diff --git a/dependencies.gradle b/dependencies.gradle
index 263c4110bb0..15a9f452b95 100644
--- a/dependencies.gradle
+++ b/dependencies.gradle
@@ -10,6 +10,10 @@ dependencies {
     // Configuration
     jarJar(modApi(forge.configuration.get()))
 
+    // Math Parser
+    jarJar(implementation(libs.evalEx.get()))
+    additionalRuntimeClasspath(libs.evalEx.get())
+
     // Mixin (& Extras)
     annotationProcessor(variantOf(libs.mixin) { classifier("processor") })
     compileOnly(annotationProcessor(forge.mixinExtras.common.get()))
@@ -118,4 +122,6 @@ 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..822ac6d82ca
--- /dev/null
+++ b/docs/content/Development/MUI2/Widget-Layout.md
@@ -0,0 +1,190 @@
+# 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)`
+- `alignX(float x)` is short for `leftRelAnchor(x, x)`
+- `alignY(float y)` is short for `topRelAnchor(y, y)`
+- `align(Alignment a)` combines `alignX(float x)` and `alignY(float y)`
+- `center()` is short for `align(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.align(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/Changes/v8.0.0.md b/docs/content/Modpacks/Changes/v8.0.0.md
index 9e9aae3f31a..fdeb7e18ec6 100644
--- a/docs/content/Modpacks/Changes/v8.0.0.md
+++ b/docs/content/Modpacks/Changes/v8.0.0.md
@@ -143,4 +143,6 @@ A large number of machine feature interfaces have been removed, and have had the
 ## Other Changes
 
 - `BlastingRecipeBuilder`, `CampfireRecipeBuilder`, `SmeltingRecipeBuilder` and `SmokingRecipeBuilder` have been merged into `SimpleCookingRecipeBuilder`
-    - Example usage: `SimpleCookingRecipeBuilder.campfireCooking("cooking_chicken").input(new ItemStack(Items.CHICKEN)).output(new ItemStacks(Items.COOKED_CHICKEN)).cookingTime(100).experience(100).save(provider);`
\ No newline at end of file
+    - Example usage: `SimpleCookingRecipeBuilder.campfireCooking("cooking_chicken").input(new ItemStack(Items.CHICKEN)).output(new ItemStacks(Items.COOKED_CHICKEN)).cookingTime(100).experience(100).save(provider);`
+- `GTFluidImpl` has been merged into `GTFluid`, use `GTFluid.Flowing` and `GTFluid.Source` instead of `GTFluidImpl.Flowing` and `GTFluidImpl.Source`.
+- Item behaviors have been moved to `common/item/behavior`, and some items have been moved from `api/item` to `common/item`
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/Materials-and-Elements/Material-Properties.md b/docs/content/Modpacks/Materials-and-Elements/Material-Properties.md
index 0108ec3c6f5..793950efaf2 100644
--- a/docs/content/Modpacks/Materials-and-Elements/Material-Properties.md
+++ b/docs/content/Modpacks/Materials-and-Elements/Material-Properties.md
@@ -102,7 +102,7 @@ Properties can be applied to a material to decide how they behave. An example of
 - `.washedIn(string fluid)`
     - `string fluid` Is what fluid it uses for if it has the ore prop and is making crushed->refined. For example, the sodium persulfate and mercury ore washing recipes.
 - `.separatedInto(list material)`
-    - `list material` Is the list of materials that are obtained when processing purified dusts in the centrifuge.
+    - `list material` Is the list of materials that are obtained when processing purified dusts in the electromagnetic seperator. There is a max of two materials.
 - `.oreSmeltInto(string material)`
     - `string material` Is what is obtained through directly smelting the ore.
   
diff --git a/gradle/forge.versions.toml b/gradle/forge.versions.toml
index 1f203aa06af..1d0db77b89f 100644
--- a/gradle/forge.versions.toml
+++ b/gradle/forge.versions.toml
@@ -11,6 +11,7 @@ ae2 = "15.0.18"
 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"
@@ -75,6 +76,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" }
@@ -116,7 +118,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 167432e271f..4ce761a0199 100644
--- a/gradle/scripts/repositories.gradle
+++ b/gradle/scripts/repositories.gradle
@@ -1,12 +1,13 @@
 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")
         }
     }
 
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 892d9e3836c..3189bc754e3 100644
--- a/src/generated/resources/assets/gtceu/lang/en_ud.json
+++ b/src/generated/resources/assets/gtceu/lang/en_ud.json
@@ -1134,6 +1134,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ɐʇı⟘",
@@ -1746,11 +1748,11 @@
   "command.gtceu.share_prospection_data.notification": "¡noʎ ɥʇıʍ ɐʇɐp buıʇɔǝdsoɹd buıɹɐɥs sı %s",
   "config.gtceu.option.addLoot": "ʇooꞀppɐ",
   "config.gtceu.option.ae2": "ᄅǝɐ",
-  "config.gtceu.option.allowDrumsInputFluidsFromOutputSide": "ǝpıSʇndʇnOɯoɹℲspınןℲʇnduIsɯnɹᗡʍoןןɐ",
   "config.gtceu.option.allowedImageDomains": "suıɐɯoᗡǝbɐɯIpǝʍoןןɐ",
   "config.gtceu.option.animationTime": "ǝɯı⟘uoıʇɐɯıuɐ",
   "config.gtceu.option.arcRecyclingYield": "pןǝıʎbuıןɔʎɔǝᴚɔɹɐ",
   "config.gtceu.option.armorHud": "pnHɹoɯɹɐ",
+  "config.gtceu.option.autoRebuildResources": "sǝɔɹnosǝᴚpןınqǝᴚoʇnɐ",
   "config.gtceu.option.batchDuration": "uoıʇɐɹnᗡɥɔʇɐq",
   "config.gtceu.option.bedrockOreDistance": "ǝɔuɐʇsıᗡǝɹOʞɔoɹpǝq",
   "config.gtceu.option.bedrockOreDropTagPrefix": "xıɟǝɹԀbɐ⟘doɹᗡǝɹOʞɔoɹpǝq",
@@ -1766,7 +1768,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",
@@ -1794,6 +1798,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⟘ǝɟ",
@@ -1845,6 +1850,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",
@@ -1865,6 +1871,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",
@@ -1878,14 +1885,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",
@@ -1897,17 +1918,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ʌ",
@@ -2018,20 +2043,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ıןʞɔɐןᗺ",
@@ -2069,6 +2092,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",
@@ -2226,6 +2250,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",
@@ -2282,7 +2310,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",
@@ -2295,6 +2324,8 @@
   "gtceu.creative_tooltip.3": "sıɥʇ ǝsn oʇ ㄥ§",
   "gtceu.cutter": "ɹǝʇʇnƆ",
   "gtceu.debug.f3_h.enabled": "ǝɹoɯ ǝǝs oʇ ǝןıɟ bıɟuoɔ ɥɔǝ⟘bǝɹ⅁ ǝɥʇ uı uoıʇdo bıɟuoɔ bnqǝp:ɔsıɯ ǝɥʇ ǝןqɐuǝ :sɹǝdoןǝʌǝᗡ ɹoℲ ¡oɟuı bnqǝp ǝɥʇ pǝıɟıpoɯ sɐɥ ɥɔǝ⟘bǝɹ⅁",
+  "gtceu.debug.resource_rebuild.done": "%s uı ǝuop pןınqǝɹ ǝɔɹnosǝɹ ǝןpɐɹ⅁",
+  "gtceu.debug.resource_rebuild.start": ")sǝɔɹnosǝᴚssǝɔoɹd: ʍǝןpɐɹb/˙( pןınqǝɹ ǝɔɹnosǝɹ ǝןpɐɹb buıʞoʌuI",
   "gtceu.direction.tooltip.back": "ʞɔɐᗺ",
   "gtceu.direction.tooltip.down": "uʍoᗡ",
   "gtceu.direction.tooltip.front": "ʇuoɹℲ",
@@ -2360,10 +2391,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ɹɐɥƆㄥ§",
@@ -2381,8 +2426,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ıᗡㄣ§",
@@ -2424,6 +2468,7 @@
   "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": "%s :ʇndʇnO 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ןℲ",
@@ -2435,6 +2480,7 @@
   "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": "%s :ʇndʇnO ɯoɹɟ ʇnduI pınןℲ",
   "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Λㄥ§",
@@ -2443,6 +2489,7 @@
   "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": "%s :ʇndʇnO ɯǝʇ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",
@@ -2454,6 +2501,8 @@
   "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": "%s :ʇndʇnO ɯoɹɟ ʇnduI ɯǝʇI",
   "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Λㄥ§",
@@ -2463,8 +2512,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",
@@ -2479,6 +2533,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,6 +2558,7 @@
   "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ㄥ§",
@@ -3029,19 +3085,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ɔǝᴚ",
@@ -3096,6 +3149,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ןןⱯ",
@@ -3338,10 +3392,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 -",
@@ -3527,6 +3580,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,ǝɹǝɥʇ ɹǝɥʇǝɥʍ >- }ǝʌıʇɔɐ{  ",
@@ -3655,6 +3716,9 @@
   "gtceu.placeholder_info.if.0": "˙0 oʇ ןɐnbǝ ʇou sı puɐ buıɹʇs ʎʇdɯǝ uɐ ʇou sı ʇı ɟı ǝnɹʇ pǝɹǝpısuoɔ sı uoıʇıpuoɔ ǝɥ⟘ ˙uoıʇıpuoɔ ǝɥʇ uo buıpuǝdǝp sʇuǝɯnbɹɐ ǝɥʇ ɟo ǝuo suɹnʇǝᴚ",
   "gtceu.placeholder_info.if.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.if.2": "}]ǝsןɐɟ‾ɟı‾pǝuɹnʇǝɹ[ >ǝnɹʇ‾ɟı‾pǝuɹnʇǝɹ< >uoıʇıpuoɔ< ɟı{  ",
+  "gtceu.placeholder_info.item.0": "ʇoןs pǝıɟıɔǝds ɐ uı ɯǝʇı ǝɥʇ ɟo pı puɐ ʇunoɯɐ ǝɥʇ suɹnʇǝᴚ",
+  "gtceu.placeholder_info.item.1": ":ǝbɐs∩",
+  "gtceu.placeholder_info.item.2": ")ǝןdɯɐxǝ ɹoɟ( \"puoɯɐıp:ʇɟɐɹɔǝuıɯ ƖƐ\" >- }>ʇoןs< ɯǝʇı{  ",
   "gtceu.placeholder_info.itemCount.0": "˙)pǝɹǝʇןıɟ ǝq uɐɔ( sɯǝʇı ɟo ʇunoɯɐ ǝɥʇ suɹnʇǝᴚ",
   "gtceu.placeholder_info.itemCount.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.itemCount.2": "ʇunoɯɐ ɯǝʇı ןɐʇoʇ >- }ʇunoƆɯǝʇı{  ",
@@ -3668,6 +3732,9 @@
   "gtceu.placeholder_info.maxProgress.1": ",%}00Ɩ * }}ssǝɹboɹԀxɐɯ{ / }ssǝɹboɹd{ ɔןɐɔ{ ɔןɐɔ{ :ssǝɹboɹԀ, :ǝןdɯɐxƎ",
   "gtceu.placeholder_info.maxProgress.2": ":ǝbɐs∩",
   "gtceu.placeholder_info.maxProgress.3": "ǝdıɔǝɹ buıuunɹ ʎןʇuǝɹɹnɔ ǝɥʇ ɟo ssǝɹboɹd xɐɯ ǝɥʇ >- }ssǝɹboɹԀxɐɯ{  ",
+  "gtceu.placeholder_info.module.0": ")ɹǝʌoɔ ɐ uı ʞɹoʍ ʇou sǝop( ɹoʇıuoɯ ןɐɹʇuǝɔ ǝɥʇ oʇuo ʇoןs pǝıɟıɔǝds ǝɥʇ uı ǝןnpoɯ ǝɥʇ sɹǝpuǝᴚ",
+  "gtceu.placeholder_info.module.1": ":ǝbɐs∩",
+  "gtceu.placeholder_info.module.2": "buıɹʇs ʎʇdɯǝ >- }>ʎ< >x< >ʇoןs< ǝןnpoɯ{  ",
   "gtceu.placeholder_info.nbt.0": "ʇoןs pǝıɟıɔǝds ǝɥʇ uı ɯǝʇı ǝɥʇ ɟo ɐʇɐp ʇqu ǝɥʇ suɹnʇǝᴚ",
   "gtceu.placeholder_info.nbt.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.nbt.2": "]˙˙˙[]Ɛʎǝʞ[]ᄅʎǝʞ[]Ɩʎǝʞ[ʇqu‾ɯǝʇı >- }˙˙˙ ]Ɛʎǝʞ[ ]ᄅʎǝʞ[ ]Ɩʎǝʞ[ >ʇoןs< ʇqu{  ",
@@ -3681,9 +3748,16 @@
   "gtceu.placeholder_info.progress.1": "}ssǝɹboɹԀxɐɯ{ puɐ 0 uǝǝʍʇǝq ɹǝbǝʇuı uɐ sı ssǝɹboɹd ʇɐɥʇ ǝʇoN",
   "gtceu.placeholder_info.progress.2": ":ǝbɐs∩",
   "gtceu.placeholder_info.progress.3": "ǝdıɔǝɹ buıuunɹ ʎןʇuǝɹɹnɔ ǝɥʇ ɟo ssǝɹboɹd ǝɥʇ >- }ssǝɹboɹd{  ",
+  "gtceu.placeholder_info.quad.0": ")sǝɔıʇɹǝʌ ㄣ ןןɐ ɹoɟ sɹǝʇǝɯɐɹɐd ʎɟıɔǝds ʇsnɯ( pɐnb ɐ sʍɐɹᗡ",
+  "gtceu.placeholder_info.quad.1": ":ǝbɐs∩",
+  "gtceu.placeholder_info.quad.2": "buıɹʇs ʎʇdɯǝ >- }>ㄣɹoןoɔ< >Ɛɹoןoɔ< >ᄅɹoןoɔ< >Ɩɹoןoɔ< >ㄣʎ< >ㄣx< >Ɛʎ< >Ɛx< >ᄅʎ< >ᄅx< >Ɩʎ< >Ɩx< pɐnb{  ",
   "gtceu.placeholder_info.random.0": "˙)ǝʌısnןɔuı( ןɐʌɹǝʇuı pǝıɟıɔǝds ǝɥʇ uı ɹǝqɯnu ɯopuɐɹ ɐ suɹnʇǝᴚ",
   "gtceu.placeholder_info.random.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.random.2": ")ǝʌısnןɔuı( xɐɯ puɐ uıɯ uǝǝʍʇǝq ɹǝqɯnu ɯopuɐɹ ɐ >- }>xɐɯ< >uıɯ< ɯopuɐɹ{  ",
+  "gtceu.placeholder_info.rect.0": "ǝzıs puɐ sǝʇɐuıpɹooɔ pǝıɟıɔǝds ǝɥʇ ɥʇıʍ uoıʇısod pǝıɟıɔǝds ǝɥʇ ʇɐ ǝןbuɐʇɔǝɹ ɐ sʍɐɹᗡ",
+  "gtceu.placeholder_info.rect.1": ":ǝbɐs∩",
+  "gtceu.placeholder_info.rect.2": "buıɹʇs ʎʇdɯǝ >- }>ᗺ⅁ᴚⱯɹoןoɔ< >ʇɥbıǝɥ< >ɥʇpıʍ< >ʎ< >x< ʇɔǝɹ{  ",
+  "gtceu.placeholder_info.rect.3": ")Ɩ 'ᄅ( ǝzıs ǝɥʇ ɥʇıʍ )ϛᄅ˙0 'ϛ˙0( ʇɐ ǝןbuɐʇɔǝɹ ǝʇıɥʍ ɐ sʍɐɹp >- }ℲℲℲℲℲℲℲℲx0 Ɩ ᄅ ϛᄅ˙0 ϛ˙0 ʇɔǝɹ{  ",
   "gtceu.placeholder_info.redstone.0": "ɥʇbuǝɹʇs ʇndʇno ǝuoʇspǝɹ ǝɥʇ sʇǝs ɹo ɥʇbuǝɹʇs ןɐubıs ǝuoʇspǝɹ ǝɥʇ suɹnʇǝᴚ",
   "gtceu.placeholder_info.redstone.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.redstone.2": "ǝpıs pǝıɟıɔǝds ǝɥʇ ʇɐ )ϛƖ-0( ɥʇbuǝɹʇs ןɐubıs ǝuoʇspǝɹ >- }>ʇsǝʍ|ʇsɐǝ|ɥʇnos|ɥʇɹou|uʍop|dn< ʇǝb ǝuoʇspǝɹ{  ",
@@ -3696,6 +3770,9 @@
   "gtceu.placeholder_info.select.0": ")0 ɯoɹɟ buıʇɹɐʇs( xǝpuı pǝıɟıɔǝds ǝɥʇ ʇɐ ʇuǝɯnbɹɐ ǝɥʇ suɹnʇǝᴚ",
   "gtceu.placeholder_info.select.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.select.2": "xǝpuı pǝıɟıɔǝds ǝɥʇ ʇɐ ʇuǝɯnbɹɐ >- ˙˙˙ ]Ɛbɹɐ[ ]ᄅbɹɐ[ ]Ɩbɹɐ[ >xǝpuı< ʇɔǝןǝs{  ",
+  "gtceu.placeholder_info.setImage.0": "ʇoןs pǝıɟıɔǝds ǝɥʇ uı ǝןnpoɯ ǝbɐɯı uɐ uı Ꞁᴚ∩ ǝbɐɯı ǝɥʇ sʇǝS",
+  "gtceu.placeholder_info.setImage.1": ":ǝbɐs∩",
+  "gtceu.placeholder_info.setImage.2": "buıɹʇs ʎʇdɯǝ >- }>ןɹn< >ʇoןs< ǝbɐɯIʇǝs{  ",
   "gtceu.placeholder_info.strike.0": "ʇno pǝssoɹɔ sɐʍ ʇı ɟı sɐ ʇı buıʎɐןdsıp 'ʇxǝʇ ʇsɹıɟ ǝɥʇ ɯoɹɟ ʇxǝʇ ǝɥʇ suɹnʇǝᴚ",
   "gtceu.placeholder_info.strike.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.strike.2": "ʇxǝʇ ʇno-pǝssoɹɔ >- }>ʇxǝʇ< ǝʞıɹʇs{  ",
@@ -4259,6 +4336,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",
diff --git a/src/generated/resources/assets/gtceu/lang/en_us.json b/src/generated/resources/assets/gtceu/lang/en_us.json
index 35d0223ccab..c64082ced62 100644
--- a/src/generated/resources/assets/gtceu/lang/en_us.json
+++ b/src/generated/resources/assets/gtceu/lang/en_us.json
@@ -1134,6 +1134,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",
@@ -1746,11 +1748,11 @@
   "command.gtceu.share_prospection_data.notification": "%s is sharing prospecting data with you!",
   "config.gtceu.option.addLoot": "addLoot",
   "config.gtceu.option.ae2": "ae2",
-  "config.gtceu.option.allowDrumsInputFluidsFromOutputSide": "allowDrumsInputFluidsFromOutputSide",
   "config.gtceu.option.allowedImageDomains": "allowedImageDomains",
   "config.gtceu.option.animationTime": "animationTime",
   "config.gtceu.option.arcRecyclingYield": "arcRecyclingYield",
   "config.gtceu.option.armorHud": "armorHud",
+  "config.gtceu.option.autoRebuildResources": "autoRebuildResources",
   "config.gtceu.option.batchDuration": "batchDuration",
   "config.gtceu.option.bedrockOreDistance": "bedrockOreDistance",
   "config.gtceu.option.bedrockOreDropTagPrefix": "bedrockOreDropTagPrefix",
@@ -1766,7 +1768,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",
@@ -1794,6 +1798,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",
@@ -1845,6 +1850,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",
@@ -1865,6 +1871,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",
@@ -1878,14 +1885,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",
@@ -1897,17 +1918,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",
@@ -2018,20 +2043,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",
@@ -2069,6 +2092,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",
@@ -2226,6 +2250,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.",
@@ -2282,7 +2310,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",
@@ -2295,6 +2324,8 @@
   "gtceu.creative_tooltip.3": "§7 to use this",
   "gtceu.cutter": "Cutter",
   "gtceu.debug.f3_h.enabled": "GregTech has modified the debug info! For Developers: enable the misc:debug config option in the GregTech config file to see more",
+  "gtceu.debug.resource_rebuild.done": "Gradle resource rebuild done in %s",
+  "gtceu.debug.resource_rebuild.start": "Invoking gradle resource rebuild (./gradlew :processResources)",
   "gtceu.direction.tooltip.back": "Back",
   "gtceu.direction.tooltip.down": "Down",
   "gtceu.direction.tooltip.front": "Front",
@@ -2360,10 +2391,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",
@@ -2381,8 +2426,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",
@@ -2424,6 +2468,7 @@
   "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": "Fluid Output: %s",
   "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",
@@ -2435,6 +2480,7 @@
   "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": "Fluid Input from Output: %s",
   "gtceu.gui.fluid_lock.tooltip.disabled": "Fluid Locking Disabled",
   "gtceu.gui.fluid_lock.tooltip.enabled": "Fluid Locking Enabled",
   "gtceu.gui.fluid_voiding": "§7Voiding §9Fluids",
@@ -2443,6 +2489,7 @@
   "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": "Item Output: %s",
   "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",
@@ -2454,6 +2501,8 @@
   "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": "Item Input from Output: %s",
   "gtceu.gui.item_lock.tooltip.disabled": "Item Locking Disabled",
   "gtceu.gui.item_lock.tooltip.enabled": "Item Locking Enabled",
   "gtceu.gui.item_voiding": "§7Voiding §6Items",
@@ -2463,8 +2512,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",
@@ -2479,6 +2533,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,6 +2558,7 @@
   "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",
@@ -3029,19 +3085,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",
@@ -3096,6 +3149,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.",
@@ -3338,10 +3392,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)",
@@ -3527,6 +3580,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",
@@ -3655,6 +3716,9 @@
   "gtceu.placeholder_info.if.0": "Returns one of the arguments depending on the condition. The condition is considered true if it is not an empty string and is not equal to 0.",
   "gtceu.placeholder_info.if.1": "Usage:",
   "gtceu.placeholder_info.if.2": "  {if <condition> <returned_if_true> [returned_if_false]}",
+  "gtceu.placeholder_info.item.0": "Returns the amount and id of the item in a specified slot",
+  "gtceu.placeholder_info.item.1": "Usage:",
+  "gtceu.placeholder_info.item.2": "  {item <slot>} -> \"31 minecraft:diamond\" (for example)",
   "gtceu.placeholder_info.itemCount.0": "Returns the amount of items (can be filtered).",
   "gtceu.placeholder_info.itemCount.1": "Usage:",
   "gtceu.placeholder_info.itemCount.2": "  {itemCount} -> total item amount",
@@ -3668,6 +3732,9 @@
   "gtceu.placeholder_info.maxProgress.1": "Example: 'Progress: {calc {calc {progress} / {maxProgress}} * 100}%'",
   "gtceu.placeholder_info.maxProgress.2": "Usage:",
   "gtceu.placeholder_info.maxProgress.3": "  {maxProgress} -> the max progress of the currently running recipe",
+  "gtceu.placeholder_info.module.0": "Renders the module in the specified slot onto the central monitor (does not work in a cover)",
+  "gtceu.placeholder_info.module.1": "Usage:",
+  "gtceu.placeholder_info.module.2": "  {module <slot> <x> <y>} -> empty string",
   "gtceu.placeholder_info.nbt.0": "Returns the nbt data of the item in the specified slot",
   "gtceu.placeholder_info.nbt.1": "Usage:",
   "gtceu.placeholder_info.nbt.2": "  {nbt <slot> [key1] [key2] [key3] ...} -> item_nbt[key1][key2][key3][...]",
@@ -3681,9 +3748,16 @@
   "gtceu.placeholder_info.progress.1": "Note that progress is an integer between 0 and {maxProgress}",
   "gtceu.placeholder_info.progress.2": "Usage:",
   "gtceu.placeholder_info.progress.3": "  {progress} -> the progress of the currently running recipe",
+  "gtceu.placeholder_info.quad.0": "Draws a quad (must specify parameters for all 4 vertices)",
+  "gtceu.placeholder_info.quad.1": "Usage:",
+  "gtceu.placeholder_info.quad.2": "  {quad <x1> <y1> <x2> <y2> <x3> <y3> <x4> <y4> <color1> <color2> <color3> <color4>} -> empty string",
   "gtceu.placeholder_info.random.0": "Returns a random number in the specified interval (inclusive).",
   "gtceu.placeholder_info.random.1": "Usage:",
   "gtceu.placeholder_info.random.2": "  {random <min> <max>} -> a random number between min and max (inclusive)",
+  "gtceu.placeholder_info.rect.0": "Draws a rectangle at the specified position with the specified coordinates and size",
+  "gtceu.placeholder_info.rect.1": "Usage:",
+  "gtceu.placeholder_info.rect.2": "  {rect <x> <y> <width> <height> <colorARGB>} -> empty string",
+  "gtceu.placeholder_info.rect.3": "  {rect 0.5 0.25 2 1 0xFFFFFFFF} -> draws a white rectangle at (0.5, 0.25) with the size (2, 1)",
   "gtceu.placeholder_info.redstone.0": "Returns the redstone signal strength or sets the redstone output strength",
   "gtceu.placeholder_info.redstone.1": "Usage:",
   "gtceu.placeholder_info.redstone.2": "  {redstone get <up|down|north|south|east|west>} -> redstone signal strength (0-15) at the specified side",
@@ -3696,6 +3770,9 @@
   "gtceu.placeholder_info.select.0": "Returns the argument at the specified index (starting from 0)",
   "gtceu.placeholder_info.select.1": "Usage:",
   "gtceu.placeholder_info.select.2": "  {select <index> [arg1] [arg2] [arg3] ... -> argument at the specified index",
+  "gtceu.placeholder_info.setImage.0": "Sets the image URL in an image module in the specified slot",
+  "gtceu.placeholder_info.setImage.1": "Usage:",
+  "gtceu.placeholder_info.setImage.2": "  {setImage <slot> <url>} -> empty string",
   "gtceu.placeholder_info.strike.0": "Returns the text from the first text, displaying it as if it was crossed out",
   "gtceu.placeholder_info.strike.1": "Usage:",
   "gtceu.placeholder_info.strike.2": "  {strike <text>} -> crossed-out text",
@@ -4259,6 +4336,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",
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/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/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java b/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java
index 35c816d2bc4..58aaac61653 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java
@@ -284,9 +284,14 @@ 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);
+            } else if (machine instanceof IUIMachine uiMachine) {
+                return uiMachine.tryToOpenUI(player, hand, hit);
+            }
         }
         return shouldOpenUi ? InteractionResult.PASS : InteractionResult.CONSUME;
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/block/PipeBlock.java b/src/main/java/com/gregtechceu/gtceu/api/block/PipeBlock.java
index c16c3d6a2c3..965831da9f8 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/block/PipeBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/block/PipeBlock.java
@@ -18,7 +18,7 @@
 import com.gregtechceu.gtceu.client.model.pipe.PipeModel;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
-import com.gregtechceu.gtceu.common.item.CoverPlaceBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.CoverPlaceBehavior;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.VanillaRecipeHelper;
 import com.gregtechceu.gtceu.utils.GTMath;
@@ -271,6 +271,7 @@ public void neighborChanged(BlockState state, Level level, BlockPos pos, Block b
                     pipeTile.setConnection(facing, false, false);
                 updateActiveNodeStatus(level, pos, pipeTile);
             }
+            pipeTile.getCoverContainer().onNeighborChanged(block, fromPos, isMoving);
         }
     }
 
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 b4fce4cded1..de39df64b52 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/blockentity/PipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/blockentity/PipeBlockEntity.java
@@ -7,10 +7,10 @@
 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;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 import com.gregtechceu.gtceu.api.pipenet.*;
 import com.gregtechceu.gtceu.api.sync_system.ManagedSyncBlockEntity;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
@@ -18,10 +18,9 @@
 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.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -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/forge/GTCapability.java b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java
similarity index 96%
rename from src/main/java/com/gregtechceu/gtceu/api/capability/forge/GTCapability.java
rename to src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java
index f26b143cd3f..66a0aa5c6b3 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/forge/GTCapability.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java
@@ -1,6 +1,5 @@
-package com.gregtechceu.gtceu.api.capability.forge;
+package com.gregtechceu.gtceu.api.capability;
 
-import com.gregtechceu.gtceu.api.capability.*;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 
 import net.minecraftforge.common.capabilities.Capability;
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 1bf8262ac7e..ddd096e5fab 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java
@@ -1,6 +1,5 @@
 package com.gregtechceu.gtceu.api.capability;
 
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 
 import net.minecraft.core.BlockPos;
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..89289292be3 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/IMonitorComponent.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/IMonitorComponent.java
@@ -1,6 +1,6 @@
 package com.gregtechceu.gtceu.api.capability;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
 
 import net.minecraft.core.BlockPos;
 import net.minecraftforge.items.IItemHandler;
@@ -13,7 +13,7 @@ default boolean isMonitor() {
         return false;
     }
 
-    IGuiTexture getComponentIcon();
+    IDrawable getIcon();
 
     BlockPos getBlockPos();
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/compat/EUToFEProvider.java b/src/main/java/com/gregtechceu/gtceu/api/capability/compat/EUToFEProvider.java
index 619d7904dec..b3b025c8f1a 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/compat/EUToFEProvider.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/compat/EUToFEProvider.java
@@ -1,8 +1,8 @@
 package com.gregtechceu.gtceu.api.capability.compat;
 
 import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IEnergyContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.GTUtil;
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..e1ffe4dbb08 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,6 +1,7 @@
 package com.gregtechceu.gtceu.api.capability.recipe;
 
 import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 
 import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
 import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
@@ -21,10 +22,13 @@ public enum IO implements EnumSelectorWidget.SelectableEnum {
     public final String tooltip;
     @Getter
     public final IGuiTexture icon;
+    @Getter
+    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/capability/recipe/RecipeCapability.java b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/RecipeCapability.java
index 28df149687e..6d2a54badc1 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/RecipeCapability.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/RecipeCapability.java
@@ -1,6 +1,5 @@
 package com.gregtechceu.gtceu.api.capability.recipe;
 
-import com.gregtechceu.gtceu.api.codec.DispatchedMapCodec;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.content.Content;
@@ -9,6 +8,7 @@
 import com.gregtechceu.gtceu.api.recipe.lookup.ingredient.AbstractMapIngredient;
 import com.gregtechceu.gtceu.api.recipe.ui.GTRecipeTypeUI;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.utils.codec.DispatchedMapCodec;
 
 import com.lowdragmc.lowdraglib.gui.widget.Widget;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
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 7da44721bec..6707d76e5e6 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/CoverBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/CoverBehavior.java
@@ -2,22 +2,19 @@
 
 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.drawable.UITexture;
 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.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -80,9 +77,7 @@ public void scheduleRenderUpdate() {
 
     @Override
     public void markAsChanged() {
-        if (coverHolder instanceof ManagedSyncBlockEntity syncEntity) {
-            syncEntity.markAsChanged();
-        }
+        coverHolder.markAsChanged();
     }
 
     /**
@@ -109,6 +104,7 @@ public void onAttached(ItemStack itemStack, @Nullable ServerPlayer player) {
         attachItem = itemStack.copy();
         attachItem.setCount(1);
         syncDataHolder.markClientSyncFieldDirty("attachItem");
+        markAsChanged();
     }
 
     public void onLoad() {}
@@ -151,9 +147,9 @@ public boolean canConnectRedstone() {
     // ******* Interaction *******//
     //////////////////////////////////////
     public InteractionResult onScrewdriverClick(Player playerIn, InteractionHand hand, BlockHitResult hitResult) {
-        if (this instanceof IUICover) {
+        if (this instanceof IMuiCover muiCover) {
             if (playerIn instanceof ServerPlayer serverPlayer) {
-                CoverUIFactory.INSTANCE.openUI(this, serverPlayer);
+                com.gregtechceu.gtceu.common.mui.factory.CoverUIFactory.INSTANCE.open(serverPlayer, muiCover);
             }
             return InteractionResult.sidedSuccess(playerIn.level().isClientSide);
         }
@@ -190,17 +186,17 @@ public boolean shouldRenderPlate() {
     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;
     }
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..421813e3f09
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/IMuiCover.java
@@ -0,0 +1,79 @@
+package com.gregtechceu.gtceu.api.cover;
+
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+
+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
+    default ModularPanel buildUI(SidedPosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        ModularPanel panel = GTGuis.createPanel(this.self(), 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..ebfa18add97 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,5 +1,10 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 
 import net.minecraft.nbt.CompoundTag;
@@ -9,7 +14,14 @@
 
 public interface Filter<T, S extends Filter<T, S>> extends Predicate<T> {
 
-    WidgetGroup openConfigurator(int x, int y);
+    default WidgetGroup openConfigurator(int x, int y) {
+        return null;
+    }
+
+    /**
+     * @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..7518f95f5e1 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
@@ -53,16 +53,16 @@ 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 abstract boolean canInsertFilterItem(ItemStack itemStack);
+
     public Widget createFilterSlotUI(int xPos, int yPos) {
         return new SlotWidget(getFilterSlot(), 0, xPos, yPos)
                 .setChangeListener(this::updateFilter)
@@ -117,7 +117,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) {
 
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..a5d3798d362 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,6 +1,9 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.item.ItemStack;
@@ -54,8 +57,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..695bfa8bf22 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,6 +1,9 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.item.ItemStack;
@@ -53,8 +56,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..0878f01e712 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,21 @@
 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.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.Dialog;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
-
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
@@ -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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(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..27cad35ac54 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,13 +1,24 @@
 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.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.PhantomItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.widgets.Dialog;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.PhantomItemSlot;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -15,6 +26,7 @@
 import net.minecraft.world.item.ItemStack;
 
 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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(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..f8ad51ce5cc 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,38 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.ColorType;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.Dialog;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.content.Content;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
+import lombok.Getter;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.function.Consumer;
 
@@ -25,6 +41,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 +86,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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(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
@@ -134,6 +163,13 @@ public String getTooltip() {
             return "cover.item_smart_filter.filtering_mode." + localeName;
         }
 
+        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);
+        }
+
         @Override
         public IGuiTexture getIcon() {
             return new ResourceTexture("gtceu:textures/block/machines/" + localeName + "/overlay_front.png");
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..2dce613ee5d 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.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.StringSyncValue;
+import com.gregtechceu.gtceu.api.mui.widgets.Dialog;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 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().addMultiLine("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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(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/properties/HazardProperty.java b/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/properties/HazardProperty.java
index 64ce68c8eba..6f3a184a71a 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
@@ -6,10 +6,10 @@
 import com.gregtechceu.gtceu.api.data.chemical.material.stack.MaterialEntry;
 import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
-import com.gregtechceu.gtceu.api.item.GTBucketItem;
 import com.gregtechceu.gtceu.api.item.TagPrefixItem;
 import com.gregtechceu.gtceu.api.item.armor.ArmorComponentItem;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.item.GTBucketItem;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 
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/fluids/GTFluid.java b/src/main/java/com/gregtechceu/gtceu/api/fluids/GTFluid.java
index 05fbacab74c..d39b11ff44f 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/fluids/GTFluid.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/fluids/GTFluid.java
@@ -17,9 +17,12 @@
 import net.minecraft.world.level.block.LiquidBlock;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
 import net.minecraft.world.level.material.FlowingFluid;
 import net.minecraft.world.level.material.Fluid;
 import net.minecraft.world.level.material.Fluids;
+import net.minecraftforge.common.extensions.IForgeFluid;
+import net.minecraftforge.fluids.FluidType;
 
 import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet;
 import lombok.Getter;
@@ -32,7 +35,7 @@
 
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
-public abstract class GTFluid extends FlowingFluid implements IAttributedFluid {
+public abstract class GTFluid extends FlowingFluid implements IAttributedFluid, IForgeFluid {
 
     @Getter
     private final Collection<FluidAttribute> attributes = new ObjectLinkedOpenHashSet<>();
@@ -44,10 +47,11 @@ public abstract class GTFluid extends FlowingFluid implements IAttributedFluid {
     private final Supplier<? extends LiquidBlock> block;
     @Getter
     private final int burnTime;
+    private final Supplier<FluidType> fluidType;
 
-    public GTFluid(@NotNull FluidState state, Supplier<? extends Fluid> stillFluid,
+    public GTFluid(FluidState state, Supplier<? extends Fluid> stillFluid,
                    Supplier<? extends Fluid> flowingFluid, Supplier<? extends LiquidBlock> block,
-                   Supplier<? extends Item> bucket, int burnTime) {
+                   Supplier<? extends Item> bucket, int burnTime, Supplier<FluidType> fluidType) {
         super();
         this.state = state;
         this.stillFluid = stillFluid;
@@ -55,10 +59,11 @@ public GTFluid(@NotNull FluidState state, Supplier<? extends Fluid> stillFluid,
         this.block = block;
         this.bucketItem = bucket;
         this.burnTime = burnTime;
+        this.fluidType = fluidType;
     }
 
     @Override
-    public void addAttribute(@NotNull FluidAttribute attribute) {
+    public void addAttribute(FluidAttribute attribute) {
         attributes.add(attribute);
     }
 
@@ -127,4 +132,52 @@ public boolean isSame(Fluid fluid) {
         boolean flowing = this.getFlowing() == fluid;
         return still || flowing;
     }
+
+    public FluidType getFluidType() {
+        return fluidType.get();
+    }
+
+    public static class Source extends GTFluid {
+
+        public Source(FluidState state, Supplier<? extends Fluid> stillFluid,
+                      Supplier<? extends Fluid> flowingFluid, Supplier<? extends LiquidBlock> block,
+                      Supplier<? extends Item> bucket, int burnTime, Supplier<FluidType> fluidType) {
+            super(state, stillFluid, flowingFluid, block, bucket, burnTime, fluidType);
+        }
+
+        @Override
+        public int getAmount(net.minecraft.world.level.material.FluidState state) {
+            return 8;
+        }
+
+        @Override
+        public boolean isSource(net.minecraft.world.level.material.FluidState state) {
+            return true;
+        }
+    }
+
+    public static class Flowing extends GTFluid {
+
+        public Flowing(FluidState state, Supplier<? extends Fluid> stillFluid,
+                       Supplier<? extends Fluid> flowingFluid, Supplier<? extends LiquidBlock> block,
+                       Supplier<? extends Item> bucket, int burnTime, Supplier<FluidType> fluidType) {
+            super(state, stillFluid, flowingFluid, block, bucket, burnTime, fluidType);
+            // registerDefaultState(getStateDefinition().any().setValue(LEVEL, 7));
+        }
+
+        protected void createFluidStateDefinition(StateDefinition.@NotNull Builder<Fluid, net.minecraft.world.level.material.FluidState> builder) {
+            super.createFluidStateDefinition(builder);
+            builder.add(LEVEL);
+        }
+
+        @Override
+        public int getAmount(net.minecraft.world.level.material.FluidState state) {
+            return state.getValue(LEVEL);
+        }
+
+        @Override
+        public boolean isSource(net.minecraft.world.level.material.FluidState state) {
+            return false;
+        }
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/fluids/forge/GTFluidImpl.java b/src/main/java/com/gregtechceu/gtceu/api/fluids/forge/GTFluidImpl.java
deleted file mode 100644
index cbc6e009b09..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/fluids/forge/GTFluidImpl.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package com.gregtechceu.gtceu.api.fluids.forge;
-
-import com.gregtechceu.gtceu.api.fluids.FluidState;
-import com.gregtechceu.gtceu.api.fluids.GTFluid;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.sounds.SoundEvent;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.level.block.LiquidBlock;
-import net.minecraft.world.level.block.state.StateDefinition;
-import net.minecraft.world.level.material.Fluid;
-import net.minecraftforge.common.SoundActions;
-import net.minecraftforge.common.extensions.IForgeFluid;
-import net.minecraftforge.fluids.FluidType;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Optional;
-import java.util.function.Supplier;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public abstract class GTFluidImpl extends GTFluid implements IForgeFluid {
-
-    private final Supplier<FluidType> fluidType;
-
-    public GTFluidImpl(@NotNull FluidState state, Supplier<? extends Fluid> stillFluid,
-                       Supplier<? extends Fluid> flowingFluid, Supplier<? extends LiquidBlock> block,
-                       Supplier<? extends Item> bucket, int burnTime, Supplier<FluidType> fluidType) {
-        super(state, stillFluid, flowingFluid, block, bucket, burnTime);
-        this.fluidType = fluidType;
-    }
-
-    @Override
-    public FluidType getFluidType() {
-        return fluidType.get();
-    }
-
-    @Override
-    public Optional<SoundEvent> getPickupSound() {
-        return fluidType != null && fluidType.get() != null ?
-                Optional.ofNullable(fluidType.get().getSound(SoundActions.BUCKET_FILL)) : Optional.empty();
-    }
-
-    public static class Source extends GTFluidImpl {
-
-        public Source(@NotNull FluidState state, Supplier<? extends Fluid> stillFluid,
-                      Supplier<? extends Fluid> flowingFluid, Supplier<? extends LiquidBlock> block,
-                      Supplier<? extends Item> bucket, int burnTime, Supplier<FluidType> fluidType) {
-            super(state, stillFluid, flowingFluid, block, bucket, burnTime, fluidType);
-        }
-
-        @Override
-        public int getAmount(net.minecraft.world.level.material.FluidState state) {
-            return 8;
-        }
-
-        @Override
-        public boolean isSource(net.minecraft.world.level.material.FluidState state) {
-            return true;
-        }
-    }
-
-    public static class Flowing extends GTFluidImpl {
-
-        public Flowing(@NotNull FluidState state, Supplier<? extends Fluid> stillFluid,
-                       Supplier<? extends Fluid> flowingFluid, Supplier<? extends LiquidBlock> block,
-                       Supplier<? extends Item> bucket, int burnTime, Supplier<FluidType> fluidType) {
-            super(state, stillFluid, flowingFluid, block, bucket, burnTime, fluidType);
-            // registerDefaultState(getStateDefinition().any().setValue(LEVEL, 7));
-        }
-
-        protected void createFluidStateDefinition(StateDefinition.@NotNull Builder<Fluid, net.minecraft.world.level.material.FluidState> builder) {
-            super.createFluidStateDefinition(builder);
-            builder.add(LEVEL);
-        }
-
-        @Override
-        public int getAmount(net.minecraft.world.level.material.FluidState state) {
-            return state.getValue(LEVEL);
-        }
-
-        @Override
-        public boolean isSource(net.minecraft.world.level.material.FluidState state) {
-            return false;
-        }
-    }
-}
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/fancy/ConfiguratorPanel.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/ConfiguratorPanel.java
index 6ab93be46bc..4762dfeb273 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/ConfiguratorPanel.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/ConfiguratorPanel.java
@@ -444,6 +444,6 @@ public void onClose(Runnable closeCallback) {
     }
 
     private static int getAnimationTime() {
-        return ConfigHolder.INSTANCE.client.animationTime;
+        return ConfigHolder.INSTANCE.client.ui.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
index 5e62d3bf958..a9891226b20 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/FancyMachineUIWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/FancyMachineUIWidget.java
@@ -71,7 +71,7 @@ public FancyMachineUIWidget(IFancyUIProvider mainPage, int width, int height) {
         this.pageSwitcher = new PageSwitcher(this::switchPage);
 
         setBackground(GuiTextures.BACKGROUND.copy()
-                .setColor(Long.decode(ConfigHolder.INSTANCE.client.defaultUIColor).intValue() | 0xFF000000));
+                .setColor(Long.decode(ConfigHolder.INSTANCE.client.ui.defaultUIColor).intValue() | 0xFF000000));
     }
 
     @Override
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
index a7253922ede..a2197e6d1ff 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/CoverConfigurator.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/CoverConfigurator.java
@@ -2,8 +2,6 @@
 
 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;
 
@@ -12,7 +10,6 @@
 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;
@@ -42,17 +39,6 @@ public IGuiTexture getIcon() {
 
     @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;
+        return new WidgetGroup(new Position(0, 0));
     }
 }
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
index c10f85179b8..26a37530d1c 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/GhostCircuitSlotWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/GhostCircuitSlotWidget.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.api.gui.widget;
 
 import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
 import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
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/ProspectingMapWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ProspectingMapWidget.java
index 69147b9a09b..56afaf9f62b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ProspectingMapWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ProspectingMapWidget.java
@@ -5,7 +5,7 @@
 import com.gregtechceu.gtceu.api.gui.misc.ProspectorMode;
 import com.gregtechceu.gtceu.api.gui.texture.ProspectingTexture;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
-import com.gregtechceu.gtceu.common.item.ProspectorScannerBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.ProspectorScannerBehavior;
 import com.gregtechceu.gtceu.integration.map.WaypointManager;
 import com.gregtechceu.gtceu.integration.map.cache.client.GTClientCache;
 import com.gregtechceu.gtceu.integration.map.cache.server.ServerCache;
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/directional/handlers/CoverableConfigHandler.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/CoverableConfigHandler.java
index a6a30fd5190..a6afc7eebb4 100644
--- 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
@@ -2,18 +2,16 @@
 
 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.CoverPlaceBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.CoverPlaceBehavior;
 
 import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
 import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
@@ -21,8 +19,6 @@
 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;
@@ -88,9 +84,6 @@ public boolean canPutStack(ItemStack stack) {
         }
                 .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;
@@ -171,24 +164,6 @@ public Component getTitle() {
             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);
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..4c3b171a546 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java
@@ -1,9 +1,15 @@
 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.base.IItemUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 
 import com.lowdragmc.lowdraglib.client.renderer.IItemRendererProvider;
 import com.lowdragmc.lowdraglib.client.renderer.IRenderer;
@@ -49,7 +55,8 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class ComponentItem extends Item
-                           implements HeldItemUIFactory.IHeldItemUIHolder, IItemRendererProvider, IComponentItem {
+                           implements HeldItemUIFactory.IHeldItemUIHolder, IItemRendererProvider, IComponentItem,
+                           IItemUIHolder {
 
     protected int burnTime = -1;
 
@@ -443,4 +450,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..52cd3a1bd0f 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,17 @@
 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.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.sound.SoundEntry;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 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;
@@ -83,7 +85,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 +880,15 @@ default void playSound(Player player) {
     }
 
     @Override
-    default ModularUI createUI(Player player, HeldItemUIFactory.HeldItemHolder holder) {
+    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/component/ElectricStats.java b/src/main/java/com/gregtechceu/gtceu/api/item/component/ElectricStats.java
index 0d79562c552..1ec8ee3c7ce 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/component/ElectricStats.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/component/ElectricStats.java
@@ -2,10 +2,10 @@
 
 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.capability.IElectricItem;
 import com.gregtechceu.gtceu.api.capability.compat.FeCompat;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.item.capability.ElectricItem;
 import com.gregtechceu.gtceu.api.item.component.forge.IComponentCapability;
 import com.gregtechceu.gtceu.client.renderer.item.ToolChargeBarRenderer;
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..2ee8ac3ab2b 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
@@ -1,12 +1,12 @@
 package com.gregtechceu.gtceu.api.item.component;
 
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.placeholder.PlaceholderContext;
 import com.gregtechceu.gtceu.client.renderer.monitor.IMonitorRenderer;
 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;
 
 public interface IMonitorModuleItem extends IItemComponent {
@@ -15,9 +15,10 @@ default void tick(ItemStack stack, CentralMonitorMachine machine, MonitorGroup g
 
     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/tool/IToolGridHighlight.java b/src/main/java/com/gregtechceu/gtceu/api/item/tool/IToolGridHighlight.java
index a79ccf07b39..a37a8d35947 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,6 +1,6 @@
 package com.gregtechceu.gtceu.api.item.tool;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -19,8 +19,8 @@ default boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state,
         return true;
     }
 
-    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..1349f8fcaff 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,9 +1,9 @@
 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.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryUIFactory;
 
-import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResultHolder;
 import net.minecraft.world.entity.player.Player;
@@ -12,20 +12,17 @@
 
 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);
-
-    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/MachineDefinition.java b/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java
index 01b6204239c..a3f82df3984 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java
@@ -6,12 +6,13 @@
 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.mui.theme.ThemeAPI;
 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;
@@ -125,6 +126,13 @@ public class MachineDefinition implements Supplier<MetaMachineBlock> {
     private EditableMachineUI editableUI;
     @Getter
     @Setter
+    @Nullable
+    private PanelFactory UI;
+    @Getter
+    @Setter
+    private String themeId = ThemeAPI.DEFAULT_ID;
+    @Getter
+    @Setter
     private Reference2IntMap<RecipeCapability<?>> recipeOutputLimits = new Reference2IntOpenHashMap<>();
 
     @Getter
@@ -164,7 +172,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 7609d198079..eb34211707e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java
@@ -9,7 +9,7 @@
 import com.gregtechceu.gtceu.api.blockentity.IGregtechBlockEntity;
 import com.gregtechceu.gtceu.api.blockentity.IPaintable;
 import com.gregtechceu.gtceu.api.capability.*;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.data.RotationState;
@@ -29,6 +29,7 @@
 import com.gregtechceu.gtceu.api.machine.trait.feature.IInteractionTrait;
 import com.gregtechceu.gtceu.api.machine.trait.feature.IRenderingTrait;
 import com.gregtechceu.gtceu.api.misc.*;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.sync_system.ManagedSyncBlockEntity;
 import com.gregtechceu.gtceu.api.sync_system.SyncDataHolder;
@@ -44,11 +45,11 @@
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
 import com.gregtechceu.gtceu.common.machine.owner.MachineOwner;
 import com.gregtechceu.gtceu.common.machine.owner.PlayerOwner;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.GTUtil;
 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;
@@ -80,7 +81,6 @@
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 import net.minecraftforge.client.model.data.ModelData;
-import net.minecraftforge.client.model.data.ModelProperty;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.common.capabilities.ForgeCapabilities;
 import net.minecraftforge.common.util.LazyOptional;
@@ -103,9 +103,6 @@
 public class MetaMachine extends ManagedSyncBlockEntity implements IGregtechBlockEntity, IToolable, IToolGridHighlight,
                          IFancyTooltip, IPaintable, IMachineFeature, ICopyable {
 
-    public static final ModelProperty<BlockAndTintGetter> MODEL_DATA_LEVEL = new ModelProperty<>();
-    public static final ModelProperty<BlockPos> MODEL_DATA_POS = new ModelProperty<>();
-
     @Getter
     protected final SyncDataHolder syncDataHolder = new SyncDataHolder(this);
 
@@ -423,7 +420,7 @@ public InteractionResult onUse(BlockState state, Level world, BlockPos pos, Play
 
     /**
      * Called when a machine is left clicked.
-     * 
+     *
      * @return true to cancel the click event, false to continue processing
      */
     public boolean onLeftClick(Player player, Level world, InteractionHand hand, BlockPos pos,
@@ -511,8 +508,8 @@ 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) {
         var cover = coverContainer.getCoverAtSide(side);
         if (cover != null) {
             var tips = cover.sideTips(player, pos, state, toolTypes, side);
@@ -522,16 +519,16 @@ public boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state, I
         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;
             }
         }
 
@@ -630,7 +627,7 @@ public void setFrontFacing(Direction facing) {
     }
 
     @Override
-    public @NotNull ModelData getModelData() {
+    public ModelData getModelData() {
         ModelData.Builder data = super.getModelData().derive();
         updateModelData(data);
         return data.build();
@@ -641,7 +638,7 @@ public Direction getUpwardsFacing() {
                 Direction.NORTH;
     }
 
-    public void setUpwardsFacing(@NotNull Direction upwardsFacing) {
+    public void setUpwardsFacing(Direction upwardsFacing) {
         if (!getDefinition().isAllowExtendedFacing()) {
             return;
         }
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 1e23a3f118b..b8028072fa6 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleGeneratorMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleGeneratorMachine.java
@@ -3,47 +3,29 @@
 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.IEnvironmentalHazardEmitter;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
 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.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 org.jetbrains.annotations.NotNull;
 
-import java.util.Collections;
-import java.util.EnumMap;
-import java.util.LinkedHashMap;
-import java.util.function.BiFunction;
-
-public class SimpleGeneratorMachine extends WorkableTieredMachine
-                                    implements IFancyUIMachine, IEnvironmentalHazardEmitter {
+public class SimpleGeneratorMachine extends WorkableTieredMachine {
 
     @Getter
-    private final float hazardStrengthPerOperation;
+    private final EnvironmentalHazardEmitterTrait hazardEmitter;
 
     public SimpleGeneratorMachine(BlockEntityCreationInfo info, int tier,
                                   float hazardStrengthPerOperation, Int2IntFunction tankScalingFunction) {
         super(info, tier, tankScalingFunction);
 
         energyContainer.setSideOutputCondition(side -> !hasFrontFacing() || side == getFrontFacing());
-        this.hazardStrengthPerOperation = hazardStrengthPerOperation;
+        this.hazardEmitter = new EnvironmentalHazardEmitterTrait(this, GTMedicalConditions.CARBON_MONOXIDE_POISONING,
+                hazardStrengthPerOperation);
     }
 
     public SimpleGeneratorMachine(BlockEntityCreationInfo info, int tier, Int2IntFunction tankScalingFunction) {
@@ -81,7 +63,7 @@ public int tintColor(int index) {
      * @param recipe  recipe
      * @return A {@link ModifierFunction} for the given Simple Generator
      */
-    public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @NotNull GTRecipe recipe) {
+    public static ModifierFunction recipeModifier(MetaMachine machine, GTRecipe recipe) {
         if (!(machine instanceof SimpleGeneratorMachine generator)) {
             return RecipeModifier.nullWrongType(SimpleGeneratorMachine.class, machine);
         }
@@ -112,47 +94,11 @@ public boolean canVoidRecipeOutputs(RecipeCapability<?> capability) {
     @Override
     public void afterWorking() {
         super.afterWorking();
-        spreadEnvironmentalHazard();
+        hazardEmitter.emitHazard();
     }
 
     @Override
     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 e2e3a655937..2e8fac0951b 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,16 @@
 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.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.trait.AutoOutputTrait;
 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.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 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 +25,7 @@
  * All simple single machines are implemented here.
  */
 public class SimpleTieredMachine extends WorkableTieredMachine
-                                 implements IFancyUIMachine, IHasCircuitSlot {
+                                 implements IHasCircuitSlot {
 
     @Getter
     @SaveField
@@ -144,143 +118,4 @@ public void onMachineDestroyed() {
     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/WorkableTieredMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java
index ed3e732e423..79597e7496e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java
@@ -90,11 +90,11 @@ public WorkableTieredMachine(BlockEntityCreationInfo info, int tier, Int2IntFunc
         this.cleanroomReceiver = new CleanroomReceiverTrait(this);
         this.recipeLogic = new RecipeLogic(this);
         this.importItems = new NotifiableItemStackHandler(this, getRecipeType().getMaxInputs(ItemRecipeCapability.CAP),
-                IO.IN);
+                IO.IN, IO.BOTH);
         this.exportItems = new NotifiableItemStackHandler(this, getRecipeType().getMaxOutputs(ItemRecipeCapability.CAP),
                 IO.OUT);
         this.importFluids = new NotifiableFluidTank(this, getRecipeType().getMaxInputs(FluidRecipeCapability.CAP),
-                tankScalingFunction.applyAsInt(getTier()), IO.IN);
+                tankScalingFunction.applyAsInt(getTier()), IO.IN, IO.BOTH);
         this.exportFluids = new NotifiableFluidTank(this, getRecipeType().getMaxOutputs(FluidRecipeCapability.CAP),
                 tankScalingFunction.applyAsInt(getTier()), IO.OUT);
         this.importComputation = new NotifiableComputationContainer(this, IO.IN, true);
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
index 522673f4fc7..dec55d9951c 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CircuitFancyConfigurator.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CircuitFancyConfigurator.java
@@ -5,7 +5,7 @@
 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.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.lang.LangHandler;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IDataInfoProvider.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IDataInfoProvider.java
index da3d9a5f14c..534effbce38 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IDataInfoProvider.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IDataInfoProvider.java
@@ -1,6 +1,6 @@
 package com.gregtechceu.gtceu.api.machine.feature;
 
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.entity.player.Player;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IEnvironmentalHazardCleaner.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IEnvironmentalHazardCleaner.java
deleted file mode 100644
index cdb7b0e7709..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IEnvironmentalHazardCleaner.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature;
-
-import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
-
-public interface IEnvironmentalHazardCleaner extends IMachineFeature {
-
-    float getRemovedLastSecond();
-
-    void cleanHazard(MedicalCondition condition, float amount);
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IEnvironmentalHazardEmitter.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IEnvironmentalHazardEmitter.java
deleted file mode 100644
index 4d4edb0c46e..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IEnvironmentalHazardEmitter.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature;
-
-import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
-import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
-import com.gregtechceu.gtceu.api.data.chemical.material.properties.HazardProperty;
-import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
-import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
-import com.gregtechceu.gtceu.common.data.GTMedicalConditions;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-
-import net.minecraft.server.level.ServerLevel;
-
-/**
- * common interface for environmental hazard (e.g. pollution) emitters like mufflers.
- */
-public interface IEnvironmentalHazardEmitter extends IMachineFeature {
-
-    /**
-     * @return the medical condition this hazard emitter creates.
-     */
-    default MedicalCondition getConditionToEmit() {
-        return GTMedicalConditions.CARBON_MONOXIDE_POISONING;
-    }
-
-    /**
-     * @return the starting strength of the hazard zone.
-     */
-    float getHazardStrengthPerOperation();
-
-    default void spreadEnvironmentalHazard() {
-        if (!ConfigHolder.INSTANCE.gameplay.environmentalHazards) {
-            return;
-        }
-
-        if (self().getLevel() instanceof ServerLevel serverLevel) {
-            IHazardParticleContainer container = GTCapabilityHelper.getHazardContainer(serverLevel,
-                    self().getBlockPos().relative(self().getFrontFacing()), self().getFrontFacing().getOpposite());
-            if (container != null &&
-                    container.getHazardCanBeInserted(getConditionToEmit()) > getHazardStrengthPerOperation()) {
-                container.addHazard(getConditionToEmit(), getHazardStrengthPerOperation());
-                return;
-            }
-
-            var savedData = EnvironmentalHazardSavedData.getOrCreate(serverLevel);
-            savedData.addZone(self().getBlockPos(), getHazardStrengthPerOperation(), true,
-                    HazardProperty.HazardTrigger.INHALATION, getConditionToEmit());
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IExhaustVentMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IExhaustVentMachine.java
deleted file mode 100644
index 7c62d616ba2..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IExhaustVentMachine.java
+++ /dev/null
@@ -1,184 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
-import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
-import com.gregtechceu.gtceu.common.data.GTDamageTypes;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.utils.GTUtil;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.core.particles.ParticleTypes;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.sounds.SoundEvents;
-import net.minecraft.sounds.SoundSource;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.block.state.properties.EnumProperty;
-import net.minecraft.world.phys.AABB;
-import net.minecraft.world.phys.shapes.Shapes;
-
-import org.jetbrains.annotations.NotNull;
-
-/**
- * Interface defining the functionality of a machine which vents exhaust from a side.
- *
- * @implNote {@link com.gregtechceu.gtceu.api.machine.steam.SimpleSteamMachine}
- */
-public interface IExhaustVentMachine extends IMachineFeature {
-
-    EnumProperty<RelativeDirection> VENT_DIRECTION_PROPERTY = GTMachineModelProperties.VENT_DIRECTION;
-
-    /**
-     * @return the direction the vent faces
-     */
-    @NotNull
-    Direction getVentingDirection();
-
-    /**
-     * @return if venting is needed
-     */
-    boolean isNeedsVenting();
-
-    void setNeedsVenting(boolean needsVenting);
-
-    /**
-     * Mark the machine as no longer needing venting
-     */
-    void markVentingComplete();
-
-    /**
-     * @return the damage to deal to entities in the vent area
-     */
-    float getVentingDamage();
-
-    /**
-     * Checks the venting state. Performs venting only if required.
-     *
-     * @return if the machine does not need venting
-     */
-    default boolean checkVenting() {
-        if (isNeedsVenting()) {
-            tryDoVenting(self().getLevel(), self().getBlockPos());
-        }
-        return !isNeedsVenting();
-    }
-
-    /**
-     * @return if venting is being blocked by something
-     */
-    default boolean isVentingBlocked() {
-        Level level = self().getLevel();
-        Direction ventingSide = getVentingDirection();
-        BlockPos ventingBlockPos = self().getBlockPos().relative(ventingSide);
-        BlockState state = level.getBlockState(ventingBlockPos);
-
-        return state.canOcclude() || Shapes.blockOccudes(state.getCollisionShape(level, ventingBlockPos),
-                Shapes.block(), ventingSide.getOpposite());
-    }
-
-    /**
-     * Attempts to vent, if needed
-     *
-     * @param level the level containing the machine venting
-     * @param pos   the position of the machine
-     */
-    default void tryDoVenting(@NotNull Level level, @NotNull BlockPos pos) {
-        if (!isNeedsVenting()) return;
-
-        if (!isVentingBlocked()) {
-            performVenting(level, pos);
-            return;
-        }
-
-        BlockPos ventingPos = pos.relative(getVentingDirection());
-        if (GTUtil.tryBreakSnow(level, ventingPos, level.getBlockState(ventingPos), false)) {
-            performVenting(level, pos);
-        }
-    }
-
-    private void performVenting(@NotNull Level level, @NotNull BlockPos pos) {
-        doVentingDamage(level, pos);
-
-        Direction ventingDirection = getVentingDirection();
-        double posX = pos.getX() + 0.5 + ventingDirection.getStepX() * 0.6;
-        double posY = pos.getY() + 0.5 + ventingDirection.getStepY() * 0.6;
-        double posZ = pos.getZ() + 0.5 + ventingDirection.getStepZ() * 0.6;
-        createVentingParticles(level, posX, posY, posZ);
-
-        if (ConfigHolder.INSTANCE.machines.machineSounds) {
-            playVentingSound(level, posX, posY, posZ);
-        }
-
-        markVentingComplete();
-    }
-
-    /**
-     * Damages entities upon venting
-     *
-     * @param level the level containing the machine and entities
-     * @param pos   the position of the machine venting
-     */
-    default void doVentingDamage(@NotNull Level level, @NotNull BlockPos pos) {
-        for (LivingEntity entity : level.getEntitiesOfClass(LivingEntity.class,
-                new AABB(pos.relative(getVentingDirection())),
-                entity -> !(entity instanceof Player player) || !player.isSpectator() && !player.isCreative())) {
-            entity.hurt(GTDamageTypes.HEAT.source(level), getVentingDamage());
-            // TODO ADVANCEMENT
-            // if (entity instanceof ServerPlayer) {
-            // AdvancementTriggers.STEAM_VENT_DEATH.trigger((ServerPlayer) entity);
-            // }
-        }
-    }
-
-    /**
-     * Create the particles for venting
-     *
-     * @param level the level containing the machine
-     * @param posX  the x position to send particles to
-     * @param posY  the y position to send particles to
-     * @param posZ  the z position to send particles to
-     */
-    default void createVentingParticles(@NotNull Level level, double posX, double posY, double posZ) {
-        Direction ventingDirection = getVentingDirection();
-        var count = 7 + level.random.nextInt(3);
-        if (level instanceof ServerLevel serverLevel) {
-            serverLevel.sendParticles(ParticleTypes.CLOUD, posX, posY, posZ,
-                    count,
-                    ventingDirection.getStepX() / 2.0,
-                    ventingDirection.getStepY() / 2.0,
-                    ventingDirection.getStepZ() / 2.0, 0.1);
-        } else {
-            for (int i = 0; i < count; ++i) {
-                double d1 = level.random.nextGaussian() * (double) ventingDirection.getStepX() / 2.0;
-                double d3 = level.random.nextGaussian() * (double) ventingDirection.getStepY() / 2.0;
-                double d5 = level.random.nextGaussian() * (double) ventingDirection.getStepZ() / 2.0;
-                double d6 = level.random.nextGaussian() * 0.1;
-                double d7 = level.random.nextGaussian() * 0.1;
-                double d8 = level.random.nextGaussian() * 0.1;
-                try {
-                    level.addParticle(ParticleTypes.CLOUD, posX + d1, posY + d3, posZ + d5, d6, d7, d8);
-                    continue;
-                } catch (Throwable throwable) {
-                    GTCEu.LOGGER.warn("Could not spawn particle effect {}", ParticleTypes.CLOUD);
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     * Play the venting sound
-     *
-     * @param level the level to play the sound in
-     * @param posX  the x position to play the sound at
-     * @param posY  the y position to play the sound at
-     * @param posZ  the z position to play the sound at
-     */
-    default void playVentingSound(@NotNull Level level, double posX, double posY, double posZ) {
-        level.playSound(null, posX, posY, posZ, SoundEvents.LAVA_EXTINGUISH, SoundSource.BLOCKS, 1F, 1F);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/ILocalizedHazardEmitter.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/ILocalizedHazardEmitter.java
deleted file mode 100644
index f13c10b0af1..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/ILocalizedHazardEmitter.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature;
-
-import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
-import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
-import com.gregtechceu.gtceu.api.data.chemical.material.properties.HazardProperty;
-import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
-import com.gregtechceu.gtceu.common.capability.LocalizedHazardSavedData;
-import com.gregtechceu.gtceu.common.data.GTMedicalConditions;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-
-import net.minecraft.server.level.ServerLevel;
-
-/**
- * common interface for localized hazard (e.g. radiation) emitters like nuclear reactors.
- */
-public interface ILocalizedHazardEmitter extends IMachineFeature {
-
-    /**
-     * @return the medical condition this hazard emitter creates.
-     */
-    default MedicalCondition getConditionToEmit() {
-        return GTMedicalConditions.CARCINOGEN;
-    }
-
-    /**
-     * @return the starting strength of the hazard zone. recommended values are in the range [1,5)
-     */
-    int getHazardSizePerOperation();
-
-    default void spreadLocalizedHazard() {
-        if (!ConfigHolder.INSTANCE.gameplay.environmentalHazards) {
-            return;
-        }
-
-        if (self().getLevel() instanceof ServerLevel serverLevel) {
-            IHazardParticleContainer container = GTCapabilityHelper.getHazardContainer(serverLevel,
-                    self().getBlockPos().relative(self().getFrontFacing()), self().getFrontFacing().getOpposite());
-            if (container != null &&
-                    container.getHazardCanBeInserted(getConditionToEmit()) > getHazardSizePerOperation()) {
-                container.addHazard(getConditionToEmit(), getHazardSizePerOperation());
-                return;
-            }
-
-            var savedData = LocalizedHazardSavedData.getOrCreate(serverLevel);
-            savedData.addSphericalZone(self().getBlockPos(), getHazardSizePerOperation(), false,
-                    HazardProperty.HazardTrigger.INHALATION, getConditionToEmit());
-        }
-    }
-}
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..e7ec6992d17
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IMuiMachine.java
@@ -0,0 +1,35 @@
+package com.gregtechceu.gtceu.api.machine.feature;
+
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.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;
+
+public interface IMuiMachine extends IUIHolder<PosGuiData>, IMachineFeature {
+
+    @Override
+    ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings);
+
+    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, this);
+            }
+            return InteractionResult.sidedSuccess(player.level().isClientSide);
+        } else {
+            return InteractionResult.PASS;
+        }
+    }
+}
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..7922c636d3d 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,28 @@
 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);
-    }
+    /*
+     * @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/IMufflerMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMufflerMachine.java
deleted file mode 100644
index db1ea9e0ea4..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMufflerMachine.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature.multiblock;
-
-import com.gregtechceu.gtceu.api.GTValues;
-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.fancy.IFancyTooltip;
-import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardEmitter;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
-import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
-import com.gregtechceu.gtceu.api.recipe.GTRecipe;
-import com.gregtechceu.gtceu.common.data.GTParticleTypes;
-
-import net.minecraft.ChatFormatting;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
-import net.minecraft.world.item.ItemStack;
-
-import java.util.List;
-
-public interface IMufflerMachine extends IMultiPart, IEnvironmentalHazardEmitter {
-
-    void recoverItemsTable(ItemStack... recoveryItems);
-
-    /**
-     * @return true if front face is free and contains only air blocks in 1x1 area OR has a duct block on it.
-     */
-    default boolean isFrontFaceFree() {
-        var frontPos = self().getBlockPos().relative(self().getFrontFacing());
-        return self().getLevel().getBlockState(frontPos).isAir() ||
-                GTCapabilityHelper.getHazardContainer(self().getLevel(),
-                        frontPos, self().getFrontFacing().getOpposite()) != null;
-    }
-
-    default void emitPollutionParticles() {
-        var pos = self().getBlockPos();
-        var facing = self().getFrontFacing();
-
-        IHazardParticleContainer container = GTCapabilityHelper.getHazardContainer(self().getLevel(),
-                pos.relative(facing), facing.getOpposite());
-        if (container != null) {
-            // do not emit particles if front face has a duct on it.
-            return;
-        }
-
-        var center = pos.getCenter();
-        var offset = .75f;
-        var xPos = (float) (center.x + facing.getStepX() * offset + (GTValues.RNG.nextFloat() - .5f) * .35f);
-        var yPos = (float) (center.y + facing.getStepY() * offset + (GTValues.RNG.nextFloat() - .5f) * .35f);
-        var zPos = (float) (center.z + facing.getStepZ() * offset + (GTValues.RNG.nextFloat() - .5f) * .35f);
-
-        var ySpd = facing.getStepY() + (GTValues.RNG.nextFloat() - .15f) * .5f;
-        var xSpd = facing.getStepX() + (GTValues.RNG.nextFloat() - .5f) * .5f;
-        var zSpd = facing.getStepZ() + (GTValues.RNG.nextFloat() - .5f) * .5f;
-
-        self().getLevel().addParticle(GTParticleTypes.MUFFLER_PARTICLE.get(),
-                xPos, yPos, zPos, xSpd, ySpd, zSpd);
-    }
-
-    @Override
-    default GTRecipe modifyRecipe(GTRecipe recipe) {
-        if (!isFrontFaceFree()) {
-            return null;
-        }
-        return IMultiPart.super.modifyRecipe(recipe);
-    }
-
-    @Override
-    default float getHazardStrengthPerOperation() {
-        float outputAmount = 2.5f;
-        return this instanceof TieredPartMachine tiered ? outputAmount / Math.max(tiered.getTier(), 1) : outputAmount;
-    }
-
-    @Override
-    default boolean afterWorking(IWorkableMultiController controller) {
-        spreadEnvironmentalHazard();
-        var supplier = controller.self().getDefinition().getRecoveryItems();
-        if (supplier != null) {
-            recoverItemsTable(supplier.get());
-        }
-        return IMultiPart.super.afterWorking(controller);
-    }
-
-    //////////////////////////////////////
-    // ******* FANCY GUI ********//
-    //////////////////////////////////////
-
-    @Override
-    default void attachFancyTooltipsToController(MultiblockControllerMachine controller, TooltipsPanel tooltipsPanel) {
-        attachTooltips(tooltipsPanel);
-    }
-
-    @Override
-    default void attachTooltips(TooltipsPanel tooltipsPanel) {
-        tooltipsPanel.attachTooltips(new IFancyTooltip.Basic(
-                () -> GuiTextures.INDICATOR_NO_STEAM.get(false),
-                () -> List.of(Component.translatable("gtceu.multiblock.universal.muffler_obstructed")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED))),
-                () -> !isFrontFaceFree(),
-                () -> 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 b3f03725c90..bcb712afa10 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,8 +1,8 @@
 package com.gregtechceu.gtceu.api.machine.feature.multiblock;
 
 import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
-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;
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.SortedSet;
 
-public interface IMultiPart extends IMachineFeature, IFancyUIMachine {
+public interface IMultiPart extends IMachineFeature, IMuiMachine {
 
     /**
      * Can it be shared among multi multiblock.
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/multiblock/CoilWorkableElectricMultiblockMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/CoilWorkableElectricMultiblockMachine.java
index a4ea83d5a11..2206a2d182d 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,12 +2,29 @@
 
 import com.gregtechceu.gtceu.api.block.ICoilType;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.*;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.block.CoilBlock;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockPanelUtil;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
 import lombok.Getter;
 
+import java.util.function.Supplier;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
@@ -36,4 +53,47 @@ public void onStructureFormed() {
     public int getCoilTier() {
         return coilType.getTier();
     }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176 + 32, 164 + 36);
+
+        var panelUtil = new GTMultiblockPanelUtil(this);
+
+        IntSyncValue coilTier = syncManager.getOrCreateSyncHandler("coilTier", IntSyncValue.class,
+                () -> new IntSyncValue(this::getCoilTier));
+
+        Supplier<IDrawable> coilTexture = () -> new UITexture.Builder()
+                .location(CoilBlock.CoilType.values()[coilTier.getIntValue()].getTexture())
+                .imageSize(16, 16).colorType(ColorType.DEFAULT).tiled().build();
+
+        var widget1 = new DynamicDrawable(coilTexture).asWidget().size(4, 16).heightRel(1.0f);
+        var widget2 = new DynamicDrawable(coilTexture).asWidget().size(4, 16).heightRel(1.0f);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176 + 36))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(3)
+                        .child(new Row()
+                                .child(widget1)
+                                .child(panelUtil.getMainTextPanel(syncManager, 208, 90))
+                                .child(widget2))
+
+                )
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+
+        return panel;
+    }
 }
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 89b0be5835f..0f3dd511d2b 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
@@ -8,6 +8,9 @@
 import com.gregtechceu.gtceu.api.machine.MultiblockMachineDefinition;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
+import com.gregtechceu.gtceu.api.machine.trait.MultiblockMachineTrait;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.pattern.BlockPattern;
 import com.gregtechceu.gtceu.api.pattern.MultiblockState;
 import com.gregtechceu.gtceu.api.pattern.MultiblockWorldSavedData;
@@ -123,6 +126,12 @@ public void onStructureFormed() {
             }
             part.addedToController(this);
         }
+        updatePartPositions();
+
+        for (var trait : getTraitHolder().getAllTraits()) {
+            if (trait instanceof MultiblockMachineTrait multiblockMachineTrait)
+                multiblockMachineTrait.onStructureFormed();
+        }
     }
 
     /**
@@ -147,6 +156,11 @@ public void onStructureInvalid() {
         parallelHatch = null;
         parts.clear();
         updatePartPositions();
+
+        for (var trait : getTraitHolder().getAllTraits()) {
+            if (trait instanceof MultiblockMachineTrait multiblockMachineTrait)
+                multiblockMachineTrait.onStructureInvalid();
+        }
     }
 
     /**
@@ -410,4 +424,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 9dc664642b9..7cf357186b9 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,41 @@
 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.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockPanelUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 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 lombok.Getter;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
 import java.util.function.Function;
 
 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 {
 
     // runtime
     protected EnergyContainerList energyContainer;
@@ -98,93 +96,130 @@ 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;
-        }
-
-        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);
-    }
-
     @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;
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 196, 237);
+
+        var panelUtil = new GTMultiblockPanelUtil(this);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 196))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.65f)
+                        .margin(4, 0)
+                        .left(3).top(2)
+                        .horizontalCenter()
+                        .child(Flow.row()
+                                .child(panelUtil.getMainTextPanel(syncManager, 186, 146))))
+                .child(Flow.col()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7).horizontalCenter());
+
+        return panel;
     }
 
     @Override
-    public ModularUI createUI(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<>();
+        widgets.add(GTMultiblockTextUtil.addEnergyTierLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addEnergyUsageLine(this, syncManager));
+        widgets.addAll(super.getWidgetsForDisplay(syncManager));
+        return widgets;
     }
 
-    @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);
-        }
-    }
+    // @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(IParallelHatch::getCurrentParallel)
+    // .orElse(0);
+    // subtickParallels = 0;
+    // batchParallels = 0;
+    // totalRuns = 0;
+    // }
+    //
+    // 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.getProgress(), recipeLogic.getMaxProgress(),
+    // recipeLogic.getProgressPercent())
+    // .addOutputLines(recipeLogic.getLastRecipe());
+    // getDefinition().getAdditionalDisplay().accept(this, textList);
+    // IDisplayUIMachine.super.addDisplayText(textList);
+    // }
+
+    // @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;
+    // }
+    //
+    // @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();
+    // }
+    //
+    // @Override
+    // public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
+    // 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);
+    // }
+    // }
 
     //////////////////////////////////////
     // ******** OVERCLOCK *********//
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 220b01daf32..be76b7048d3 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
@@ -10,11 +10,14 @@
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IWorkableMultiController;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.*;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
@@ -320,4 +323,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/MultiblockPartMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/MultiblockPartMachine.java
index b552c93432d..96076c61349 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/MultiblockPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/MultiblockPartMachine.java
@@ -9,9 +9,14 @@
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.IRecipeHandlerTrait;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.sync_system.annotations.ClientFieldChangeListener;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -165,4 +170,9 @@ public BlockState getFormedAppearance(BlockState sourceState, BlockPos sourcePos
         if (!replacePartModelWhenFormed()) return null;
         return IMultiPart.super.getFormedAppearance(sourceState, sourcePos, side);
     }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return GTGuis.createPanel(this, 176, 166);
+    }
 }
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 42a5a224244..aa374159f99 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,14 +4,9 @@
 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.IExhaustVentMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
+import com.gregtechceu.gtceu.api.machine.trait.ExhaustVentMachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
@@ -23,19 +18,10 @@
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
 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.MethodsReturnNonnullByDefault;
 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 lombok.Setter;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
@@ -43,22 +29,23 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class SimpleSteamMachine extends SteamWorkableMachine implements IExhaustVentMachine, IUIMachine {
+public class SimpleSteamMachine extends SteamWorkableMachine {
 
     @SaveField
     public final NotifiableItemStackHandler importItems;
     @SaveField
     public final NotifiableItemStackHandler exportItems;
+
     @Getter
-    @Setter
-    @SaveField
-    private boolean needsVenting;
+    private final ExhaustVentMachineTrait exhaustVentTrait;
 
     public SimpleSteamMachine(BlockEntityCreationInfo info, boolean isHighPressure) {
         super(info, isHighPressure);
         this.importItems = createImportItemHandler();
         this.exportItems = createExportItemHandler();
 
+        this.exhaustVentTrait = new ExhaustVentMachineTrait(this);
+        exhaustVentTrait.setVentingDamageAmount(isHighPressure() ? 12F : 6F);
         MachineRenderState renderState = getRenderState();
         if (renderState.hasProperty(GTMachineModelProperties.VENT_DIRECTION)) {
             // outputFacing will always be opposite the front facing on init
@@ -81,6 +68,7 @@ protected NotifiableItemStackHandler createExportItemHandler() {
     @Override
     public void onLoad() {
         super.onLoad();
+        exhaustVentTrait.setVentingDirection(Objects.requireNonNull(getOutputFacing()));
         // Simulate an EU machine via a SteamEnergyHandler
         this.addHandlerList(RecipeHandlerList.of(IO.IN, new SteamEnergyRecipeHandler(steamTank, getConversionRate())));
     }
@@ -96,17 +84,6 @@ public void onMachineDestroyed() {
     // ****** Venting Logic ******//
     //////////////////////////////////////
 
-    @Override
-    public float getVentingDamage() {
-        return isHighPressure() ? 12F : 6F;
-    }
-
-    @SuppressWarnings("DataFlowIssue")
-    @Override
-    public @NotNull Direction getVentingDirection() {
-        return getOutputFacing();
-    }
-
     public void updateModelVentDirection() {
         MachineRenderState renderState = getRenderState();
         if (renderState.hasProperty(GTMachineModelProperties.VENT_DIRECTION)) {
@@ -115,17 +92,19 @@ public void updateModelVentDirection() {
             if (getFrontFacing() == Direction.UP && !allowExtendedFacing()) {
                 upwardsDir = upwardsDir.getOpposite();
             }
-            var relative = RelativeDirection.findRelativeOf(getFrontFacing(), getVentingDirection(), upwardsDir);
+            var relative = RelativeDirection.findRelativeOf(getFrontFacing(), exhaustVentTrait.getVentingDirection(),
+                    upwardsDir);
             setRenderState(renderState.setValue(GTMachineModelProperties.VENT_DIRECTION, relative));
         }
     }
 
     @Override
-    public void setOutputFacing(@NotNull Direction outputFacing) {
+    public void setOutputFacing(Direction outputFacing) {
         var oldFacing = getOutputFacing();
         super.setOutputFacing(outputFacing);
         if (getOutputFacing() != oldFacing) {
             updateModelVentDirection();
+            exhaustVentTrait.setVentingDirection(outputFacing);
         }
     }
 
@@ -139,7 +118,7 @@ public void setFrontFacing(Direction facing) {
     }
 
     @Override
-    public void setUpwardsFacing(@NotNull Direction upwardsFacing) {
+    public void setUpwardsFacing(Direction upwardsFacing) {
         var oldFacing = getUpwardsFacing();
         super.setUpwardsFacing(upwardsFacing);
         if (getUpwardsFacing() != oldFacing) {
@@ -147,11 +126,6 @@ public void setUpwardsFacing(@NotNull Direction upwardsFacing) {
         }
     }
 
-    @Override
-    public void markVentingComplete() {
-        this.needsVenting = false;
-    }
-
     public double getConversionRate() {
         return isHighPressure() ? 2.0 : 1.0;
     }
@@ -171,11 +145,11 @@ public double getConversionRate() {
      * @param recipe  recipe
      * @return A {@link ModifierFunction} for the given Steam Machine
      */
-    public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @NotNull GTRecipe recipe) {
+    public static ModifierFunction recipeModifier(MetaMachine machine, GTRecipe recipe) {
         if (!(machine instanceof SimpleSteamMachine steamMachine)) {
             return RecipeModifier.nullWrongType(SimpleSteamMachine.class, machine);
         }
-        if (RecipeHelper.getRecipeEUtTier(recipe) > GTValues.LV || !steamMachine.checkVenting()) {
+        if (RecipeHelper.getRecipeEUtTier(recipe) > GTValues.LV || !steamMachine.exhaustVentTrait.checkVenting()) {
             return ModifierFunction.NULL;
         }
 
@@ -187,38 +161,7 @@ public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @Not
     @Override
     public void afterWorking() {
         super.afterWorking();
-        needsVenting = true;
-        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));
+        exhaustVentTrait.setNeedsVenting(true);
+        exhaustVentTrait.checkVenting();
     }
 }
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 7182caea78a..1cbab0e678b 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,36 +3,40 @@
 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.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.modifier.ModifierFunction;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-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.MethodsReturnNonnullByDefault;
-import net.minecraft.client.resources.language.I18n;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.particles.ParticleTypes;
@@ -66,7 +70,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public abstract class SteamBoilerMachine extends SteamWorkableMachine
-                                         implements IUIMachine, IDataInfoProvider {
+                                         implements IMuiMachine, IDataInfoProvider {
 
     @SaveField
     public final NotifiableFluidTank waterTank;
@@ -181,7 +185,9 @@ protected void updateCurrentTemperature() {
                 currentTemperature -= getCoolDownRate();
                 timeBeforeCoolingDown = getCooldownInterval();
             }
-        } else--timeBeforeCoolingDown;
+        } else {
+            --timeBeforeCoolingDown;
+        }
 
         if (getOffsetTimer() % 10 == 0) {
             if (currentTemperature >= 100) {
@@ -195,7 +201,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;
@@ -218,9 +226,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() {
@@ -310,27 +321,44 @@ public InteractionResult onUse(BlockState state, Level world, BlockPos pos, Play
     //////////////////////////////////////
 
     @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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        ModularPanel panel = GTGuis.createPanel(this, 176, 166);
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176));
+
+        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));
+
+        panel.child(new Row()
+                .top(12)
+                .left(50)
+                .coverChildren()
+                .childPadding(10)
+                .child(new FluidSlot()
+                        .syncHandler(new FluidSlotSyncHandler(waterTank.getStorages()[0]))
+                        .size(14, 54)
+                        .alwaysShowFull(true)
+                        .displayAmount(false))
+                .child(new FluidSlot()
+                        .syncHandler(new FluidSlotSyncHandler(steamTank.getStorages()[0])
+                                .canFillSlot(false).canDrainSlot(true))
+                        .alwaysShowFull(true)
+                        .size(14, 54)
+                        .displayAmount(false))
+                .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()))))))
+                .child(SlotGroupWidget.playerInventory(false).bottom(7).left(7));
+
+        return panel;
     }
 
     //////////////////////////////////////
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 8434c9c9fc3..a1683caf644 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,19 +4,18 @@
 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;
 import com.gregtechceu.gtceu.api.machine.trait.*;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 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.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -192,12 +191,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/AutoOutputTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/AutoOutputTrait.java
index b11770867d6..b4b609c5848 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/AutoOutputTrait.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/AutoOutputTrait.java
@@ -1,22 +1,21 @@
 package com.gregtechceu.gtceu.api.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.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 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;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 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.item.tool.behavior.ToolModeSwitchBehavior;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -300,8 +299,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) {
         if (toolTypes.contains(GTToolType.WRENCH)) {
             if (!player.isShiftKeyDown()) {
                 if (!machine.hasFrontFacing() || side != machine.getFrontFacing()) {
@@ -310,14 +309,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/api/machine/trait/ExhaustVentMachineTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/ExhaustVentMachineTrait.java
new file mode 100644
index 00000000000..a8862e5a58e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/ExhaustVentMachineTrait.java
@@ -0,0 +1,136 @@
+package com.gregtechceu.gtceu.api.machine.trait;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.common.data.GTDamageTypes;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.shapes.Shapes;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class ExhaustVentMachineTrait extends MachineTrait {
+
+    public static final MachineTraitType<ExhaustVentMachineTrait> TYPE = new MachineTraitType<>(
+            ExhaustVentMachineTrait.class, false);
+
+    @Getter
+    @Setter
+    private Direction ventingDirection;
+    @Getter
+    @Setter
+    @SaveField
+    private boolean needsVenting;
+    @Getter
+    @Setter
+    private float ventingDamageAmount;
+
+    public ExhaustVentMachineTrait(MetaMachine machine) {
+        super(machine);
+
+        this.ventingDirection = machine.getFrontFacing().getOpposite();
+        this.needsVenting = false;
+        this.ventingDamageAmount = 0;
+    }
+
+    @Override
+    public MachineTraitType<ExhaustVentMachineTrait> getTraitType() {
+        return TYPE;
+    }
+
+    public boolean isVentingBlocked() {
+        BlockPos ventingBlockPos = getBlockPos().relative(getVentingDirection());
+        BlockState state = getLevel().getBlockState(ventingBlockPos);
+
+        return state.canOcclude() || Shapes.blockOccudes(state.getCollisionShape(getLevel(), ventingBlockPos),
+                Shapes.block(), getVentingDirection().getOpposite());
+    }
+
+    public boolean checkVenting() {
+        if (!needsVenting) return true;
+
+        if (!isVentingBlocked()) {
+            performVenting();
+            return true;
+        }
+
+        BlockPos ventingPos = getBlockPos().relative(getVentingDirection());
+        if (GTUtil.tryBreakSnow(getLevel(), ventingPos, getLevel().getBlockState(ventingPos), false)) {
+            performVenting();
+            return true;
+        }
+        return false;
+    }
+
+    private void performVenting() {
+        doVentingDamage();
+        createVentingParticles();
+        if (ConfigHolder.INSTANCE.machines.machineSounds) {
+            playVentingSound();
+        }
+        needsVenting = false;
+    }
+
+    private void doVentingDamage() {
+        for (LivingEntity entity : getLevel().getEntitiesOfClass(LivingEntity.class,
+                new AABB(getBlockPos().relative(getVentingDirection())),
+                entity -> !(entity instanceof Player player) || !player.isSpectator() && !player.isCreative())) {
+            entity.hurt(GTDamageTypes.HEAT.source(getLevel()), ventingDamageAmount);
+        }
+    }
+
+    private void createVentingParticles() {
+        var level = getLevel();
+        var pos = getBlockPos();
+        Direction ventingDirection = getVentingDirection();
+        double posX = pos.getX() + 0.5 + ventingDirection.getStepX() * 0.6;
+        double posY = pos.getY() + 0.5 + ventingDirection.getStepY() * 0.6;
+        double posZ = pos.getZ() + 0.5 + ventingDirection.getStepZ() * 0.6;
+        var count = 7 + level.random.nextInt(3);
+        if (level instanceof ServerLevel serverLevel) {
+            serverLevel.sendParticles(ParticleTypes.CLOUD, posX, posY, posZ,
+                    count,
+                    ventingDirection.getStepX() / 2.0,
+                    ventingDirection.getStepY() / 2.0,
+                    ventingDirection.getStepZ() / 2.0, 0.1);
+        } else {
+            for (int i = 0; i < count; ++i) {
+                double d1 = level.random.nextGaussian() * (double) ventingDirection.getStepX() / 2.0;
+                double d3 = level.random.nextGaussian() * (double) ventingDirection.getStepY() / 2.0;
+                double d5 = level.random.nextGaussian() * (double) ventingDirection.getStepZ() / 2.0;
+                double d6 = level.random.nextGaussian() * 0.1;
+                double d7 = level.random.nextGaussian() * 0.1;
+                double d8 = level.random.nextGaussian() * 0.1;
+                try {
+                    level.addParticle(ParticleTypes.CLOUD, posX + d1, posY + d3, posZ + d5, d6, d7, d8);
+                    continue;
+                } catch (Throwable throwable) {
+                    GTCEu.LOGGER.warn("Could not spawn particle effect {}", ParticleTypes.CLOUD);
+                    return;
+                }
+            }
+        }
+    }
+
+    private void playVentingSound() {
+        var pos = getBlockPos();
+        var level = getLevel();
+        double posX = pos.getX() + 0.5 + ventingDirection.getStepX() * 0.6;
+        double posY = pos.getY() + 0.5 + ventingDirection.getStepY() * 0.6;
+        double posZ = pos.getZ() + 0.5 + ventingDirection.getStepZ() * 0.6;
+        level.playSound(null, posX, posY, posZ, SoundEvents.LAVA_EXTINGUISH, SoundSource.BLOCKS, 1F, 1F);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MachineTraitHolder.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MachineTraitHolder.java
index 1f12ceaeec1..1e7eb18063a 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MachineTraitHolder.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MachineTraitHolder.java
@@ -1,6 +1,12 @@
 package com.gregtechceu.gtceu.api.machine.trait;
 
+import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.sync_system.data_transformers.ValueTransformer;
+import com.gregtechceu.gtceu.api.sync_system.data_transformers.ValueTransformers;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
 
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
@@ -10,6 +16,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 
 public final class MachineTraitHolder {
@@ -18,10 +25,13 @@ public final class MachineTraitHolder {
     private final List<MachineTrait> traits;
     private final Map<MachineTraitType<?>, List<MachineTrait>> traitsByType;
 
+    private final Map<String, MachineTrait> traitsToSave;
+
     public MachineTraitHolder(MetaMachine machine) {
         this.machine = machine;
         this.traits = new ObjectArrayList<>();
         this.traitsByType = new Object2ObjectOpenHashMap<>();
+        this.traitsToSave = new Object2ObjectOpenHashMap<>();
     }
 
     public @UnmodifiableView List<MachineTrait> getAllTraits() {
@@ -40,6 +50,28 @@ public void attachTrait(MachineTrait trait) {
         traits.add(trait);
     }
 
+    /**
+     * Registers a trait to be synced/saved.
+     * Do not register a trait to be synced and also store that trait as a syncable machine field, otherwise the trait
+     * data will be duplicated. Use only one sync method.
+     *
+     * @param traitName Unique identifier for this trait.
+     * @param trait     The trait to register
+     */
+    public MachineTraitHolder syncTrait(String traitName, MachineTrait trait) {
+        if (trait.machine != machine) throw new IllegalArgumentException("Trait does not belong to this machine.");
+        if (traitsToSave.containsKey(traitName))
+            throw new IllegalArgumentException("Attempted to register duplicate trait save key \"" + traitName + "\"");
+        traitsToSave.put(traitName, trait);
+        return this;
+    }
+
+    @SuppressWarnings("unchecked")
+    public @Nullable <T extends MachineTrait> T getSyncTrait(String traitName) {
+        MachineTrait trait = traitsToSave.get(traitName);
+        return trait == null ? null : (T) trait;
+    }
+
     /**
      * Gets the first trait with the specified type.
      */
@@ -62,4 +94,39 @@ public <T extends MachineTrait> Optional<T> getTraitOptional(MachineTraitType<T>
         if (traitList == null) return List.of();
         return Collections.unmodifiableList(traitList);
     }
+
+    private static class MachineTraitHolderTransformer implements ValueTransformer<MachineTraitHolder> {
+
+        @Override
+        public Tag serializeNBT(MachineTraitHolder value, TransformerContext<MachineTraitHolder> context) {
+            CompoundTag tag = new CompoundTag();
+
+            value.traitsToSave.forEach((k, v) -> tag.put(k,
+                    v.getSyncDataHolder().serializeNBT(context.isClientSync(), context.isClientFullSyncUpdate())));
+
+            return tag;
+        }
+
+        @Override
+        public @Nullable MachineTraitHolder deserializeNBT(Tag tag, TransformerContext<MachineTraitHolder> context) {
+            var traitHolder = Objects.requireNonNull(context.currentValue());
+            var compoundTag = (CompoundTag) tag;
+
+            for (var key : compoundTag.getAllKeys()) {
+                var trait = traitHolder.getSyncTrait(key);
+                if (trait == null) {
+                    GTCEu.LOGGER.warn("Attempted to deserialise syncable trait '{}', but no syncable trait has that ID",
+                            key);
+                    continue;
+                }
+                trait.getSyncDataHolder().deserializeNBT(compoundTag.getCompound("key"), context.isClientSync());
+            }
+
+            return null;
+        }
+    }
+
+    static {
+        ValueTransformers.registerTransformer(MachineTraitHolder.class, new MachineTraitHolderTransformer());
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MultiblockMachineTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MultiblockMachineTrait.java
new file mode 100644
index 00000000000..4070537b988
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/MultiblockMachineTrait.java
@@ -0,0 +1,14 @@
+package com.gregtechceu.gtceu.api.machine.trait;
+
+import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
+
+public abstract class MultiblockMachineTrait extends MachineTrait {
+
+    public MultiblockMachineTrait(MultiblockControllerMachine multiMachine) {
+        super(multiMachine);
+    }
+
+    public void onStructureFormed() {}
+
+    public void onStructureInvalid() {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableComputationContainer.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableComputationContainer.java
index 4cfb6b28756..f04b8757722 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableComputationContainer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableComputationContainer.java
@@ -1,10 +1,10 @@
 package com.gregtechceu.gtceu.api.machine.trait;
 
 import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationHatch;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationReceiver;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.*;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
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 203c0ad68e8..82bb38af3ad 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
@@ -298,6 +298,7 @@ public void handleRecipeWorking() {
                 }
                 progress++;
                 totalContinuousRunningTime++;
+                syncDataHolder.markClientSyncFieldDirty("progress");
             } else {
                 setWaiting(handleTick.reason());
 
@@ -338,6 +339,7 @@ public void handleRecipeWorking() {
     protected void regressRecipe() {
         if (progress > 0 && machine.regressWhenWaiting()) {
             this.progress = 1;
+            syncDataHolder.markClientSyncFieldDirty("progress");
         }
     }
 
@@ -361,6 +363,7 @@ public void findAndHandleRecipe() {
             lastOriginRecipe = null;
             handleSearchingRecipes(searchRecipe());
         }
+        syncDataHolder.markClientSyncFieldDirty("lastRecipe");
         recipeDirty = false;
     }
 
@@ -405,6 +408,7 @@ public void setupRecipe(GTRecipe recipe) {
             progress = 0;
             duration = 0;
             isActive = false;
+            syncDataHolder.resyncAllFields();
             return;
         }
         var handledIO = handleRecipeIO(recipe, IO.IN);
@@ -419,6 +423,7 @@ public void setupRecipe(GTRecipe recipe) {
             progress = 0;
             duration = recipe.duration;
             isActive = true;
+            syncDataHolder.resyncAllFields();
         }
     }
 
@@ -438,6 +443,7 @@ public void setStatus(Status status) {
             updateTickSubscription();
             if (this.status != Status.WAITING) {
                 waitingReason = null;
+                syncDataHolder.markClientSyncFieldDirty("waitingReason");
             }
         }
     }
@@ -445,6 +451,7 @@ public void setStatus(Status status) {
     public void setWaiting(@Nullable Component reason) {
         setStatus(Status.WAITING);
         waitingReason = reason;
+        syncDataHolder.markClientSyncFieldDirty("waitingReason");
         machine.onWaiting();
     }
 
@@ -533,6 +540,7 @@ public void onRecipeFinish() {
                 isActive = false;
                 // Force a recipe recheck.
                 lastRecipe = null;
+                syncDataHolder.resyncAllFields();
                 return;
             }
             if (machine.alwaysTryModifyRecipe()) {
@@ -542,6 +550,7 @@ public void onRecipeFinish() {
                         markLastRecipeDirty();
                     } else {
                         lastRecipe = modified;
+                        syncDataHolder.markClientSyncFieldDirty("lastRecipe");
                     }
                 } else {
                     markLastRecipeDirty();
@@ -557,6 +566,7 @@ public void onRecipeFinish() {
                 progress = 0;
                 duration = 0;
                 isActive = false;
+                syncDataHolder.resyncAllFields();
             }
         }
     }
@@ -578,6 +588,8 @@ public void interruptRecipe() {
             setStatus(Status.IDLE);
             progress = 0;
             duration = 0;
+            syncDataHolder.markClientSyncFieldDirty("progress");
+            syncDataHolder.markClientSyncFieldDirty("duration");
         }
     }
 
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 bdf175dd2b2..29c0f345333 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
@@ -1,8 +1,7 @@
 package com.gregtechceu.gtceu.api.machine.trait.feature;
 
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -35,9 +34,9 @@ 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.
      */
-    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/machine/trait/hazard/EnvironmentalHazardCleanerTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/EnvironmentalHazardCleanerTrait.java
new file mode 100644
index 00000000000..73afc1c5c11
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/EnvironmentalHazardCleanerTrait.java
@@ -0,0 +1,130 @@
+package com.gregtechceu.gtceu.api.machine.trait.hazard;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
+import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
+import com.gregtechceu.gtceu.common.blockentity.DuctPipeBlockEntity;
+import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.common.network.packets.hazard.SPacketRemoveHazardZone;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.LevelChunk;
+
+import it.unimi.dsi.fastutil.objects.Object2FloatMap;
+import it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiPredicate;
+
+public class EnvironmentalHazardCleanerTrait extends MachineTrait {
+
+    public static final MachineTraitType<EnvironmentalHazardCleanerTrait> TYPE = new MachineTraitType<>(
+            EnvironmentalHazardCleanerTrait.class);
+
+    @Getter
+    protected float removedLastSecond;
+
+    @Getter
+    protected float amountPerOperation;
+    @Getter
+    protected MedicalCondition conditionToRemove;
+    @Getter
+    protected int cleaningRadius;
+    @Getter
+    private boolean cleaningOperationInProgress;
+
+    private final @Nullable BiPredicate<MedicalCondition, Float> cleaningHandler;
+
+    public EnvironmentalHazardCleanerTrait(MetaMachine machine, int cleaningRadius,
+                                           @Nullable BiPredicate<MedicalCondition, Float> validateCleaningOperation) {
+        super(machine);
+        this.cleaningRadius = cleaningRadius;
+        this.cleaningHandler = validateCleaningOperation;
+    }
+
+    @Override
+    public MachineTraitType<EnvironmentalHazardCleanerTrait> getTraitType() {
+        return TYPE;
+    }
+
+    public boolean cleanHazard(MedicalCondition condition, float totalAmountToRemove) {
+        if (cleaningHandler == null) return beginCleaningOperation(condition, totalAmountToRemove);
+        return cleaningHandler.test(condition, totalAmountToRemove);
+    }
+
+    public boolean beginCleaningOperation(MedicalCondition condition, float amountPerOperation) {
+        if (cleaningOperationInProgress) return false;
+
+        this.conditionToRemove = condition;
+        this.amountPerOperation = amountPerOperation;
+        this.cleaningOperationInProgress = true;
+        return true;
+    }
+
+    public void endCleaningOperation() {
+        this.cleaningOperationInProgress = false;
+    }
+
+    public void cleanHazard() {
+        if (!cleaningOperationInProgress) return;
+        if (machine.getOffsetTimer() % 20 == 0) {
+            removedLastSecond = 0;
+
+            for (Direction dir : GTUtil.DIRECTIONS) {
+                BlockPos offset = getBlockPos().relative(dir);
+                if (GTCapabilityHelper.getHazardContainer(getLevel(), offset, dir.getOpposite()) != null) {
+                    if (getLevel().getBlockEntity(offset) instanceof DuctPipeBlockEntity duct &&
+                            !duct.isConnected(dir.getOpposite())) {
+                        continue;
+                    }
+                    return;
+                }
+            }
+
+            final ServerLevel serverLevel = (ServerLevel) getLevel();
+            EnvironmentalHazardSavedData savedData = EnvironmentalHazardSavedData.getOrCreate(serverLevel);
+
+            final ChunkPos pos = new ChunkPos(getBlockPos());
+            Object2FloatMap<ChunkPos> relativePositions = new Object2FloatOpenHashMap<>();
+            if (cleaningRadius <= 0) {
+                // LV scrubber can only process the chunk it's in
+                relativePositions.put(pos, 1);
+            } else {
+                for (int x = -cleaningRadius; x <= cleaningRadius; ++x) {
+                    for (int z = -cleaningRadius; z <= cleaningRadius; ++z) {
+                        relativePositions.put(new ChunkPos(pos.x + x, pos.z + z), Mth.sqrt(Mth.abs(x * z)) + 1);
+                    }
+                }
+            }
+            for (ChunkPos rel : relativePositions.keySet()) {
+                final float distance = relativePositions.getFloat(rel);
+                savedData.getHazardZones().compute(rel, (chunkPos, zone) -> {
+                    if (zone == null || zone.strength() <= 0) {
+                        return null;
+                    }
+
+                    float toClean = amountPerOperation / distance;
+                    removedLastSecond += toClean;
+                    zone.removeStrength(toClean);
+                    if (zone.strength() <= 0) {
+                        if (serverLevel.hasChunk(chunkPos.x, chunkPos.z)) {
+                            LevelChunk chunk = serverLevel.getChunk(chunkPos.x, chunkPos.z);
+                            GTNetwork.sendToAllPlayersTrackingChunk(chunk, new SPacketRemoveHazardZone(chunkPos));
+                        }
+                        return null;
+                    } else return zone;
+                });
+            }
+        }
+        return;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/EnvironmentalHazardEmitterTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/EnvironmentalHazardEmitterTrait.java
new file mode 100644
index 00000000000..f3dce5ffe4a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/EnvironmentalHazardEmitterTrait.java
@@ -0,0 +1,64 @@
+package com.gregtechceu.gtceu.api.machine.trait.hazard;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
+import com.gregtechceu.gtceu.api.data.chemical.material.properties.HazardProperty;
+import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
+import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
+import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.server.level.ServerLevel;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * trait for environmental hazard (e.g. pollution) emitters like mufflers.
+ */
+public class EnvironmentalHazardEmitterTrait extends MachineTrait {
+
+    public static final MachineTraitType<EnvironmentalHazardEmitterTrait> TYPE = new MachineTraitType<>(
+            EnvironmentalHazardEmitterTrait.class);
+
+    @Getter
+    @Setter
+    protected float emissionStrength;
+    @Getter
+    @Setter
+    protected MedicalCondition conditionToEmit;
+
+    public EnvironmentalHazardEmitterTrait(MetaMachine machine, MedicalCondition conditionToEmit,
+                                           float emissionStrength) {
+        super(machine);
+        this.conditionToEmit = conditionToEmit;
+        this.emissionStrength = emissionStrength;
+    }
+
+    @Override
+    public MachineTraitType<EnvironmentalHazardEmitterTrait> getTraitType() {
+        return TYPE;
+    }
+
+    public void emitHazard() {
+        if (!ConfigHolder.INSTANCE.gameplay.environmentalHazards) {
+            return;
+        }
+
+        if (getLevel() instanceof ServerLevel serverLevel) {
+            IHazardParticleContainer container = GTCapabilityHelper.getHazardContainer(serverLevel,
+                    getBlockPos().relative(machine.getFrontFacing()), machine.getFrontFacing().getOpposite());
+            if (container != null &&
+                    container.getHazardCanBeInserted(getConditionToEmit()) > getEmissionStrength()) {
+                container.addHazard(getConditionToEmit(), getEmissionStrength());
+                return;
+            }
+
+            var savedData = EnvironmentalHazardSavedData.getOrCreate(serverLevel);
+            savedData.addZone(getBlockPos(), getEmissionStrength(), true,
+                    HazardProperty.HazardTrigger.INHALATION, getConditionToEmit());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/LocalizedHazardEmitterTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/LocalizedHazardEmitterTrait.java
new file mode 100644
index 00000000000..8192765380b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/LocalizedHazardEmitterTrait.java
@@ -0,0 +1,64 @@
+package com.gregtechceu.gtceu.api.machine.trait.hazard;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
+import com.gregtechceu.gtceu.api.data.chemical.material.properties.HazardProperty;
+import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
+import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
+import com.gregtechceu.gtceu.common.capability.LocalizedHazardSavedData;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.server.level.ServerLevel;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * trait for localized hazard (e.g. radiation) emitters like nuclear reactors.
+ */
+public class LocalizedHazardEmitterTrait extends MachineTrait {
+
+    public static final MachineTraitType<LocalizedHazardEmitterTrait> TYPE = new MachineTraitType<>(
+            LocalizedHazardEmitterTrait.class);
+
+    @Getter
+    @Setter
+    private MedicalCondition conditionToEmit;
+    @Getter
+    @Setter
+    private int conditionStrength;
+
+    public LocalizedHazardEmitterTrait(MetaMachine machine, MedicalCondition conditionToEmit,
+                                       int defaultConditionStrength) {
+        super(machine);
+        this.conditionToEmit = conditionToEmit;
+        this.conditionStrength = defaultConditionStrength;
+    }
+
+    @Override
+    public MachineTraitType<LocalizedHazardEmitterTrait> getTraitType() {
+        return TYPE;
+    }
+
+    public void spreadHazard() {
+        if (!ConfigHolder.INSTANCE.gameplay.environmentalHazards) {
+            return;
+        }
+
+        if (getLevel() instanceof ServerLevel serverLevel) {
+            IHazardParticleContainer container = GTCapabilityHelper.getHazardContainer(serverLevel,
+                    getBlockPos().relative(machine.getFrontFacing()), machine.getFrontFacing().getOpposite());
+            if (container != null &&
+                    container.getHazardCanBeInserted(getConditionToEmit()) > getConditionStrength()) {
+                container.addHazard(getConditionToEmit(), getConditionStrength());
+                return;
+            }
+
+            var savedData = LocalizedHazardSavedData.getOrCreate(serverLevel);
+            savedData.addSphericalZone(getBlockPos(), getConditionStrength(), false,
+                    HazardProperty.HazardTrigger.INHALATION, getConditionToEmit());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/package-info.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/package-info.java
new file mode 100644
index 00000000000..a4d86990353
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/hazard/package-info.java
@@ -0,0 +1,4 @@
+@NotNullByDefault
+package com.gregtechceu.gtceu.api.machine.trait.hazard;
+
+import org.jetbrains.annotations.NotNullByDefault;
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/GuiError.java b/src/main/java/com/gregtechceu/gtceu/api/mui/GuiError.java
new file mode 100644
index 00000000000..a20c4ebedf2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/GuiError.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.api.mui;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+import lombok.Getter;
+import org.apache.logging.log4j.Level;
+
+import java.util.Objects;
+
+public class GuiError {
+
+    public static void throwNew(IWidget guiElement, Type type, String msg) {
+        if (GTCEu.isClientSide()) {
+            GuiErrorHandler.INSTANCE.pushError(guiElement, type, msg);
+        }
+    }
+
+    @Getter
+    private final Level level = Level.ERROR;
+    @Getter
+    private final String msg;
+    @Getter
+    private final IWidget reference;
+    @Getter
+    private final Type type;
+
+    protected GuiError(String msg, IWidget reference, Type type) {
+        this.msg = msg;
+        this.reference = reference;
+        this.type = type;
+    }
+
+    @Override
+    public String toString() {
+        return "MUI [" + this.type.toString() + "][" + this.reference.toString() + "]: " + this.msg;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.level, this.reference, this.type);
+    }
+
+    public enum Type {
+        DRAW,
+        SIZING,
+        WIDGET_TREE,
+        INTERACTION,
+        SYNC
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/GuiErrorHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/GuiErrorHandler.java
new file mode 100644
index 00000000000..4fb450f38ed
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/GuiErrorHandler.java
@@ -0,0 +1,40 @@
+package com.gregtechceu.gtceu.api.mui;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+@OnlyIn(Dist.CLIENT)
+public class GuiErrorHandler {
+
+    public static final GuiErrorHandler INSTANCE = new GuiErrorHandler();
+
+    private final Set<GuiError> errorSet = new ObjectOpenHashSet<>();
+    @Getter
+    private final List<GuiError> errors = new ArrayList<>();
+
+    private GuiErrorHandler() {}
+
+    public void clear() {
+        this.errors.clear();
+    }
+
+    void pushError(IWidget reference, GuiError.Type type, String msg) {
+        GuiError error = new GuiError(msg, reference, type);
+        if (this.errorSet.add(error)) {
+            GTCEu.LOGGER.log(error.getLevel(), error);
+            this.errors.add(error);
+        }
+    }
+
+    public void drawErrors(int x, int y) {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/InWorldMUIOpenEvent.java b/src/main/java/com/gregtechceu/gtceu/api/mui/InWorldMUIOpenEvent.java
new file mode 100644
index 00000000000..4817595ef30
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/InWorldMUIOpenEvent.java
@@ -0,0 +1,27 @@
+package com.gregtechceu.gtceu.api.mui;
+
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraftforge.eventbus.api.Event;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+public class InWorldMUIOpenEvent extends Event {
+
+    @Getter
+    private final GuiData guiData;
+
+    @Getter
+    private final Screen vanillaScreen;
+
+    @Getter
+    private final ModularScreen screen;
+
+    @Getter
+    private final ModularContainerMenu menu;
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/InWorldMUIRenderEvent.java b/src/main/java/com/gregtechceu/gtceu/api/mui/InWorldMUIRenderEvent.java
new file mode 100644
index 00000000000..8a965ac5e63
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/InWorldMUIRenderEvent.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.api.mui;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraftforge.eventbus.api.Event;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+@Getter
+public class InWorldMUIRenderEvent extends Event {
+
+    private final GuiGraphics graphics;
+    private final float partialTick;
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/Animator.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/Animator.java
new file mode 100644
index 00000000000..5aab34b489e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/Animator.java
@@ -0,0 +1,199 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IInterpolation;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolation;
+
+import lombok.Getter;
+
+import java.util.function.DoubleConsumer;
+import java.util.function.DoublePredicate;
+
+public class Animator extends BaseAnimator<Animator> implements IAnimator {
+
+    @Getter
+    private float min = 0.0f;
+    @Getter
+    private float max = 1.0f;
+    @Getter
+    private int duration = 250;
+    @Getter
+    private IInterpolation curve = Interpolation.LINEAR;
+    private DoublePredicate onUpdate;
+    private Runnable onFinish;
+
+    private int progress = 0;
+
+    @Override
+    public void reset(boolean atEnd) {
+        super.reset(atEnd);
+        this.progress = atEnd ? this.duration : 0;
+    }
+
+    public Animator copy(boolean reversed) {
+        Animator animator = new Animator()
+                .curve(this.curve)
+                .reverseOnFinish(this.reverseOnFinish)
+                .repeatsOnFinish(this.repeats)
+                .onUpdate(this.onUpdate)
+                .duration(this.duration)
+                .onFinish(this.onFinish);
+        if (reversed) {
+            animator.bounds(this.max, this.min);
+        } else {
+            animator.bounds(this.min, this.max);
+        }
+        return animator;
+    }
+
+    @Override
+    public int advance(int elapsedTime) {
+        if (!isAnimating()) return elapsedTime;
+        while (elapsedTime > 0) {
+            int max = isAnimatingForward() ? this.duration - this.progress : this.progress;
+            int prog = Math.min(max, elapsedTime);
+            this.progress += prog * getDirection();
+            elapsedTime -= prog;
+            if (onUpdate()) {
+                stop(true);
+                break;
+            }
+            if ((isAnimatingForward() && this.progress >= this.duration) ||
+                    (isAnimatingReverse() && this.progress <= 0)) {
+                stop(false);
+                if (!isAnimating()) {
+                    onAnimationFinished(true, true);
+                    break;
+                }
+            }
+        }
+        return elapsedTime;
+    }
+
+    protected boolean onUpdate() {
+        return this.onUpdate != null && this.onUpdate.test(getRawValue());
+    }
+
+    protected void onAnimationFinished(boolean finishedOneCycle, boolean finishedAllRepeats) {
+        if (this.onFinish != null) {
+            this.onFinish.run();
+        }
+    }
+
+    public boolean isAtEnd() {
+        return this.progress >= this.duration;
+    }
+
+    public boolean isAtStart() {
+        return this.progress <= 0;
+    }
+
+    protected float getRawValue() {
+        return this.curve.interpolate(this.min, this.max, (float) this.progress / this.duration);
+    }
+
+    public float getValue() {
+        // advance();
+        return getRawValue();
+    }
+
+    @Override
+    public boolean hasProgressed() {
+        if (!isAnimating()) return false;
+        return isAnimatingForward() ? this.progress > 0 : this.progress < this.duration;
+    }
+
+    /**
+     * Sets the min bound of the value that will be interpolated.
+     *
+     * @param min min value
+     * @return this
+     */
+    public Animator min(float min) {
+        this.min = min;
+        return this;
+    }
+
+    /**
+     * Sets the max bound of the value that will be interpolated.
+     *
+     * @param max max value
+     * @return this
+     */
+    public Animator max(float max) {
+        this.max = max;
+        return this;
+    }
+
+    /**
+     * Sets the bounds of the value that will be interpolated.
+     *
+     * @param min min value
+     * @param max max value
+     * @return this
+     */
+    public Animator bounds(float min, float max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    /**
+     * The duration of this animation in milliseconds. Note this is not 100% accurate.
+     * Usually it's plus minus 2ms, but can rarely be more.
+     *
+     * @param duration duration in milliseconds
+     * @return this
+     */
+    public Animator duration(int duration) {
+        this.duration = duration;
+        return this;
+    }
+
+    /**
+     * Sets the interpolation curve, which is used to interpolate between the bounds.
+     *
+     * @param curve curve to interpolate on
+     * @return this
+     */
+    public Animator curve(IInterpolation curve) {
+        this.curve = curve;
+        return this;
+    }
+
+    /**
+     * Sets a function which is executed everytime the progress updates, that is on every frame.
+     * The argument of the function is the interpolated value.
+     *
+     * @param onUpdate update function
+     * @return this
+     */
+    public Animator onUpdate(DoublePredicate onUpdate) {
+        this.onUpdate = onUpdate;
+        return this;
+    }
+
+    /**
+     * Sets a function which is executed everytime the progress updates, that is on every frame.
+     * The argument of the function is the interpolated value.
+     *
+     * @param onUpdate update function
+     * @return this
+     */
+    public Animator onUpdate(DoubleConsumer onUpdate) {
+        return onUpdate(val -> {
+            onUpdate.accept(val);
+            return false;
+        });
+    }
+
+    /**
+     * Sets a function which is executed everytime, on animation, cycle or all repeats is finished.
+     *
+     * @param onFinish finish function
+     * @return this
+     */
+    public Animator onFinish(Runnable onFinish) {
+        this.onFinish = onFinish;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/AnimatorManager.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/AnimatorManager.java
new file mode 100644
index 00000000000..6398d9c85c7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/AnimatorManager.java
@@ -0,0 +1,66 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import net.minecraft.Util;
+import net.minecraftforge.client.event.ScreenEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.eventbus.api.EventPriority;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AnimatorManager {
+
+    public static final AnimatorManager INSTANCE = new AnimatorManager();
+
+    private static final List<IAnimator> animators = new ArrayList<>(16);
+    private static final List<IAnimator> queuedAnimators = new ArrayList<>(8);
+    private static long lastTime = 0;
+    private static boolean waitClearAnimators = false;
+
+    static void startAnimation(IAnimator animator) {
+        if (!animators.contains(animator) && !queuedAnimators.contains(animator)) {
+            queuedAnimators.add(animator);
+        }
+    }
+
+    private AnimatorManager() {}
+
+    public static void init() {
+        MinecraftForge.EVENT_BUS.register(INSTANCE);
+    }
+
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onDraw(ScreenEvent.Render.Pre event) {
+        long time = Util.getMillis();
+        int elapsedTime = IAnimator.getTimeDiff(lastTime, time);
+        checkClearAnimators();
+        if (lastTime > 0 && !animators.isEmpty()) {
+            animators.removeIf(animator -> {
+                if (animator == null) return true;
+                if (animator.isPaused()) return false;
+                animator.advance(elapsedTime);
+                return !animator.isAnimating();
+            });
+        }
+        lastTime = time;
+        animators.addAll(queuedAnimators);
+        queuedAnimators.clear();
+        checkClearAnimators();
+    }
+
+    private static void checkClearAnimators() {
+        if (waitClearAnimators) {
+            waitClearAnimators = false;
+            animators.forEach(iAnimator -> iAnimator.stop(false));
+            animators.clear();
+        }
+    }
+
+    @SubscribeEvent(priority = EventPriority.LOWEST)
+    public void onClose(ScreenEvent.Closing event) {
+        // stop and yeet all animators on gui close
+        // we can't clear now otherwise we might get a CME because of multithreading
+        waitClearAnimators = true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/BaseAnimator.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/BaseAnimator.java
new file mode 100644
index 00000000000..ff452cf1d0a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/BaseAnimator.java
@@ -0,0 +1,128 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import org.jetbrains.annotations.Nullable;
+
+public abstract class BaseAnimator<A extends BaseAnimator<A>> implements IAnimator {
+
+    private IAnimator parent;
+    protected boolean reverseOnFinish = false;
+    protected int repeats = 0;
+
+    private byte direction = 0;
+    private boolean paused = false;
+    private boolean startedReverse = false;
+    private int repeated = 0;
+
+    void setParent(IAnimator parent) {
+        this.parent = parent;
+    }
+
+    @SuppressWarnings("unchecked")
+    public A getThis() {
+        return (A) this;
+    }
+
+    @Nullable
+    public final IAnimator getParent() {
+        return parent;
+    }
+
+    @Override
+    public void reset(boolean atEnd) {
+        this.startedReverse = atEnd;
+        this.repeated = 0;
+    }
+
+    @Override
+    public boolean stop(boolean force) {
+        if (isAnimating() && !force) {
+            if (this.reverseOnFinish && this.startedReverse == isAnimatingReverse()) {
+                onAnimationFinished(false, false);
+                // started reverse -> bounce back and animate forward
+                animate(isAnimatingForward());
+                return false;
+            }
+            if (repeats != 0 && (repeated < repeats || repeats < 0)) {
+                onAnimationFinished(true, false);
+                // started forward -> full cycle finished -> try repeating
+                boolean reverse = !this.reverseOnFinish == isAnimatingReverse();
+                animate(reverse);
+                repeated++;
+                return false;
+            }
+        }
+        this.direction = 0;
+        return true;
+    }
+
+    protected void onAnimationFinished(boolean finishedOneCycle, boolean finishedAllRepeats) {}
+
+    @Override
+    public void pause() {
+        this.paused = true;
+    }
+
+    @Override
+    public void resume(boolean reverse) {
+        this.paused = false;
+        this.direction = (byte) (reverse ? -1 : 1);
+        if (this.parent == null) AnimatorManager.startAnimation(this);
+    }
+
+    @Override
+    public boolean isPaused() {
+        return paused;
+    }
+
+    @Override
+    public boolean isAnimating() {
+        return this.direction != 0;
+    }
+
+    @Override
+    public boolean isAnimatingReverse() {
+        return this.direction < 0;
+    }
+
+    @Override
+    public boolean isAnimatingForward() {
+        return this.direction > 0;
+    }
+
+    public final byte getDirection() {
+        return direction;
+    }
+
+    /**
+     * Sets if the animation should reverse animate once after it finished.
+     * If the animation started in reverse it will animate forward on finish.
+     *
+     * @param reverseOnFinish if animation should bounce back on finish
+     * @return this
+     */
+    public A reverseOnFinish(boolean reverseOnFinish) {
+        this.reverseOnFinish = reverseOnFinish;
+        return getThis();
+    }
+
+    /**
+     * Sets how often the animation should repeat. If {@link #reverseOnFinish(boolean)} is set to true, it will repeat
+     * the whole cycle.
+     * If the number of repeats is negative, it will repeat infinitely.
+     *
+     * @param repeats how often the animation should repeat.
+     * @return this
+     */
+    public A repeatsOnFinish(int repeats) {
+        this.repeats = repeats;
+        return getThis();
+    }
+
+    public SequentialAnimator followedBy(IAnimator animator) {
+        return new SequentialAnimator(this, animator);
+    }
+
+    public ParallelAnimator inParallelWith(IAnimator animator) {
+        return new ParallelAnimator(this, animator);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/IAnimatable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/IAnimatable.java
new file mode 100644
index 00000000000..38bf2801288
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/IAnimatable.java
@@ -0,0 +1,63 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IInterpolation;
+
+public interface IAnimatable<T extends IAnimatable<T>> {
+
+    T interpolate(T start, T end, float t);
+
+    T copyOrImmutable();
+
+    default boolean shouldAnimate(T target) {
+        return !equals(target);
+    }
+
+    default MutableObjectAnimator<T> animator(T target) {
+        T self = (T) this;
+        return new MutableObjectAnimator<>(self, self.copyOrImmutable(), target);
+    }
+
+    default void animate(T target) {
+        animate(target, false);
+    }
+
+    default void animate(T target, boolean reverse) {
+        if (shouldAnimate(target)) {
+            animator(target).animate(reverse);
+        }
+    }
+
+    default void animate(T target, boolean reverse, boolean reverseOnFinish, int repeatsOnFinish) {
+        if (shouldAnimate(target)) {
+            animator(target).reverseOnFinish(reverseOnFinish).repeatsOnFinish(repeatsOnFinish).animate(reverse);
+        }
+    }
+
+    default void animate(T target, int durationMs, boolean reverse) {
+        if (shouldAnimate(target)) {
+            animator(target).duration(durationMs).animate(reverse);
+        }
+    }
+
+    default void animate(T target, IInterpolation curve, boolean reverse) {
+        if (shouldAnimate(target)) {
+            animator(target).curve(curve).animate(reverse);
+        }
+    }
+
+    default void animate(T target, IInterpolation curve, int durationMs, boolean reverse) {
+        animate(target, curve, durationMs, reverse, false, 0);
+    }
+
+    default void animate(T target, IInterpolation curve, int durationMs, boolean reverse, boolean reverseOnFinish,
+                         int repeatsOnFinish) {
+        if (shouldAnimate(target)) {
+            animator(target)
+                    .curve(curve)
+                    .duration(durationMs)
+                    .reverseOnFinish(reverseOnFinish)
+                    .repeatsOnFinish(repeatsOnFinish)
+                    .animate(reverse);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/IAnimator.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/IAnimator.java
new file mode 100644
index 00000000000..adeac87c6ad
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/IAnimator.java
@@ -0,0 +1,63 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import net.minecraft.Util;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+public interface IAnimator {
+
+    @Nullable
+    IAnimator getParent();
+
+    default void animate(boolean reverse) {
+        reset(reverse);
+        resume(reverse);
+    }
+
+    default void animate() {
+        animate(false);
+    }
+
+    boolean stop(boolean force);
+
+    void pause();
+
+    void resume(boolean reverse);
+
+    void reset(boolean atEnd);
+
+    default void reset() {
+        reset(false);
+    }
+
+    /**
+     * Advances the animation by a given duration.
+     *
+     * @param elapsedTime elapsed time in ms
+     * @return remaining time (elapsed time - consumed time)
+     */
+    @ApiStatus.OverrideOnly
+    int advance(int elapsedTime);
+
+    boolean isPaused();
+
+    boolean isAnimating();
+
+    boolean isAnimatingReverse();
+
+    boolean hasProgressed();
+
+    default boolean isAnimatingForward() {
+        return isAnimating() && !isAnimatingReverse();
+    }
+
+    static int getTimeDiff(long startTime) {
+        return getTimeDiff(startTime, Util.getMillis());
+    }
+
+    static int getTimeDiff(long startTime, long currentTime) {
+        long elapsedTime = Math.abs(currentTime - startTime);
+        return (int) Math.min(Integer.MAX_VALUE, elapsedTime);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/MutableObjectAnimator.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/MutableObjectAnimator.java
new file mode 100644
index 00000000000..2e3521ebbb8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/MutableObjectAnimator.java
@@ -0,0 +1,38 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import java.util.function.Consumer;
+
+public class MutableObjectAnimator<T extends IAnimatable<T>> extends Animator {
+
+    private final T from;
+    private final T to;
+    private final T animatable;
+    private Consumer<T> intermediateConsumer;
+
+    public MutableObjectAnimator(T animatable, T from, T to) {
+        this.from = from;
+        this.to = to;
+        this.animatable = animatable;
+        bounds(0f, 1f);
+    }
+
+    @Override
+    public void resume(boolean reverse) {
+        super.resume(reverse);
+        this.animatable.interpolate(this.from, this.to, getRawValue());
+    }
+
+    @Override
+    protected boolean onUpdate() {
+        T intermediate = this.animatable.interpolate(this.from, this.to, getRawValue());
+        if (this.intermediateConsumer != null) {
+            this.intermediateConsumer.accept(intermediate);
+        }
+        return super.onUpdate();
+    }
+
+    public MutableObjectAnimator<T> intermediateConsumer(Consumer<T> consumer) {
+        this.intermediateConsumer = consumer;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/ParallelAnimator.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/ParallelAnimator.java
new file mode 100644
index 00000000000..afe6bcd6e2e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/ParallelAnimator.java
@@ -0,0 +1,121 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ParallelAnimator extends BaseAnimator<ParallelAnimator> implements IAnimator {
+
+    private final List<IAnimator> animators;
+    private int waitTimeBetweenAnimators;
+
+    private int startedAnimating = 0;
+    private int finishedAnimating = 0;
+    private int waitTime = 0;
+
+    public ParallelAnimator(List<IAnimator> animators) {
+        this.animators = new ArrayList<>(animators);
+        this.animators.forEach(animator -> {
+            if (animator instanceof BaseAnimator baseAnimator) {
+                baseAnimator.setParent(this);
+            }
+        });
+    }
+
+    public ParallelAnimator(IAnimator... animators) {
+        this.animators = new ArrayList<>();
+        Collections.addAll(this.animators, animators);
+        this.animators.forEach(animator -> {
+            if (animator instanceof BaseAnimator baseAnimator) {
+                baseAnimator.setParent(this);
+            }
+        });
+    }
+
+    @Override
+    public void animate(boolean reverse) {
+        super.animate(reverse);
+        if (this.waitTimeBetweenAnimators <= 0) {
+            for (IAnimator animator : animators) {
+                animator.animate(reverse);
+            }
+            this.startedAnimating = this.animators.size();
+        } else {
+            this.animators.get(this.startedAnimating).animate(reverse);
+        }
+    }
+
+    @Override
+
+    public boolean stop(boolean force) {
+        if (super.stop(force)) {
+            for (IAnimator animator : animators) {
+                animator.stop(force);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void reset(boolean atEnd) {
+        super.reset(atEnd);
+        this.startedAnimating = 0;
+        this.finishedAnimating = 0;
+        for (IAnimator animator : animators) {
+            animator.reset(atEnd);
+        }
+    }
+
+    @Override
+    public int advance(int elapsedTime) {
+        int remainingTime = 0;
+        for (int i = 0; i < this.startedAnimating; i++) {
+            IAnimator animator = this.animators.get(i);
+            if (!animator.isAnimating()) continue;
+            remainingTime = Math.max(remainingTime, animator.advance(elapsedTime));
+            if (!animator.isAnimating()) {
+                this.finishedAnimating++;
+                if (isFinished()) {
+                    stop(false);
+                    return remainingTime;
+                }
+            }
+        }
+        while (elapsedTime > 0 && this.startedAnimating < this.animators.size()) {
+            int prog = Math.min(elapsedTime, this.waitTimeBetweenAnimators - this.waitTime);
+            this.waitTime += prog;
+            elapsedTime -= prog;
+            if (this.waitTime >= this.waitTimeBetweenAnimators) {
+                this.animators.get(this.startedAnimating).animate(isAnimatingReverse());
+                this.waitTime -= this.waitTimeBetweenAnimators;
+                this.startedAnimating++;
+            }
+        }
+        return Math.min(elapsedTime, remainingTime);
+    }
+
+    public boolean isFinished() {
+        return this.finishedAnimating == this.animators.size();
+    }
+
+    @Override
+    public boolean hasProgressed() {
+        return isAnimating() && this.startedAnimating > 0;
+    }
+
+    public ParallelAnimator waitTimeBetweenAnimators(int waitTime) {
+        this.waitTimeBetweenAnimators = waitTime;
+        return this;
+    }
+
+    @Override
+    public ParallelAnimator inParallelWith(IAnimator animator) {
+        if (isAnimating()) {
+            throw new IllegalStateException("Can't add animators while animating");
+        }
+        reset();
+        this.animators.add(animator);
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/SequentialAnimator.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/SequentialAnimator.java
new file mode 100644
index 00000000000..00c7ba144ed
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/SequentialAnimator.java
@@ -0,0 +1,88 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SequentialAnimator extends BaseAnimator<SequentialAnimator> implements IAnimator {
+
+    private final List<IAnimator> animators;
+    private int currentIndex = 0;
+
+    public SequentialAnimator(List<IAnimator> animators) {
+        this.animators = new ArrayList<>(animators);
+        this.animators.forEach(animator -> {
+            if (animator instanceof BaseAnimator<?> baseAnimator) {
+                baseAnimator.setParent(this);
+            }
+        });
+    }
+
+    public SequentialAnimator(IAnimator... animators) {
+        this.animators = new ArrayList<>();
+        Collections.addAll(this.animators, animators);
+        this.animators.forEach(animator -> {
+            if (animator instanceof BaseAnimator<?> baseAnimator) {
+                baseAnimator.setParent(this);
+            }
+        });
+    }
+
+    @Override
+    public void animate(boolean reverse) {
+        if (this.animators.isEmpty()) return;
+        super.animate(reverse);
+        // start first animation
+        this.animators.get(this.currentIndex).animate(reverse);
+    }
+
+    @Override
+    public void reset(boolean atEnd) {
+        super.reset(atEnd);
+        this.currentIndex = atEnd ? this.animators.size() - 1 : 0;
+        this.animators.forEach(animator -> animator.reset(atEnd));
+    }
+
+    @Override
+    public void resume(boolean reverse) {
+        super.resume(reverse);
+        this.animators.get(this.currentIndex).resume(reverse);
+    }
+
+    @Override
+    public int advance(int elapsedTime) {
+        while (isAnimating() && elapsedTime > 0) {
+            IAnimator animator = this.animators.get(currentIndex);
+            elapsedTime = animator.advance(elapsedTime);
+            if (!animator.isAnimating()) {
+                // animator has finished
+                this.currentIndex += getDirection();
+                // GTCEu.LOGGER.info("Finished {}th animator", this.currentIndex);
+                if (this.currentIndex >= this.animators.size() || this.currentIndex < 0) {
+                    // whole sequence has finished
+                    stop(false);
+                } else {
+                    // start next animation
+                    animator = this.animators.get(this.currentIndex);
+                    animator.animate(isAnimatingReverse());
+                }
+            }
+        }
+        return elapsedTime;
+    }
+
+    @Override
+    public boolean hasProgressed() {
+        return !this.animators.isEmpty() && this.animators.get(0).hasProgressed();
+    }
+
+    @Override
+    public SequentialAnimator followedBy(IAnimator animator) {
+        if (isAnimating()) {
+            throw new IllegalStateException("Can't add animators while animating");
+        }
+        reset();
+        this.animators.add(animator);
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/animation/Wait.java b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/Wait.java
new file mode 100644
index 00000000000..787e863c29a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/animation/Wait.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.api.mui.animation;
+
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+@Accessors(fluent = true, chain = true)
+public class Wait extends BaseAnimator {
+
+    @Setter
+    private int duration;
+    private int progress = 0;
+
+    public Wait() {
+        this(250);
+    }
+
+    public Wait(int duration) {
+        this.duration = duration;
+    }
+
+    @Override
+    public void reset(boolean atEnd) {
+        this.progress = 0;
+    }
+
+    @Override
+    public int advance(int elapsedTime) {
+        int max = this.duration - this.progress;
+        int prog = Math.min(max, elapsedTime);
+        this.progress += prog;
+        if (this.progress >= this.duration) {
+            stop(false);
+        }
+        return elapsedTime - prog;
+    }
+
+    @Override
+    public boolean hasProgressed() {
+        return progress > 0 && isAnimating();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/GuiAxis.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/GuiAxis.java
new file mode 100644
index 00000000000..df57956d26e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/GuiAxis.java
@@ -0,0 +1,19 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+public enum GuiAxis {
+
+    X,
+    Y;
+
+    public boolean isHorizontal() {
+        return this == X;
+    }
+
+    public boolean isVertical() {
+        return this == Y;
+    }
+
+    public GuiAxis getOther() {
+        return this == X ? Y : X;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IItemUIHolder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IItemUIHolder.java
new file mode 100644
index 00000000000..882d174f09c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IItemUIHolder.java
@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryUIFactory;
+
+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;
+
+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;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IJsonSerializable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IJsonSerializable.java
new file mode 100644
index 00000000000..2782f238e76
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IJsonSerializable.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.google.gson.JsonObject;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.Dynamic;
+import com.mojang.serialization.JsonOps;
+import org.jetbrains.annotations.ApiStatus;
+
+public interface IJsonSerializable<T extends IJsonSerializable<T>> {
+
+    /**
+     * Override this
+     * 
+     * @return the codec to serialize this object with
+     */
+    // TODO actually implement on subclasses
+    @ApiStatus.OverrideOnly
+    default Codec<T> getCodec() {
+        return Codec.PASSTHROUGH.flatComapMap(dynamic -> {
+            loadFromJson(dynamic.cast(JsonOps.INSTANCE).getAsJsonObject());
+            return (T) this;
+        }, object -> {
+            JsonObject jsonObject = new JsonObject();
+            if (saveToJson(jsonObject)) {
+                return DataResult.success(new Dynamic<>(JsonOps.INSTANCE, jsonObject));
+            }
+            return DataResult.error(() -> "Failed to serialize drawable %s".formatted(object));
+        });
+    }
+
+    /**
+     * Reads extra json data after this drawable is created.
+     *
+     * @param json json to read from
+     */
+    default void loadFromJson(JsonObject json) {}
+
+    /**
+     * Writes all json data necessary so that deserializing it results in the same drawable.
+     *
+     * @param json json to write to
+     * @return if the drawable was serialized
+     */
+    default boolean saveToJson(JsonObject json) {
+        return false;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IMathValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IMathValue.java
new file mode 100644
index 00000000000..600f53a5dc1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IMathValue.java
@@ -0,0 +1,36 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+/**
+ * Math value interface
+ * <p>
+ * This interface provides only one method which is used by all
+ * mathematical related classes. The point of this interface is to
+ * provide generalized abstract method for computing/fetching some value
+ * from different mathematical classes.
+ */
+public interface IMathValue {
+
+    /**
+     * Get computed or stored value
+     */
+    IMathValue get();
+
+    boolean isNumber();
+
+    void set(double value);
+
+    void set(String value);
+
+    double doubleValue();
+
+    boolean booleanValue();
+
+    String stringValue();
+
+    class EvaluateException extends RuntimeException {
+
+        public EvaluateException(String message) {
+            super(message);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IMuiScreen.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IMuiScreen.java
new file mode 100644
index 00000000000..b9b7f8eb015
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IMuiScreen.java
@@ -0,0 +1,105 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ContainerScreenWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.ScreenWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.core.mixins.client.AbstractContainerScreenAccessor;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.world.inventory.Slot;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Consumer;
+
+/**
+ * Implement this interface on a {@link Screen} to be able to use it as a custom wrapper.
+ * The Screen should have final {@link ModularScreen} field, which is set from the constructor.
+ * Additionally, the Screen MUST call {@link ModularScreen#construct(IMuiScreen)} in its constructor.
+ * See {@link ScreenWrapper ScreenWrapper} and {@link ContainerScreenWrapper GuiContainerWrapper}
+ * for default implementations.
+ */
+@OnlyIn(Dist.CLIENT)
+public interface IMuiScreen {
+
+    /**
+     * Returns the {@link ModularScreen} that is being wrapped. This should return a final instance field.
+     *
+     * @return the wrapped modular screen
+     */
+    @NotNull
+    ModularScreen getScreen();
+
+    /**
+     * This method decides how the gui background is drawn.
+     * The intended usage is to override {@link Screen#renderBackground(GuiGraphics)} and call this method
+     * with the super method reference as the second parameter.
+     *
+     * @param guiGraphics  this screen's {@link GuiGraphics} instance
+     * @param drawFunction a method reference to draw the world background normally with the
+     *                     {@code guiGraphics} as the parameter
+     */
+    @ApiStatus.NonExtendable
+    default void handleDrawBackground(GuiGraphics guiGraphics, Consumer<GuiGraphics> drawFunction) {
+        if (ClientScreenHandler.shouldDrawWorldBackground()) {
+            drawFunction.accept(guiGraphics);
+        }
+        ClientScreenHandler.drawDarkBackground(getWrappedScreen(), guiGraphics);
+    }
+
+    /**
+     * This method is called every time the {@link ModularScreen} resizes.
+     * This usually only affects {@link AbstractContainerScreen AbstractContainerScreens}.
+     *
+     * @param area area of the main panel
+     */
+    default void updateGuiArea(Rectangle area) {
+        if (getWrappedScreen() instanceof AbstractContainerScreenAccessor acc) {
+            acc.setLeftPos(area.x);
+            acc.setTopPos(area.y);
+            acc.setImageWidth(area.width);
+            acc.setImageHeight(area.height);
+        }
+    }
+
+    /**
+     * @return if this wrapper is a {@link AbstractContainerScreen}
+     */
+    @ApiStatus.NonExtendable
+    default boolean isGuiContainer() {
+        return getWrappedScreen() instanceof AbstractContainerScreen<?>;
+    }
+
+    /**
+     * Hovering widget is handled by {@link ModularGuiContext}.
+     * If it detects a slot, this method is called. Only affects {@link AbstractContainerScreen
+     * AbstractContainerScreens}.
+     *
+     * @param slot hovered slot
+     */
+    @ApiStatus.NonExtendable
+    default void setHoveredSlot(Slot slot) {
+        if (getWrappedScreen() instanceof AbstractContainerScreenAccessor acc) {
+            acc.setHoveredSlot(slot);
+        }
+    }
+
+    /**
+     * Returns the {@link Screen} that wraps the {@link ModularScreen}.
+     * In most cases this does not need to be overridden as this interfaces should be implemented on {@link Screen
+     * Screens}.
+     *
+     * @return the wrapping gui screen
+     */
+    default Screen getWrappedScreen() {
+        return (Screen) this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IPacketWriter.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IPacketWriter.java
new file mode 100644
index 00000000000..d1e92c68f13
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IPacketWriter.java
@@ -0,0 +1,24 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import io.netty.buffer.Unpooled;
+
+/**
+ * A function that can write any data to an {@link FriendlyByteBuf}.
+ */
+public interface IPacketWriter {
+
+    /**
+     * Writes any data to a packet buffer
+     *
+     * @param buffer buffer to write to
+     */
+    void write(FriendlyByteBuf buffer);
+
+    default FriendlyByteBuf toPacket() {
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        write(buffer);
+        return buffer;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IPanelHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IPanelHandler.java
new file mode 100644
index 00000000000..776900d4941
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IPanelHandler.java
@@ -0,0 +1,104 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.SecondaryPanel;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * This class can handle opening and closing of a {@link ModularPanel}. It makes sure, that the same panel is not
+ * created multiple
+ * times and instead reused.
+ * <p>
+ * Using {@link #openPanel()} is the only way to open multiple panels.
+ * </p>
+ * <p>
+ * Panels can be closed with {@link #closePanel()}, but also with {@link ModularPanel#closeIfOpen()}.
+ * With the difference, that the method from this interface also works on server
+ * side.
+ * </p>
+ * Synced panels must be created with
+ * {@link PanelSyncManager#syncedPanel(String, boolean, PanelSyncHandler.IPanelBuilder)}.
+ * If the panel does not contain any synced widgets, a simple panel handler using
+ * {@link #simple(ModularPanel, SecondaryPanel.IPanelBuilder, boolean)}
+ * is likely what you need.
+ */
+@ApiStatus.NonExtendable
+public interface IPanelHandler {
+
+    /**
+     * Creates a non synced panel handler. Trying to use synced values anyway will result in a crash.
+     * It only works on client side. Doing anything with it on server side might result in a crash.
+     *
+     * @param parent   an existing parent panel of the gui
+     * @param provider the panel builder, that will create the new panel. It must not return null or the main panel.
+     * @param subPanel true if this panel should close when its parent closes (the parent is defined by the first
+     *                 parameter)
+     * @return a simple panel handler.
+     * @throws NullPointerException     if the build panel of the builder is null
+     * @throws IllegalArgumentException if the build panel of the builder is the main panel or there are synced values
+     *                                  in the panel
+     */
+    static IPanelHandler simple(ModularPanel parent, SecondaryPanel.IPanelBuilder provider, boolean subPanel) {
+        return new SecondaryPanel(parent, provider, subPanel);
+    }
+
+    boolean isPanelOpen();
+
+    /**
+     * Opens the panel. If there is no cached panel, one will be created.
+     * Can be called on both sides if this handler is synced.
+     */
+    void openPanel();
+
+    /**
+     * Initiates the closing animation if the panel is open.
+     * Can be called on both sides if this handler is synced.
+     */
+    void closePanel();
+
+    /**
+     * Initiates the closing animation of all sub panels.
+     * Usually for internal use.
+     */
+    void closeSubPanels();
+
+    /**
+     * Called internally after the panel is closed.
+     */
+    @ApiStatus.OverrideOnly
+    void closePanelInternal();
+
+    /**
+     * Toggles this panel open or closed. Delegates to {@link #openPanel()} and {@link #closePanel()}.
+     *
+     * @return {@code true} if the panel was opened, {@code false} if it was closed
+     */
+    default boolean togglePanel() {
+        if (isPanelOpen()) {
+            closePanel();
+            return false;
+        } else {
+            openPanel();
+            return true;
+        }
+    }
+
+    /**
+     * Deletes the current cached panel. Should not be used frequently.
+     * This only works on panels which don't have {@link ItemSlotSyncHandler} sync handlers.
+     *
+     * @throws UnsupportedOperationException if this handler has ItemSlot sync handlers
+     */
+    void deleteCachedPanel();
+
+    /**
+     * If this is a sub panel of another panel. A sub panel will be closed when its parent is closed.
+     *
+     * @return true if this is a sub panel
+     */
+    boolean isSubPanel();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/ISyncedAction.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/ISyncedAction.java
new file mode 100644
index 00000000000..2ded1a87fb7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/ISyncedAction.java
@@ -0,0 +1,13 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@FunctionalInterface
+public interface ISyncedAction {
+
+    @ApiStatus.OverrideOnly
+    void invoke(@NotNull FriendlyByteBuf packet);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/ITheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/ITheme.java
new file mode 100644
index 00000000000..cf2b4c135a7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/ITheme.java
@@ -0,0 +1,59 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.mui.theme.*;
+
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.Collection;
+
+/**
+ * A theme is parsed from json and contains style information like color or background texture.
+ */
+public interface ITheme {
+
+    /**
+     * @return the master default theme.
+     */
+    static ITheme getDefault() {
+        return IThemeApi.get().getDefaultTheme();
+    }
+
+    /**
+     * @param id theme id
+     * @return theme with given id
+     */
+    static ITheme get(String id) {
+        return IThemeApi.get().getTheme(id);
+    }
+
+    /**
+     * @return theme id
+     */
+    String getId();
+
+    /**
+     * @return parent theme
+     */
+    ITheme getParentTheme();
+
+    @UnmodifiableView
+    Collection<WidgetThemeEntry<?>> getWidgetThemes();
+
+    WidgetThemeEntry<WidgetTheme> getFallback();
+
+    WidgetThemeEntry<WidgetTheme> getPanelTheme();
+
+    WidgetThemeEntry<WidgetTheme> getButtonTheme();
+
+    WidgetThemeEntry<WidgetTheme> getScrollbarTheme();
+
+    WidgetThemeEntry<SlotTheme> getItemSlotTheme();
+
+    WidgetThemeEntry<SlotTheme> getFluidSlotTheme();
+
+    WidgetThemeEntry<TextFieldTheme> getTextFieldTheme();
+
+    WidgetThemeEntry<SelectableTheme> getToggleButtonTheme();
+
+    <T extends WidgetTheme> WidgetThemeEntry<T> getWidgetTheme(WidgetThemeKey<T> key);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IThemeApi.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IThemeApi.java
new file mode 100644
index 00000000000..1f5a6fe2c50
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IThemeApi.java
@@ -0,0 +1,232 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.Scrollbar;
+import com.gregtechceu.gtceu.api.mui.theme.*;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+
+import org.jetbrains.annotations.*;
+
+import java.util.List;
+
+/**
+ * An API interface for Themes.
+ */
+@ApiStatus.NonExtendable
+public interface IThemeApi {
+
+    // widget themes
+    WidgetThemeKey<WidgetTheme> FALLBACK = get().widgetThemeKeyBuilder("default", WidgetTheme.class)
+            .defaultTheme(WidgetTheme.darkTextNoShadow(18, 18, null))
+            .register();
+
+    WidgetThemeKey<WidgetTheme> PANEL = get().widgetThemeKeyBuilder("panel", WidgetTheme.class)
+            .defaultTheme(WidgetTheme.darkTextNoShadow(176, 166, GTGuiTextures.BACKGROUND))
+            .register();
+
+    WidgetThemeKey<WidgetTheme> BUTTON = get().widgetThemeKeyBuilder("button", WidgetTheme.class)
+            .defaultTheme(WidgetTheme.whiteTextShadow(18, 18, GTGuiTextures.MC_BUTTON))
+            .defaultHoverTheme(WidgetTheme.whiteTextShadow(18, 18, GTGuiTextures.MC_BUTTON_HOVERED))
+            .register();
+
+    WidgetThemeKey<WidgetTheme> CLOSE_BUTTON = get().widgetThemeKeyBuilder("closeButton", WidgetTheme.class)
+            .defaultTheme(WidgetTheme.whiteTextShadow(10, 10, GTGuiTextures.MC_BUTTON))
+            .defaultHoverTheme(WidgetTheme.whiteTextShadow(10, 10, GTGuiTextures.MC_BUTTON_HOVERED))
+            .register();
+
+    WidgetThemeKey<WidgetTheme> SCROLLBAR = get().widgetThemeKeyBuilder("scrollbar", WidgetTheme.class)
+            .defaultTheme(WidgetTheme.darkTextNoShadow(4, 4, Scrollbar.VANILLA))
+            .register();
+
+    WidgetThemeKey<SlotTheme> ITEM_SLOT = get().widgetThemeKeyBuilder("itemSlot", SlotTheme.class)
+            .defaultTheme(new SlotTheme(GTGuiTextures.SLOT))
+            .register();
+
+    WidgetThemeKey<SlotTheme> FLUID_SLOT = get().widgetThemeKeyBuilder("fluidSlot", SlotTheme.class)
+            .defaultTheme(new SlotTheme(GTGuiTextures.FLUID_SLOT))
+            .register();
+
+    WidgetThemeKey<TextFieldTheme> TEXT_FIELD = get().widgetThemeKeyBuilder("textField", TextFieldTheme.class)
+            .defaultTheme(new TextFieldTheme(0xFF2F72A8, 0xFF5F5F5F))
+            .register();
+
+    WidgetThemeKey<SelectableTheme> TOGGLE_BUTTON = get().widgetThemeKeyBuilder("toggleButton", SelectableTheme.class)
+            .defaultTheme(
+                    SelectableTheme.whiteTextShadow(18, 18, GTGuiTextures.MC_BUTTON, GTGuiTextures.MC_BUTTON_DISABLED))
+            .defaultHoverTheme(SelectableTheme.whiteTextShadow(18, 18, GTGuiTextures.MC_BUTTON_HOVERED,
+                    IDrawable.NONE))
+            .register();
+
+    // subwidget themes
+    WidgetThemeKey<SlotTheme> ITEM_SLOT_PLAYER = ITEM_SLOT.createSubKey("player");
+    WidgetThemeKey<SlotTheme> ITEM_SLOT_PLAYER_HOTBAR = ITEM_SLOT_PLAYER.createSubKey("playerHotbar");
+    WidgetThemeKey<SlotTheme> ITEM_SLOT_PLAYER_MAIN_INV = ITEM_SLOT_PLAYER.createSubKey("playerMainInventory");
+    WidgetThemeKey<SlotTheme> ITEM_SLOT_PLAYER_OFFHAND = ITEM_SLOT_PLAYER.createSubKey("playerOffhand");
+    WidgetThemeKey<SlotTheme> ITEM_SLOT_PLAYER_ARMOR = ITEM_SLOT_PLAYER.createSubKey("playerArmor");
+
+    String HOVER_SUFFIX = ":hover";
+
+    // properties
+    String PARENT = "parent";
+    String DEFAULT_WIDTH = "defaultWidth";
+    String DEFAULT_HEIGHT = "defaultHeight";
+    String BACKGROUND = "background";
+    String HOVER_BACKGROUND = "hoverBackground";
+    String COLOR = "color";
+    String TEXT_COLOR = "textColor";
+    String TEXT_SHADOW = "textShadow";
+    String ICON_COLOR = "iconColor";
+    String SLOT_HOVER_COLOR = "slotHoverColor";
+    String MARKED_COLOR = "markedColor";
+    String HINT_COLOR = "hintColor";
+    String SELECTED_BACKGROUND = "selectedBackground";
+    String SELECTED_COLOR = "selectedColor";
+    String SELECTED_TEXT_COLOR = "selectedTextColor";
+    String SELECTED_TEXT_SHADOW = "selectedTextShadow";
+    String SELECTED_ICON_COLOR = "selectedIconColor";
+
+    /**
+     * @return the default api implementation
+     */
+    @Contract(pure = true)
+    static IThemeApi get() {
+        return ThemeAPI.INSTANCE;
+    }
+
+    /**
+     * @return the absolute fallback theme
+     */
+    ITheme getDefaultTheme();
+
+    /**
+     * Finds a theme for an id
+     *
+     * @param id id of the theme
+     * @return the found theme or {@link #getDefaultTheme()} if no theme was found
+     */
+    @NotNull
+    ITheme getTheme(String id);
+
+    /**
+     * @param id id of the theme
+     * @return if a theme with the id is registered
+     */
+    boolean hasTheme(String id);
+
+    /**
+     * Registers a theme json object. Themes from resource packs always have greater priority.
+     * Json builders are used here as they are much easier to merge as opposed to normal java objects.
+     *
+     * @param id   id of the theme
+     * @param json theme data
+     */
+    void registerTheme(String id, JsonBuilder json);
+
+    /**
+     * Registers a theme json object. Themes from resource packs always have greater priority.
+     *
+     * @param themeBuilder theme data
+     */
+    default void registerTheme(ThemeBuilder<?> themeBuilder) {
+        registerTheme(themeBuilder.getId(), themeBuilder);
+    }
+
+    /**
+     * Gets all currently from java side registered theme json's for a theme.
+     *
+     * @param id id of the theme
+     * @return all theme json's for a theme.
+     */
+    List<JsonBuilder> getJavaDefaultThemes(String id);
+
+    /**
+     * Gets the appropriate theme for a screen.
+     *
+     * @param owner        owner of the screen
+     * @param name         name of the screen
+     * @param defaultTheme default theme if no theme was found
+     * @return the registered theme for the given screen or the given default theme or {@link #getDefaultTheme()}
+     */
+    default ITheme getThemeForScreen(String owner, String name, @Nullable String defaultTheme,
+                                     @Nullable String fallbackTheme) {
+        return getThemeForScreen(owner, name, null, defaultTheme, fallbackTheme);
+    }
+
+    /**
+     * Gets the appropriate theme for a screen.
+     *
+     * @param owner        owner of the screen
+     * @param name         name of the screen
+     * @param panel        the name
+     * @param defaultTheme default theme if no theme was found
+     * @return the registered theme for the given screen or the given default theme or {@link #getDefaultTheme()}
+     */
+    ITheme getThemeForScreen(String owner, String name, @Nullable String panel, @Nullable String defaultTheme,
+                             @Nullable String fallbackTheme);
+
+    /**
+     * Gets the appropriate theme for a specific panel.
+     *
+     * @param panel        the panel to find a theme for
+     * @param defaultTheme default theme if no theme was found
+     * @return the registered theme for the given screen or the given default theme or {@link #getDefaultTheme()}
+     */
+    default ITheme getThemeForScreen(ModularPanel panel, @Nullable String defaultTheme) {
+        ModularScreen screen = panel.getScreen();
+        return getThemeForScreen(screen.getOwner(), screen.getName(), panel.getName(), defaultTheme,
+                screen.getThemeOverride());
+    }
+
+    /**
+     * Gets the appropriate theme for a screen.
+     *
+     * @param screen       screen
+     * @param defaultTheme default theme if no theme was found
+     * @return the registered theme for the given screen or the given default theme or {@link #getDefaultTheme()}
+     */
+    default ITheme getThemeForScreen(ModularScreen screen, @Nullable String defaultTheme) {
+        return getThemeForScreen(screen.getOwner(), screen.getName(), defaultTheme, null);
+    }
+
+    /**
+     * Registers a theme for a screen. Themes from resource packs always have greater priority.
+     *
+     * @param owner owner of the screen
+     * @param name  name of the screen
+     * @param theme theme to register
+     */
+    default void registerThemeForScreen(String owner, String name, String theme) {
+        registerThemeForScreen(owner + ":" + name, theme);
+    }
+
+    /**
+     * Registers a theme for a screen. Themes from resource packs always have greater priority.
+     *
+     * @param screen full screen id
+     * @param theme  theme to register
+     */
+    void registerThemeForScreen(String screen, String theme);
+
+    /**
+     * Registers a widget theme. It is recommended to store the resulting key in a static variable and make it
+     * accessible by public methods.
+     *
+     * @param id                id of the widget theme
+     * @param defaultTheme      the fallback widget theme
+     * @param defaultHoverTheme the fallback hover widget theme
+     * @param parser            the widget theme json parser function. This is usually another constructor.
+     * @return key to access the widget theme
+     */
+    <T extends WidgetTheme> WidgetThemeKey<T> registerWidgetTheme(String id, T defaultTheme, T defaultHoverTheme,
+                                                                  WidgetThemeParser<T> parser);
+
+    default <T extends WidgetTheme> WidgetThemeKeyBuilder<T> widgetThemeKeyBuilder(String id, Class<T> type) {
+        return new WidgetThemeKeyBuilder<>(id);
+    }
+
+    @UnmodifiableView
+    List<WidgetThemeKey<?>> getWidgetThemeKeys();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/ITreeNode.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/ITreeNode.java
new file mode 100644
index 00000000000..734788304e9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/ITreeNode.java
@@ -0,0 +1,18 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import java.util.List;
+
+public interface ITreeNode<T extends ITreeNode<T>> {
+
+    T getParent();
+
+    default boolean hasParent() {
+        return getParent() != null;
+    }
+
+    List<T> getChildren();
+
+    default boolean hasChildren() {
+        return !getChildren().isEmpty();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/IUIHolder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IUIHolder.java
new file mode 100644
index 00000000000..ce498c5f101
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/IUIHolder.java
@@ -0,0 +1,47 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+/**
+ * An interface to implement on {@link net.minecraft.world.level.block.entity.BlockEntity} or
+ * {@link net.minecraft.world.item.Item}.
+ */
+@FunctionalInterface
+public interface IUIHolder<T extends GuiData> {
+
+    /**
+     * Only called on client side.
+     *
+     * @param data      information about the creation context
+     * @param mainPanel the panel created in {@link #buildUI(GuiData, PanelSyncManager, UISettings)}
+     * @return a modular screen instance with the given panel
+     */
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(T data, ModularPanel mainPanel) {
+        GTCEu.LOGGER
+                .warn("IGuiHolder.createScreen() should be overridden to pass your own mod id to the ModularScreen." +
+                        " In future versions this method must be overridden or else it will crash!");
+        return new ModularScreen(GTCEu.MOD_ID, mainPanel);
+    }
+
+    /**
+     * Called on server and client. Create only the main panel here. Only here you can add sync handlers to widgets
+     * directly.
+     * If the widget to be synced is not in this panel yet (f.e. in another panel) the sync handler must be registered
+     * here
+     * with {@link PanelSyncManager}.
+     *
+     * @param data        information about the creation context
+     * @param syncManager sync handler where widget sync handlers should be registered
+     * @param settings    settings which apply to the whole ui and not just this panel
+     */
+    ModularPanel buildUI(T data, PanelSyncManager syncManager, UISettings settings);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/MCHelper.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/MCHelper.java
new file mode 100644
index 00000000000..e6ef11fb86e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/MCHelper.java
@@ -0,0 +1,74 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.List;
+
+public class MCHelper {
+
+    @SideOnly(Side.CLIENT)
+    public static Minecraft getMc() {
+        return Minecraft.getInstance();
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static Player getPlayer() {
+        return getMc().player;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static boolean closeScreen() {
+        getMc().popGuiLayer();
+        return false;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static void popScreen(boolean openParentOnClose, Screen parent) {
+        Player player = MCHelper.getPlayer();
+        if (player != null) {
+            // container should not just be closed here
+            // instead they are kept in a stack until all screens are closed
+            // prepareCloseContainer(player);
+            if (openParentOnClose) {
+                Minecraft.getInstance().setScreen(parent);
+                ModularNetwork.CLIENT.reopenSyncerOf(parent);
+            } else {
+                Minecraft.getInstance().setScreen(null);
+            }
+        } else {
+            // we are currently not in a world and want to display the previous screen
+            Minecraft.getInstance().setScreen(parent);
+        }
+    }
+
+    public static void setScreen(Screen screen) {
+        if (screen == null) {
+            closeScreen();
+        } else {
+            getMc().setScreen(screen);
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static Screen getCurrentScreen() {
+        return getMc().screen;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static Font getFont() {
+        return getMc().font;
+    }
+
+    public static List<Component> getItemToolTip(ItemStack item) {
+        return Screen.getTooltipFromItem(getMc(), item);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/RecipeViewerSettings.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/RecipeViewerSettings.java
new file mode 100644
index 00000000000..bc644585695
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/RecipeViewerSettings.java
@@ -0,0 +1,122 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Keeps track of everything related to JEI in a Modular GUI.
+ * By default, JEI is disabled in client only GUIs.
+ * This class can be safely interacted with even when JEI/HEI is not installed.
+ */
+@ApiStatus.NonExtendable
+public interface RecipeViewerSettings {
+
+    /**
+     * Force recipe viewer to be enabled
+     */
+    void enable();
+
+    /**
+     * Force recipe viewer to be disabled
+     */
+    void disable();
+
+    /**
+     * Only enable the recipe viewer in synced GUIs
+     */
+    void defaultState();
+
+    /**
+     * Checks if the recipe viewer is enabled for a given screen
+     *
+     * @param screen modular screen
+     * @return true if the recipe viewer is enabled
+     */
+    boolean isEnabled(ModularScreen screen);
+
+    /**
+     * Adds an exclusion zone. Recipe viewers will always try to avoid exclusion zones. <br>
+     * <b>If a widgets wishes to have an exclusion zone it should use {@link #addExclusionArea(IWidget)}!</b>
+     *
+     * @param area exclusion area
+     */
+    void addExclusionArea(Rectangle area);
+
+    /**
+     * Removes an exclusion zone.
+     *
+     * @param area exclusion area to remove (must be the same instance)
+     */
+    void removeExclusionArea(Rectangle area);
+
+    /**
+     * Adds an exclusion zone of a widget. Recipe viewers will always try to avoid exclusion zones. <br>
+     * Useful when a widget is outside its panel.
+     *
+     * @param area widget
+     */
+    void addExclusionArea(IWidget area);
+
+    /**
+     * Removes a widget exclusion area.
+     *
+     * @param area widget
+     */
+    void removeExclusionArea(IWidget area);
+
+    /**
+     * Adds a recipe viewer ghost slot. Ghost slots can display an ingredient, but the ingredient does not really exist.
+     * By calling this method users will be able to drag ingredients from recipe viewers into the slot.
+     *
+     * @param slot slot widget
+     * @param <W>  slot widget type
+     */
+    <W extends IWidget & GhostIngredientSlot<?>> void addGhostIngredientSlot(W slot);
+
+    /**
+     * Removes a recipe viewer ghost slot.
+     *
+     * @param slot slot widget
+     * @param <W>  slot widget type
+     */
+    <W extends IWidget & GhostIngredientSlot<?>> void removeGhostIngredientSlot(W slot);
+
+    RecipeViewerSettings DUMMY = new RecipeViewerSettings() {
+
+        @Override
+        public void enable() {}
+
+        @Override
+        public void disable() {}
+
+        @Override
+        public void defaultState() {}
+
+        @Override
+        public boolean isEnabled(ModularScreen screen) {
+            return false;
+        }
+
+        @Override
+        public void addExclusionArea(Rectangle area) {}
+
+        @Override
+        public void removeExclusionArea(Rectangle area) {}
+
+        @Override
+        public void addExclusionArea(IWidget area) {}
+
+        @Override
+        public void removeExclusionArea(IWidget area) {}
+
+        @Override
+        public <W extends IWidget & GhostIngredientSlot<?>> void addGhostIngredientSlot(W slot) {}
+
+        @Override
+        public <W extends IWidget & GhostIngredientSlot<?>> void removeGhostIngredientSlot(W slot) {}
+    };
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/UIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/UIFactory.java
new file mode 100644
index 00000000000..0d58fc06be3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/UIFactory.java
@@ -0,0 +1,114 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.*;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An interface for UI factories. They are responsible for opening synced GUIs and syncing necessary data.
+ *
+ * @param <D> gui data type
+ */
+public interface UIFactory<D extends GuiData> {
+
+    /**
+     * The name of this factory. Must be constant.
+     *
+     * @return the factory name
+     */
+    @NotNull
+    ResourceLocation getFactoryName();
+
+    /**
+     * Creates the main panel for the GUI. Is called on client and server side.
+     *
+     * @param guiData     gui data
+     * @param syncManager sync manager
+     * @param settings    ui settings
+     * @return new main panel
+     */
+    @ApiStatus.OverrideOnly
+    ModularPanel createPanel(D guiData, PanelSyncManager syncManager, UISettings settings);
+
+    /**
+     * Creates the screen for the GUI. Is only called on client side.
+     *
+     * @param guiData   gui data
+     * @param mainPanel main panel created in {@link #createPanel(GuiData, PanelSyncManager, UISettings)}
+     * @return new main panel
+     */
+    @OnlyIn(Dist.CLIENT)
+    @ApiStatus.OverrideOnly
+    ModularScreen createScreen(D guiData, ModularPanel mainPanel);
+
+    /**
+     * Creates the screen wrapper for the GUI. Is only called on client side.
+     *
+     * @param container container for the gui
+     * @param screen    the screen which was created in {@link #createScreen(GuiData, ModularPanel)}
+     * @return new screen wrapper
+     * @throws IllegalStateException if the wrapping screen is not a
+     *                               {@link AbstractContainerMenu AbstractContainerMenu}
+     *                               or if the container inside is not the same as the one passed to this method.
+     *                               This method is not the thrower, but the caller of this method.
+     */
+    @OnlyIn(Dist.CLIENT)
+    @ApiStatus.OverrideOnly
+    default IMuiScreen createScreenWrapper(ModularContainerMenu container, ModularScreen screen) {
+        return new ContainerScreenWrapper(container, screen);
+    }
+
+    /**
+     * The default container supplier. This is called when no custom container in {@link UISettings} is set.
+     *
+     * @return new container instance
+     */
+    default ModularContainerMenu createContainer(int containerId) {
+        return new ModularContainerMenu(containerId);
+    }
+
+    /**
+     * A default function to check if the current interacting player can interact with the ui. If not overridden on
+     * {@link UISettings},
+     * then this is called every tick while a UI opened by this factory is open. Once this function returns false, the
+     * UI is immediately
+     * closed.
+     *
+     * @param player  current interacting player
+     * @param guiData gui data of the current ui
+     * @return if the player can interact with the player.
+     */
+    default boolean canInteractWith(Player player, D guiData) {
+        return player == guiData.getPlayer();
+    }
+
+    /**
+     * Writes the gui data to a buffer.
+     *
+     * @param guiData gui data
+     * @param buffer  buffer
+     */
+    @ApiStatus.OverrideOnly
+    void writeGuiData(D guiData, FriendlyByteBuf buffer);
+
+    /**
+     * Reads and creates the gui data from the buffer.
+     *
+     * @param player player
+     * @param buffer buffer
+     * @return new gui data
+     */
+    @NotNull
+    @ApiStatus.OverrideOnly
+    D readGuiData(Player player, FriendlyByteBuf buffer);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IDrawable.java
new file mode 100644
index 00000000000..052c7ebce4d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IDrawable.java
@@ -0,0 +1,219 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableStack;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * An object which can be drawn at any size. This is mainly used for backgrounds and overlays in
+ * {@link com.gregtechceu.gtceu.api.mui.base.widget.IWidget}.
+ * To draw at a fixed size, use {@link IIcon} (see {@link #asIcon()}).
+ */
+public interface IDrawable {
+
+    static IDrawable of(IDrawable... drawables) {
+        if (drawables == null || drawables.length == 0) {
+            return null;
+        } else if (drawables.length == 1) {
+            return drawables[0];
+        } else {
+            return new DrawableStack(drawables);
+        }
+    }
+
+    /**
+     * Draws this drawable at the given position with the given size. It's the implementors responsibility to properly
+     * apply the widget theme by calling {@link #applyColor(int)} before drawing.
+     *
+     * @param context     current context to draw with
+     * @param x           x position
+     * @param y           y position
+     * @param width       draw width
+     * @param height      draw height
+     * @param widgetTheme current theme
+     */
+    @OnlyIn(Dist.CLIENT)
+    void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme);
+
+    /**
+     * Draws this drawable at the current (0|0) with the given size. This is useful inside widgets since GL is
+     * transformed to their position when they are drawing.
+     *
+     * @param context     gui context
+     * @param width       draw width
+     * @param height      draw height
+     * @param widgetTheme current theme
+     */
+    @OnlyIn(Dist.CLIENT)
+    default void drawAtZero(GuiContext context, int width, int height, WidgetTheme widgetTheme) {
+        draw(context, 0, 0, width, height, widgetTheme);
+    }
+
+    /**
+     * Draws this drawable in a given area. The padding of the area is not applied here.
+     *
+     * @param context     current context to draw with
+     * @param area        draw area
+     * @param widgetTheme current theme
+     */
+    @OnlyIn(Dist.CLIENT)
+    default void draw(GuiContext context, Area area, WidgetTheme widgetTheme) {
+        draw(context, area.x, area.y, area.width,
+                area.height, widgetTheme);
+    }
+
+    /**
+     * Draws this drawable in a given area with its padding applied.
+     *
+     * @param context     current context to draw with
+     * @param area        draw area
+     * @param widgetTheme current theme
+     */
+    @OnlyIn(Dist.CLIENT)
+    default void drawPadded(GuiContext context, Area area, WidgetTheme widgetTheme) {
+        draw(context, area.x + area.getPadding().left(), area.y + area.getPadding().top(),
+                area.paddedWidth(), area.paddedHeight(), widgetTheme);
+    }
+
+    /**
+     * Draws this drawable at the current (0|0) with the given area's size. This is useful inside widgets since GL is
+     * transformed to their position when they are drawing. The padding of the area is not applied here.
+     *
+     * @param context     gui context
+     * @param area        draw area
+     * @param widgetTheme current theme
+     */
+    @OnlyIn(Dist.CLIENT)
+    default void drawAtZero(GuiContext context, Area area, WidgetTheme widgetTheme) {
+        draw(context, 0, 0, area.width, area.height, widgetTheme);
+    }
+
+    /**
+     * Draws this drawable at the current (0|0) with the given area's size and its padding applied
+     * (this means its technically not at 0|0). This is useful inside widgets since GL is transformed to their position
+     * when they are drawing.
+     *
+     * @param context     gui context
+     * @param area        draw area
+     * @param widgetTheme current theme
+     */
+    @OnlyIn(Dist.CLIENT)
+    default void drawAtZeroPadded(GuiContext context, Area area, WidgetTheme widgetTheme) {
+        draw(context, area.getPadding().left(), area.getPadding().top(), area.paddedWidth(), area.paddedHeight(),
+                widgetTheme);
+    }
+
+    /**
+     * @return if theme color can be applied on this drawable
+     */
+    default boolean canApplyTheme() {
+        return false;
+    }
+
+    /**
+     * Applies the theme color to OpenGL if this drawable can have theme colors applied. This is determined by
+     * {@link #canApplyTheme()}.
+     * If this drawable does not allow theme colors, it will reset the current color (to white).
+     * This method should be called before drawing.
+     *
+     * @param themeColor theme color to apply (usually {@link WidgetTheme#getColor()})
+     */
+    default void applyColor(int themeColor) {
+        if (canApplyTheme()) {
+            Color.setGlColor(themeColor);
+        } else {
+            Color.setGlColorOpaque(Color.WHITE.main);
+        }
+    }
+
+    default int getDefaultWidth() {
+        return 0;
+    }
+
+    default int getDefaultHeight() {
+        return 0;
+    }
+
+    /**
+     * @return a widget with this drawable as a background
+     */
+    default Widget<?> asWidget() {
+        return new DrawableWidget(this);
+    }
+
+    /**
+     * @return this drawable as an icon
+     */
+    default Icon asIcon() {
+        return new Icon(this).size(getDefaultWidth(), getDefaultHeight());
+    }
+
+    /**
+     * An empty drawable. Does nothing.
+     */
+    IDrawable EMPTY = (context, x, y, width, height, widgetTheme) -> {};
+
+    /**
+     * An empty drawable used to mark hover textures as "should not be used"!
+     */
+    IDrawable NONE = (context, x, y, width, height, widgetTheme) -> {};
+
+    static boolean isVisible(@Nullable IDrawable drawable) {
+        if (drawable == null || drawable == EMPTY || drawable == NONE) return false;
+        if (drawable instanceof DrawableStack array) {
+            return array.getDrawables().length > 0;
+        }
+        return true;
+    }
+
+    /**
+     * A widget wrapping a drawable. The drawable is drawn between the background and the overlay.
+     */
+    class DrawableWidget extends Widget<DrawableWidget> {
+
+        private final IDrawable drawable;
+
+        public DrawableWidget(IDrawable drawable) {
+            this.drawable = drawable;
+        }
+
+        @OnlyIn(Dist.CLIENT)
+        @Override
+        public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+            this.drawable.drawAtZero(context, getArea(), getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+    }
+
+    /**
+     * A widget wrapping multiple drawables
+     */
+    class MultiDrawableWidget extends Widget<MultiDrawableWidget> {
+
+        private final IDrawable[] drawables;
+
+        public MultiDrawableWidget(IDrawable... drawables) {
+            this.drawables = drawables;
+        }
+
+        @OnlyIn(Dist.CLIENT)
+        @Override
+        public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+            for (IDrawable drawable : this.drawables) {
+                drawable.draw(context, getArea().getPadding().left(), getArea().getPadding().top(),
+                        getArea().paddedWidth(), getArea().paddedHeight(),
+                        getActiveWidgetTheme(widgetTheme, isHovering()));
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IHoverable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IHoverable.java
new file mode 100644
index 00000000000..fdca45a2433
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IHoverable.java
@@ -0,0 +1,38 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+import com.gregtechceu.gtceu.api.mui.drawable.text.RichText;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * This marks an {@link IDrawable} as hoverable in a {@link RichText RichText}. This should not be
+ * extended in most cases instead obtain an instance by calling {@link IIcon#asHoverable()}.
+ */
+@ApiStatus.NonExtendable
+public interface IHoverable extends IIcon {
+
+    /**
+     * Called every frame this hoverable is hovered inside a
+     * {@link com.gregtechceu.gtceu.api.mui.drawable.text.RichText RichText}.
+     */
+    default void onHover() {}
+
+    @Nullable
+    default RichTooltip getTooltip() {
+        return null;
+    }
+
+    /**
+     * An internal function to set the current rendered position. This is used to detect if this element is under the
+     * mouse.
+     */
+    void setRenderedAt(int x, int y);
+
+    /**
+     * @return the last area this drawable was drawn at.
+     */
+    Area getRenderedArea();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IIcon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IIcon.java
new file mode 100644
index 00000000000..23035e1750c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IIcon.java
@@ -0,0 +1,78 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.drawable.HoverableIcon;
+import com.gregtechceu.gtceu.api.mui.drawable.InteractableIcon;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A {@link IDrawable} with a fixed size.
+ */
+public interface IIcon extends IDrawable {
+
+    /**
+     * @return the drawable this icon wraps or null if it doesn't wrap anything
+     */
+    @Nullable
+    IDrawable getWrappedDrawable();
+
+    /**
+     * @return width of this icon or 0 if the width should be dynamic
+     */
+    int getWidth();
+
+    /**
+     * @return height of this icon or 0 of the height should be dynamic
+     */
+    int getHeight();
+
+    default int getSize(GuiAxis axis) {
+        return axis.isHorizontal() ? getWidth() : getHeight();
+    }
+
+    @Override
+    default int getDefaultWidth() {
+        return getWrappedDrawable() != null ? getWrappedDrawable().getDefaultWidth() : 0;
+    }
+
+    @Override
+    default int getDefaultHeight() {
+        return getWrappedDrawable() != null ? getWrappedDrawable().getDefaultHeight() : 0;
+    }
+
+    /**
+     * @return the margin of this icon. Only used if width or height is 0
+     */
+    Box getMargin();
+
+    default IDrawable getRootDrawable() {
+        IDrawable drawable = this;
+        while (drawable instanceof IIcon icon) {
+            drawable = icon.getWrappedDrawable();
+            if (drawable == null) return icon;
+        }
+        return drawable;
+    }
+
+    /**
+     * This returns a hoverable wrapper of this icon. This is only used in
+     * {@link com.gregtechceu.gtceu.api.mui.drawable.text.RichText RichText}.
+     * This allows this icon to have its own tooltip.
+     */
+    default HoverableIcon asHoverable() {
+        return new HoverableIcon(this);
+    }
+
+    /**
+     * This returns an interactable wrapper of this icon. This is only used in
+     * {@link com.gregtechceu.gtceu.api.mui.drawable.text.RichText RichText}.
+     * This allows this icon to be able to listen to clicks and other inputs.
+     */
+    default InteractableIcon asInteractable() {
+        return new InteractableIcon(this);
+    }
+
+    IIcon EMPTY_2PX = EMPTY.asIcon().height(2);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IInterpolation.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IInterpolation.java
new file mode 100644
index 00000000000..d008d1ccc81
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IInterpolation.java
@@ -0,0 +1,17 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+/**
+ * A function which interpolates between two values.
+ */
+public interface IInterpolation {
+
+    /**
+     * Calculates a new value between a and b based on a curve.
+     *
+     * @param a start value
+     * @param b end value
+     * @param x progress (between 0.0 and 1.0)
+     * @return new value
+     */
+    float interpolate(float a, float b, float x);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IKey.java
new file mode 100644
index 00000000000..7183f99f616
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IKey.java
@@ -0,0 +1,329 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.drawable.text.*;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonObject;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
+
+/**
+ * This represents a piece of text in a GUI.
+ */
+public interface IKey extends IDrawable, IJsonSerializable<IKey> {
+
+    int TEXT_COLOR = 0xFF404040;
+
+    TextRenderer renderer = new TextRenderer();
+
+    IKey EMPTY = str("");
+    IKey LINE_FEED = str("\n");
+    IKey SPACE = str(" ");
+
+    // Formatting for convenience
+    ChatFormatting BLACK = ChatFormatting.BLACK;
+    ChatFormatting DARK_BLUE = ChatFormatting.DARK_BLUE;
+    ChatFormatting DARK_GREEN = ChatFormatting.DARK_GREEN;
+    ChatFormatting DARK_AQUA = ChatFormatting.DARK_AQUA;
+    ChatFormatting DARK_RED = ChatFormatting.DARK_RED;
+    ChatFormatting DARK_PURPLE = ChatFormatting.DARK_PURPLE;
+    ChatFormatting GOLD = ChatFormatting.GOLD;
+    ChatFormatting GRAY = ChatFormatting.GRAY;
+    ChatFormatting DARK_GRAY = ChatFormatting.DARK_GRAY;
+    ChatFormatting BLUE = ChatFormatting.BLUE;
+    ChatFormatting GREEN = ChatFormatting.GREEN;
+    ChatFormatting AQUA = ChatFormatting.AQUA;
+    ChatFormatting RED = ChatFormatting.RED;
+    ChatFormatting LIGHT_PURPLE = ChatFormatting.LIGHT_PURPLE;
+    ChatFormatting YELLOW = ChatFormatting.YELLOW;
+    ChatFormatting WHITE = ChatFormatting.WHITE;
+    ChatFormatting OBFUSCATED = ChatFormatting.OBFUSCATED;
+    ChatFormatting BOLD = ChatFormatting.BOLD;
+    ChatFormatting STRIKETHROUGH = ChatFormatting.STRIKETHROUGH;
+    ChatFormatting UNDERLINE = ChatFormatting.UNDERLINE;
+    ChatFormatting ITALIC = ChatFormatting.ITALIC;
+    ChatFormatting RESET = ChatFormatting.RESET;
+
+    /**
+     * Creates a translated text.
+     *
+     * @param key translation key
+     * @return text key
+     */
+    static IKey lang(@NotNull String key) {
+        return new LangKey(key);
+    }
+
+    /**
+     * Creates a translated text.
+     *
+     * @param component translation component
+     * @return text key
+     */
+    static IKey lang(@NotNull Component component) {
+        return new LangKey(component);
+    }
+
+    /**
+     * Creates a translated text with arguments. The arguments can change.
+     *
+     * @param key  translation key
+     * @param args translation arguments
+     * @return text key
+     */
+    static IKey lang(@NotNull String key, @Nullable Object... args) {
+        return new LangKey(key, args);
+    }
+
+    /**
+     * Creates a translated text with arguments supplier.
+     *
+     * @param key          translation key
+     * @param argsSupplier translation arguments supplier
+     * @return text key
+     */
+    static IKey lang(@NotNull String key, @NotNull Supplier<Object[]> argsSupplier) {
+        return new LangKey(key, argsSupplier);
+    }
+
+    /**
+     * Creates a translated text.
+     *
+     * @param keySupplier translation key supplier
+     * @return text key
+     */
+    static IKey lang(@NotNull Supplier<String> keySupplier) {
+        return new LangKey(keySupplier);
+    }
+
+    /**
+     * Creates a translated text with arguments supplier.
+     *
+     * @param keySupplier  translation key supplier
+     * @param argsSupplier translation arguments supplier
+     * @return text key
+     */
+    static IKey lang(@NotNull Supplier<String> keySupplier, @NotNull Supplier<Object[]> argsSupplier) {
+        return new LangKey(keySupplier, argsSupplier);
+    }
+
+    /**
+     * Creates a string literal text.
+     *
+     * @param key string
+     * @return text key
+     */
+    static IKey str(@NotNull String key) {
+        return new StringKey(key);
+    }
+
+    /**
+     * Creates a formatted string literal text with arguments. The arguments can be dynamic.
+     * The string is formatted using {@link String#format(String, Object...)}.
+     *
+     * @param key  string
+     * @param args arguments
+     * @return text key
+     */
+    static IKey str(@NotNull String key, @Nullable Object... args) {
+        return new StringKey(key, args);
+    }
+
+    /**
+     * Creates a composed text key.
+     *
+     * @param keys text keys
+     * @return composed text key.
+     */
+    static IKey comp(@NotNull IKey... keys) {
+        return new CompoundKey(keys);
+    }
+
+    /**
+     * Creates a dynamic text key.
+     *
+     * @param supp string supplier
+     * @return dynamic text key
+     */
+    static IKey dynamic(@NotNull Supplier<@NotNull Component> supp) {
+        // DO NOT PULL OUT INTO A LOCAL VAR IT WILL BREAK THE SUPPLIER
+        if (supp.get() instanceof MutableComponent) {
+            return dynamicKey(() -> IKey.lang(supp.get()));
+        } else {
+            return dynamicKey(() -> IKey.lang(supp.get().copy()));
+        }
+    }
+
+    /**
+     * Creates a dynamic text key.
+     *
+     * @param supp key supplier
+     * @return dynamic text key
+     */
+    static IKey dynamicKey(@NotNull Supplier<@NotNull IKey> supp) {
+        return new DynamicKey(supp);
+    }
+
+    /**
+     * @return the current unformatted string
+     */
+    MutableComponent get();
+
+    /**
+     * @param parentFormatting formatting of the parent in case of composite keys
+     * @return the current formatted string
+     */
+    default MutableComponent getFormatted(@Nullable FormattingState parentFormatting) {
+        return get();
+    }
+
+    /**
+     * @return the current formatted string
+     */
+    default MutableComponent getFormatted() {
+        return getFormatted(null);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    default void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        drawAligned(context, x, y, width, height, widgetTheme, Alignment.CENTER);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    default void drawAligned(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme,
+                             Alignment alignment) {
+        renderer.setColor(widgetTheme.getTextColor());
+        renderer.setShadow(widgetTheme.isTextShadow());
+        renderer.setAlignment(alignment, width, height);
+        renderer.setScale(getScale());
+        renderer.setPos(x, y);
+        renderer.draw(context.getGraphics(), getFormatted());
+    }
+
+    @Override
+    default boolean canApplyTheme() {
+        return true;
+    }
+
+    @Override
+    default int getDefaultWidth() {
+        renderer.setAlignment(Alignment.TopLeft, -1, -1);
+        renderer.setScale(getScale());
+        renderer.setPos(0, 0);
+        renderer.setSimulate(true);
+        renderer.draw(null, getFormatted());
+        renderer.setSimulate(false);
+        return (int) renderer.getLastWidth();
+    }
+
+    @Override
+    default int getDefaultHeight() {
+        renderer.setAlignment(Alignment.TopLeft, -1, -1);
+        renderer.setScale(getScale());
+        renderer.setPos(0, 0);
+        renderer.setSimulate(true);
+        renderer.draw(null, getFormatted());
+        renderer.setSimulate(false);
+        return (int) renderer.getLastWidth();
+    }
+
+    default float getScale() {
+        return 1f;
+    }
+
+    @Override
+    default TextWidget<?> asWidget() {
+        return new TextWidget<>(this);
+    }
+
+    default StyledText withStyle() {
+        return new StyledText(this);
+    }
+
+    default AnimatedText withAnimation() {
+        return new AnimatedText(this);
+    }
+
+    /**
+     * @return a formatting state of this key
+     */
+    default @Nullable FormattingState getFormatting() {
+        return null;
+    }
+
+    /**
+     * Set text formatting to this key. If {@link IKey#RESET} is used, then that's applied first and then all other
+     * formatting of this key.
+     * With {@code null}, you can remove a color formatting. No matter the parents color, the default color will be
+     * used.
+     *
+     * @param formatting a formatting rule
+     * @return this
+     */
+    IKey style(@Nullable ChatFormatting formatting);
+
+    default IKey style(ChatFormatting... formatting) {
+        for (ChatFormatting cf : formatting) style(cf);
+        return this;
+    }
+
+    default IKey removeFormatColor() {
+        return style((ChatFormatting) null);
+    }
+
+    IKey removeStyle();
+
+    default StyledText alignment(Alignment alignment) {
+        return withStyle().alignment(alignment);
+    }
+
+    default @NotNull StyledText color(int color) {
+        return color(() -> color);
+    }
+
+    default StyledText color(@Nullable IntSupplier color) {
+        return withStyle().color(color);
+    }
+
+    default StyledText scale(float scale) {
+        return withStyle().scale(scale);
+    }
+
+    default StyledText shadow(@Nullable Boolean shadow) {
+        return withStyle().shadow(shadow);
+    }
+
+    default KeyIcon asTextIcon() {
+        return new KeyIcon(this);
+    }
+
+    @Override
+    default void loadFromJson(JsonObject json) {
+        if (json.has("color") || json.has("shadow") || json.has("align") || json.has("alignment") ||
+                json.has("scale")) {
+            StyledText styledText = this instanceof StyledText styledText1 ? styledText1 : withStyle();
+            if (json.has("color")) {
+                styledText.color(JsonHelper.getInt(json, 0, "color"));
+            }
+            styledText.shadow(JsonHelper.getBoolean(json, false, "shadow"));
+            styledText.alignment(
+                    JsonHelper.deserialize(json, Alignment.class, styledText.alignment(), "align", "alignment"));
+            styledText.scale(JsonHelper.getFloat(json, 1, "scale"));
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IRichTextBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IRichTextBuilder.java
new file mode 100644
index 00000000000..dd60bcfcdf9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/IRichTextBuilder.java
@@ -0,0 +1,400 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+import com.gregtechceu.gtceu.api.mui.drawable.text.Spacer;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.data.lang.LangHandler;
+
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.world.inventory.tooltip.TooltipComponent;
+
+import java.util.function.UnaryOperator;
+import java.util.regex.Pattern;
+
+public interface IRichTextBuilder<T extends IRichTextBuilder<T>> {
+
+    T getThis();
+
+    IRichTextBuilder<?> getRichText();
+
+    /**
+     * Removes all text and style.
+     *
+     * @return this
+     */
+    default T reset() {
+        getRichText().reset();
+        return getThis();
+    }
+
+    /**
+     * Adds a component to the current line
+     *
+     * @param c component to add
+     * @return this
+     */
+    default T add(FormattedText c) {
+        getRichText().add(c);
+        return getThis();
+    }
+
+    /**
+     * Adds a string to the current line
+     *
+     * @param s string to add
+     * @return this
+     */
+    default T add(String s) {
+        getRichText().add(s);
+        return getThis();
+    }
+
+    /**
+     * Adds a drawable to the current line. If the drawable is not a {@link IIcon} it will convert to one with
+     * {@link IDrawable#asIcon()}.
+     * If that icon then has no default height (<=0) then it is set to the default text height (9 pixel). If the width
+     * of the icon is not set, then the width of the widest tooltip line is used.
+     *
+     * @param drawable drawable to add.
+     * @return this
+     */
+    default T add(IDrawable drawable) {
+        getRichText().add(drawable);
+        return getThis();
+    }
+
+    /**
+     * Adds a vanilla {@link TooltipComponent} to the current line.
+     * The tooltip component will always be converted into a {@link IIcon} regardless of what it is and drawn inline
+     * with the other components.
+     * It's recommended to use {@link #addLine(TooltipComponent)} instead if you want to preserve how vanilla handles
+     * this.
+     *
+     * @param tooltipComponent tooltip component to add.
+     * @return this
+     * @see #addLine(TooltipComponent)
+     */
+    default T add(TooltipComponent tooltipComponent) {
+        getRichText().add(tooltipComponent);
+        return getThis();
+    }
+
+    default T addLine(FormattedText formattedText) {
+        getRichText().add(formattedText).newLine();
+        return getThis();
+    }
+
+    default T addLine(String s) {
+        getRichText().add(s).newLine();
+        return getThis();
+    }
+
+    default T addLine(ITextLine line) {
+        getRichText().addLine(line);
+        return getThis();
+    }
+
+    default T addLine(TooltipComponent tooltipComponent) {
+        getRichText().add(tooltipComponent).newLine();
+        return getThis();
+    }
+
+    /**
+     * Adds a drawable to the current line and creates a new line.
+     * Refer to {@link #add(IDrawable)} for additional information.
+     *
+     * @param line drawable to add.
+     * @return this
+     * @see #add(IDrawable)
+     */
+    default T addLine(IDrawable line) {
+        getRichText().add(line).newLine();
+        return getThis();
+    }
+
+    /**
+     * Adds all translated components of a multilang's subkeys and creates a new line for each.
+     * 
+     * @param lang lang key of the multilang to add.
+     * @return this
+     */
+    default T addMultiLine(String lang) {
+        for (MutableComponent text : LangHandler.getMultiLang(lang)) {
+            getRichText().addLine(text);
+        }
+        return getThis();
+    }
+
+    /**
+     * Starts a new line. This is always preferred over {@code "\n"} or {@code IKey.str("\n")}, it reduces computation a
+     * lot and maybe saves a tiny bit of memory.
+     *
+     * @return this
+     */
+    default T newLine() {
+        return add(IKey.LINE_FEED);
+    }
+
+    /**
+     * Adds a space character to the current line. This is rarely useful.
+     *
+     * @return this
+     */
+    default T space() {
+        return add(IKey.SPACE);
+    }
+
+    /**
+     * Adds a line with a given thickness in pixels. This will result in larger text line gap.
+     *
+     * @param pixelSpace thickness in pixel
+     * @return this
+     */
+    default T spaceLine(int pixelSpace) {
+        return addLine(Spacer.of(pixelSpace));
+    }
+
+    /**
+     * Adds a two pixel thick empty line. This will result in larger text line gap.
+     * This is useful for titles.
+     *
+     * @return this
+     */
+    default T spaceLine() {
+        return addLine(Spacer.SPACER_2PX);
+    }
+
+    /**
+     * Adds an empty line which is as tall as a normal text line.
+     *
+     * @return this
+     */
+    default T emptyLine() {
+        return addLine(Spacer.LINE_SPACER);
+    }
+
+    /**
+     * Adds multiple drawables to the current line.
+     * Refer to {@link #add(IDrawable)} for additional information.
+     *
+     * @param drawables drawables to add.
+     * @return this
+     * @see #add(IDrawable)
+     */
+    default T addElements(Iterable<IDrawable> drawables) {
+        for (IDrawable drawable : drawables) {
+            getRichText().add(drawable);
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds each drawable and creates a new line after each.
+     * Refer to {@link #add(IDrawable)} for additional information.
+     *
+     * @param drawables drawables to add.
+     * @return this
+     * @see #add(IDrawable)
+     */
+    default T addDrawableLines(Iterable<IDrawable> drawables) {
+        for (IDrawable drawable : drawables) {
+            getRichText().add(drawable).newLine();
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds each string and creates a new line after each.
+     * Refer to {@link #add(String)} for additional information.
+     *
+     * @param strings strings to add.
+     * @return this
+     * @see #add(IDrawable)
+     */
+    default T addStringLines(Iterable<String> strings) {
+        for (String string : strings) {
+            getRichText().add(string).newLine();
+        }
+        return getThis();
+    }
+
+    /**
+     * Finds the next element which contains the matching regex and put the cursor after it.
+     * If none was found the cursor is at the end.
+     *
+     * @param regex regex to match strings for
+     * @return this
+     */
+    default T moveCursorAfterElement(String regex) {
+        return moveCursorAfterElement(Pattern.compile(regex));
+    }
+
+    /**
+     * Finds the next element which contains the matching regex and put the cursor after it.
+     * If none was found the cursor is at the end.
+     *
+     * @param regex regex to match strings for
+     * @return this
+     */
+    default T moveCursorAfterElement(Pattern regex) {
+        getRichText().moveCursorAfterElement(regex);
+        return getThis();
+    }
+
+    /**
+     * Finds the next element which contains the matching regex and replaces the whole element with the result of the
+     * function.
+     * The cursor is then placed after the new element. If the function returns {@code null}, then the element is
+     * removed.
+     * If no element is found nothing happens and the cursor stays in place.
+     *
+     * @param regex    regex to match strings for
+     * @param function function to modify the found element
+     * @return this
+     */
+    default T replace(String regex, UnaryOperator<IKey> function) {
+        return replace(Pattern.compile(regex), function);
+    }
+
+    /**
+     * Finds the next element which contains the matching regex and replaces the whole element with the result of the
+     * function.
+     * The cursor is then placed after the new element. If the function returns {@code null}, then the element is
+     * removed.
+     * If no element is found nothing happens and the cursor stays in place.
+     *
+     * @param regex    regex to match strings for
+     * @param function function to modify the found element
+     * @return this
+     */
+    default T replace(Pattern regex, UnaryOperator<IKey> function) {
+        getRichText().replace(regex, function);
+        return getThis();
+    }
+
+    /**
+     * Moves the cursor to the very start.
+     *
+     * @return this
+     */
+    default T moveCursorToStart() {
+        getRichText().moveCursorToStart();
+        return getThis();
+    }
+
+    /**
+     * Moves the cursor to the very end (default).
+     *
+     * @return this
+     */
+    default T moveCursorToEnd() {
+        getRichText().moveCursorToEnd();
+        return getThis();
+    }
+
+    /**
+     * Moves the cursor a given number of elements forward. The cursor will be clamped at the end.
+     *
+     * @param by amount to move cursor by
+     * @return this
+     */
+    default T moveCursorForward(int by) {
+        getRichText().moveCursorForward(by);
+        return getThis();
+    }
+
+    /**
+     * Moves the cursor one element forward. The cursor will be clamped at the end.
+     *
+     * @return this
+     */
+    default T moveCursorForward() {
+        return moveCursorForward(1);
+    }
+
+    /**
+     * Moves the cursor a given number of elements backward. The cursor will be clamped at the start.
+     *
+     * @param by amount to move cursor by
+     * @return this
+     */
+    default T moveCursorBackward(int by) {
+        getRichText().moveCursorBackward(by);
+        return getThis();
+    }
+
+    /**
+     * Moves the cursor one element backward. The cursor will be clamped at the start.
+     *
+     * @return this
+     */
+    default T moveCursorBackward() {
+        return moveCursorBackward(1);
+    }
+
+    /**
+     * This finds the next element ending with a line break and moves the cursor after it. Note that if the line break
+     * is somewhere in the middle of the element, that element will be ignored.
+     *
+     * @return this
+     */
+    default T moveCursorToNextLine() {
+        getRichText().moveCursorToNextLine();
+        return getThis();
+    }
+
+    /**
+     * When the cursor is locked it will no longer move automatically when elements are added, but it can still be moved
+     * manually with the move methods from above.
+     *
+     * @return this
+     * @see #unlockCursor()
+     */
+    default T lockCursor() {
+        getRichText().lockCursor();
+        return getThis();
+    }
+
+    /**
+     * When the cursor is locked it will no longer move automatically when elements are added, but it can still be moved
+     * manually with the move methods from above.
+     *
+     * @return this
+     * @see #lockCursor() ()
+     */
+    default T unlockCursor() {
+        getRichText().unlockCursor();
+        return getThis();
+    }
+
+    /**
+     * Removes all text.
+     *
+     * @return this
+     */
+
+    default T clearText() {
+        getRichText().clearText();
+        return getThis();
+    }
+
+    default T alignment(Alignment alignment) {
+        getRichText().alignment(alignment);
+        return getThis();
+    }
+
+    default T textColor(int color) {
+        getRichText().textColor(color);
+        return getThis();
+    }
+
+    default T scale(float scale) {
+        getRichText().scale(scale);
+        return getThis();
+    }
+
+    default T textShadow(boolean shadow) {
+        getRichText().textShadow(shadow);
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/ITextLine.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/ITextLine.java
new file mode 100644
index 00000000000..40d3e68b683
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/drawable/ITextLine.java
@@ -0,0 +1,17 @@
+package com.gregtechceu.gtceu.api.mui.base.drawable;
+
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+
+public interface ITextLine {
+
+    int getWidth();
+
+    int getHeight(Font font);
+
+    void draw(GuiContext context, Font font, float x, float y, int color, boolean shadow,
+              int availableWidth, int availableHeight);
+
+    Object getHoveringElement(Font font, int x, int y);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/gui.json b/src/main/java/com/gregtechceu/gtceu/api/mui/base/gui.json
new file mode 100644
index 00000000000..1e2c6b1ae07
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/gui.json
@@ -0,0 +1,9 @@
+{
+  "name": "test",
+  "gui": [
+    {
+      "widget": "image",
+      "min": 50
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/ILayoutWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/ILayoutWidget.java
new file mode 100644
index 00000000000..21e57899ecd
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/ILayoutWidget.java
@@ -0,0 +1,55 @@
+package com.gregtechceu.gtceu.api.mui.base.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.widget.INotifyEnabled;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+/**
+ * This is responsible for laying out widgets. This method responsible for laying out its children
+ * in itself. This includes calling {@link IResizeable#setSizeResized(boolean, boolean)} or one of its variants after a
+ * size with
+ * {@link com.gregtechceu.gtceu.api.mui.widget.sizer.Area#setSize(GuiAxis, int)} or one of its variants on each child.
+ * The same goes for
+ * position. If this widget also applies margin and padding (this is usually the case), then
+ * {@link IResizeable#setMarginPaddingApplied(boolean)}
+ * or one of its variants needs to be called to.
+ */
+public interface ILayoutWidget extends INotifyEnabled {
+
+    /**
+     * Called after the children tried to calculate their size.
+     * Might be called multiple times.
+     *
+     * @return true if the layout was successful and no further iteration is needed.
+     */
+    boolean layoutWidgets();
+
+    /**
+     * Called after post calculation of this widget. The last call guarantees, that this widget is fully calculated.
+     *
+     * @return true if the layout was successful and no further iteration is needed
+     */
+    default boolean postLayoutWidgets() {
+        return true;
+    }
+
+    default boolean canCoverByDefaultSize(GuiAxis axis) {
+        return false;
+    }
+
+    /**
+     * Called when determining wrapping size of this widget.
+     * If this method returns true, size and margin of the queried child will be ignored for calculation.
+     * Typically return true when the child is disabled and you want to collapse it for layout.
+     * This method should also be used for layouting children with {@link #layoutWidgets} if it might return true.
+     */
+    default boolean shouldIgnoreChildSize(IWidget child) {
+        return false;
+    }
+
+    @Override
+    default void onChildChangeEnabled(IWidget child, boolean enabled) {
+        layoutWidgets();
+        postLayoutWidgets();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IResizeParent.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IResizeParent.java
new file mode 100644
index 00000000000..df16e1125cb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IResizeParent.java
@@ -0,0 +1,75 @@
+package com.gregtechceu.gtceu.api.mui.base.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+
+public interface IResizeParent {
+
+    /**
+     * @return area of the element
+     */
+    Area getArea();
+
+    /**
+     * @return true if the relative x position is calculated
+     */
+    boolean isXCalculated();
+
+    /**
+     * @return true if the relative y position is calculated
+     */
+    boolean isYCalculated();
+
+    /**
+     * @return true if the width is calculated
+     */
+    boolean isWidthCalculated();
+
+    /**
+     * @return true if the height is calculated
+     */
+    boolean isHeightCalculated();
+
+    boolean areChildrenCalculated();
+
+    boolean isLayoutDone();
+
+    boolean canRelayout(boolean isParentLayout);
+
+    default boolean isSizeCalculated(GuiAxis axis) {
+        return axis.isHorizontal() ? isWidthCalculated() : isHeightCalculated();
+    }
+
+    default boolean isPosCalculated(GuiAxis axis) {
+        return axis.isHorizontal() ? isXCalculated() : isYCalculated();
+    }
+
+    /**
+     * @return true if the relative position and size are fully calculated
+     */
+    default boolean isSelfFullyCalculated(boolean isParentLayout) {
+        return isSelfFullyCalculated() && !canRelayout(isParentLayout);
+    }
+
+    default boolean isSelfFullyCalculated() {
+        return isXCalculated() && isYCalculated() && isWidthCalculated() && isHeightCalculated();
+    }
+
+    default boolean isFullyCalculated() {
+        return isSelfFullyCalculated() && areChildrenCalculated() && isLayoutDone();
+    }
+
+    default boolean isFullyCalculated(boolean isParentLayout) {
+        return isFullyCalculated() && !canRelayout(isParentLayout);
+    }
+
+    /**
+     * @return true if margin and padding are applied on the x-axis
+     */
+    boolean isXMarginPaddingApplied();
+
+    /**
+     * @return true if margin and padding are applied on the y-axis
+     */
+    boolean isYMarginPaddingApplied();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IResizeable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IResizeable.java
new file mode 100644
index 00000000000..3c6a76c76a3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IResizeable.java
@@ -0,0 +1,140 @@
+package com.gregtechceu.gtceu.api.mui.base.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+/**
+ * An interface that handles resizing of widgets.
+ * Usually this interface is not implemented by the users of this library or will even interact with it.
+ */
+public interface IResizeable extends IResizeParent {
+
+    /**
+     * Called once before resizing
+     */
+    void initResizing(boolean onOpen);
+
+    /**
+     * Resizes the given element
+     *
+     * @param isParentLayout if the parent is a layout widget
+     * @return true if element is fully resized
+     */
+    boolean resize(boolean isParentLayout);
+
+    /**
+     * Called if {@link #resize(boolean)} returned false after children have been resized.
+     *
+     * @return if element is fully resized
+     */
+    boolean postResize();
+
+    /**
+     * Called after all elements in the tree are resized and the absolute positions needs to be calculated from the
+     * relative position.
+     */
+    default void preApplyPos() {}
+
+    /**
+     * This converts the relative pos to resizer parent to relative pos to widget parent.
+     */
+    default void applyPos() {}
+
+    void setChildrenResized(boolean resized);
+
+    void setLayoutDone(boolean done);
+
+    default void setAxisResized(GuiAxis axis, boolean pos, boolean size) {
+        if (axis.isHorizontal()) {
+            setXAxisResized(pos, size);
+        } else {
+            setYAxisResized(pos, size);
+        }
+    }
+
+    void setXAxisResized(boolean pos, boolean size);
+
+    void setYAxisResized(boolean pos, boolean size);
+
+    /**
+     * Marks position and size as calculated.
+     */
+    default void setResized(boolean x, boolean y, boolean w, boolean h) {
+        setXAxisResized(x, w);
+        setYAxisResized(y, h);
+    }
+
+    default void setPosResized(boolean x, boolean y) {
+        setResized(x, y, isWidthCalculated(), isHeightCalculated());
+    }
+
+    default void setSizeResized(boolean w, boolean h) {
+        setResized(isXCalculated(), isYCalculated(), w, h);
+    }
+
+    default void setXResized(boolean v) {
+        setXAxisResized(v, isWidthCalculated());
+    }
+
+    default void setYResized(boolean v) {
+        setYAxisResized(v, isHeightCalculated());
+    }
+
+    default void setPosResized(GuiAxis axis, boolean v) {
+        if (axis.isHorizontal()) {
+            setXResized(v);
+        } else {
+            setYResized(v);
+        }
+    }
+
+    default void setWidthResized(boolean v) {
+        setXAxisResized(isXCalculated(), v);
+    }
+
+    default void setHeightResized(boolean v) {
+        setYAxisResized(isYCalculated(), v);
+    }
+
+    default void setSizeResized(GuiAxis axis, boolean v) {
+        if (axis.isHorizontal()) {
+            setWidthResized(v);
+        } else {
+            setHeightResized(v);
+        }
+    }
+
+    default void setResized(boolean b) {
+        setResized(b, b, b, b);
+    }
+
+    default void updateResized() {
+        setResized(isXCalculated(), isYCalculated(), isWidthCalculated(), isHeightCalculated());
+    }
+
+    /**
+     * Sets if margin and padding on the x-axis is applied
+     *
+     * @param b true if margin and padding are applied
+     */
+    void setXMarginPaddingApplied(boolean b);
+
+    /**
+     * Sets if margin and padding on the y-axis is applied
+     *
+     * @param b true if margin and padding are applied
+     */
+    void setYMarginPaddingApplied(boolean b);
+
+    default void setMarginPaddingApplied(boolean b) {
+        setXMarginPaddingApplied(b);
+        setYMarginPaddingApplied(b);
+    }
+
+    default void setMarginPaddingApplied(GuiAxis axis, boolean b) {
+        if (axis.isHorizontal()) {
+            setXMarginPaddingApplied(b);
+        } else {
+            setYMarginPaddingApplied(b);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IViewport.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IViewport.java
new file mode 100644
index 00000000000..335c229cf01
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IViewport.java
@@ -0,0 +1,130 @@
+package com.gregtechceu.gtceu.api.mui.base.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.HoveredWidgetList;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import java.util.function.Predicate;
+
+/**
+ * A gui element which can transform its children f.e. a scrollable list.
+ */
+public interface IViewport extends IWidget {
+
+    /**
+     * Apply shifts of this viewport.
+     *
+     * @param stack viewport stack
+     */
+    default void transformChildren(IViewportStack stack) {}
+
+    /**
+     * Gathers all children at a position. Transformations from this viewport are already applied.
+     *
+     * @param stack   current viewport stack. Should not be modified.
+     * @param widgets widget list of already gathered widgets. Add children here.
+     * @param x       x position
+     * @param y       y position
+     */
+    default void getWidgetsAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        if (hasChildren()) {
+            getChildrenAt(this, stack, widgets, x, y);
+        }
+    }
+
+    /**
+     * Gathers all children at a position. Transformations from this viewport are not applied.
+     * Called before {@link #getWidgetsAt(IViewportStack, HoveredWidgetList, int, int)}
+     *
+     * @param stack   current viewport stack. Should not be modified.
+     * @param widgets widget list of already gathered widgets. Add children here.
+     * @param x       x position
+     * @param y       y position
+     */
+    default void getSelfAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        if (isInside(stack, x, y)) {
+            widgets.add(this, stack, getAdditionalHoverInfo(stack, x, y));
+        }
+    }
+
+    /**
+     * Called during drawing twice (before children are drawn). Once with transformation of this viewport and once
+     * without
+     *
+     * @param context     gui context
+     * @param transformed if transformation from this viewport is active
+     */
+    default void preDraw(ModularGuiContext context, boolean transformed) {}
+
+    /**
+     * Called during drawing twice (after children are drawn). Once with transformation of this viewport and once
+     * without
+     *
+     * @param context     gui context
+     * @param transformed if transformation from this viewport is active
+     */
+    default void postDraw(ModularGuiContext context, boolean transformed) {}
+
+    static void getChildrenAt(IWidget parent, IViewportStack stack, HoveredWidgetList widgetList, int x, int y) {
+        for (IWidget child : parent.getChildren()) {
+            if (!child.isEnabled()) {
+                continue;
+            }
+            if (child instanceof IViewport viewport) {
+                stack.pushViewport(viewport, parent.getArea());
+                child.transform(stack);
+                viewport.getSelfAt(stack, widgetList, x, y);
+                viewport.transformChildren(stack);
+                viewport.getWidgetsAt(stack, widgetList, x, y);
+                stack.popViewport(viewport);
+            } else {
+                stack.pushMatrix();
+                child.transform(stack);
+                if (child.isInside(stack, x, y)) {
+                    widgetList.add(child, stack, child.getAdditionalHoverInfo(stack, x, y));
+                }
+                if (child.hasChildren()) {
+                    getChildrenAt(child, stack, widgetList, x, y);
+                }
+                stack.popMatrix();
+            }
+        }
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    static boolean forEachChild(IViewportStack stack, IWidget parent, Predicate<IWidget> predicate, int context) {
+        for (IWidget child : parent.getChildren()) {
+            if (!child.isEnabled()) {
+                continue;
+            }
+            stack.popMatrix();
+            if (child instanceof IViewport viewport) {
+                stack.pushViewport(viewport, parent.getArea());
+                parent.transform(stack);
+                if (!predicate.test(child)) {
+                    stack.popViewport(viewport);
+                    return false;
+                }
+                viewport.transformChildren(parent.getContext());
+                if (child.hasChildren() && !forEachChild(stack, child, predicate, context)) {
+                    stack.popViewport(viewport);
+                    return false;
+                }
+                stack.popViewport(viewport);
+            } else {
+                stack.pushMatrix();
+                parent.transform(stack);
+                if (!predicate.test(child)) {
+                    stack.popMatrix();
+                    return false;
+                }
+                if (child.hasChildren() && !forEachChild(stack, child, predicate, context)) {
+                    stack.popMatrix();
+                    return false;
+                }
+                stack.popMatrix();
+            }
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IViewportStack.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IViewportStack.java
new file mode 100644
index 00000000000..0f95085bba2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/layout/IViewportStack.java
@@ -0,0 +1,217 @@
+package com.gregtechceu.gtceu.api.mui.base.layout;
+
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.TransformationMatrix;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+/**
+ * This handles all viewports in a GUI. Also keeps track of a matrix stack used for rendering and
+ * user interaction.
+ */
+@ApiStatus.NonExtendable
+public interface IViewportStack {
+
+    /**
+     * Reset all viewports and the matrix stack.
+     */
+    void reset();
+
+    /**
+     * @return current viewport
+     */
+    Area getViewport();
+
+    /**
+     * Pushes a viewport to the top. Also pushes a new matrix.
+     *
+     * @param viewport viewport to push
+     * @param area     area of the viewport
+     */
+    void pushViewport(IViewport viewport, Area area);
+
+    /**
+     * Only pushes a matrix without a viewport.
+     */
+    void pushMatrix();
+
+    /**
+     * Removes the top viewport and its matrix from the stack.
+     *
+     * @param viewport viewport to remove from the top.
+     * @throws IllegalStateException if the given viewport doesn't match the viewport at the top.
+     */
+    void popViewport(IViewport viewport);
+
+    /**
+     * Removes the top matrix from the stack.
+     *
+     * @throws IllegalStateException if the top matrix is a viewport.
+     */
+    void popMatrix();
+
+    /**
+     * @return the matrix stack size
+     */
+    int getStackSize();
+
+    /**
+     * Removes all matrices ABOVE the given index.
+     *
+     * @param index matrices are removed above this index.
+     */
+    void popUntilIndex(int index);
+
+    /**
+     * Removes all matrices ABOVE the given viewport.
+     *
+     * @param viewport matrices are removed above this viewport.
+     */
+    void popUntilViewport(IViewport viewport);
+
+    /**
+     * Applies translation transformation to the current top matrix.
+     *
+     * @param x translation in x
+     * @param y translation in y
+     */
+    void translate(float x, float y);
+
+    /**
+     * Applies translation transformation to the current top matrix.
+     *
+     * @param x translation in x
+     * @param y translation in y
+     * @param z translation in z
+     */
+    void translate(float x, float y, float z);
+
+    /**
+     * Applies rotation transformation to the current top matrix.
+     *
+     * @param angle clockwise rotation angle in radians
+     * @param x     x-axis rotation. 1 for yes, 0 for no
+     * @param y     y-axis rotation. 1 for yes, 0 for no
+     * @param z     z-axis rotation. 1 for yes, 0 for no
+     */
+    void rotate(float angle, float x, float y, float z);
+
+    /**
+     * Applies rotation transformation to the current top matrix around z.
+     *
+     * @param angle clockwise rotation angle in radians
+     */
+    void rotateZ(float angle);
+
+    /**
+     * Applies scaling transformation to the current top matrix around.
+     *
+     * @param x x scale factor
+     * @param y y scale factor
+     */
+    void scale(float x, float y);
+
+    /**
+     * Multiplies current matrix transformation by another matrix
+     *
+     * @param matrix the matrix to multiply with
+     */
+    void multiply(Matrix4f matrix);
+
+    /**
+     * Resets the top matrix to the matrix below.
+     */
+    void resetCurrent();
+
+    /**
+     * Transforms the x component of a position with the current matrix transformations.
+     *
+     * @param x x component of position
+     * @param y y component of position
+     * @return transformed x component
+     */
+    int transformX(float x, float y);
+
+    /**
+     * Transforms the y component of a position with the current matrix transformations.
+     *
+     * @param x x component of position
+     * @param y y component of position
+     * @return transformed y component
+     */
+    int transformY(float x, float y);
+
+    /**
+     * Transforms the x component of a position with the current inverted matrix transformations.
+     *
+     * @param x x component of position
+     * @param y y component of position
+     * @return un-transformed x component
+     */
+    int unTransformX(float x, float y);
+
+    /**
+     * Transforms the y component of a position with the current inverted matrix transformations.
+     *
+     * @param x x component of position
+     * @param y y component of position
+     * @return un-transformed y component
+     */
+    int unTransformY(float x, float y);
+
+    /**
+     * Transforms a vector with the current matrix transformations.
+     * This modifies the given vector.
+     *
+     * @param vec vector to transform
+     * @return transformed vector
+     */
+    default Vector3f transform(Vector3f vec) {
+        return transform(vec, vec);
+    }
+
+    /**
+     * Transforms a vector with the current matrix transformations.
+     *
+     * @param vec  vector to transform
+     * @param dest vector to write the result to
+     * @return transformed vector
+     */
+    Vector3f transform(Vector3f vec, Vector3f dest);
+
+    /**
+     * Transforms a vector with the current inverted matrix transformations.
+     * This modifies the given vector.
+     *
+     * @param vec vector to un-transform
+     * @return un-transformed vector
+     */
+    default Vector3f unTransform(Vector3f vec) {
+        return unTransform(vec, vec);
+    }
+
+    /**
+     * Transforms a vector with the current inverted matrix transformations.
+     * This modifies the given vector.
+     *
+     * @param vec  vector to un-transform
+     * @param dest vector to write the result to
+     * @return un-transformed vector
+     */
+    Vector3f unTransform(Vector3f vec, Vector3f dest);
+
+    /**
+     * Applies the current matrix transformations the current OpenGL matrix.
+     */
+    void applyTo(PoseStack poseStack);
+
+    /**
+     * @return the top matrix or null if stack is empty
+     */
+    @Nullable
+    TransformationMatrix peek();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IBoolValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IBoolValue.java
new file mode 100644
index 00000000000..df57a91e30d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IBoolValue.java
@@ -0,0 +1,18 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IBoolValue<T> extends IValue<T>, IIntValue<T> {
+
+    boolean getBoolValue();
+
+    void setBoolValue(boolean val);
+
+    @Override
+    default int getIntValue() {
+        return getBoolValue() ? 1 : 0;
+    }
+
+    @Override
+    default void setIntValue(int val) {
+        setBoolValue(val == 1);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IByteValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IByteValue.java
new file mode 100644
index 00000000000..89be4e97256
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IByteValue.java
@@ -0,0 +1,28 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IByteValue<T> extends IIntValue<T>, IStringValue<T> {
+
+    @Override
+    default void setIntValue(int val) {
+        setByteValue((byte) val);
+    }
+
+    @Override
+    default void setStringValue(String val) {
+        setByteValue(Byte.parseByte(val));
+    }
+
+    @Override
+    default int getIntValue() {
+        return getByteValue();
+    }
+
+    @Override
+    default String getStringValue() {
+        return String.valueOf(getByteValue());
+    }
+
+    void setByteValue(byte b);
+
+    byte getByteValue();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IDoubleValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IDoubleValue.java
new file mode 100644
index 00000000000..0e50cbb29e8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IDoubleValue.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IDoubleValue<T> extends IValue<T> {
+
+    double getDoubleValue();
+
+    void setDoubleValue(double val);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IEnumValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IEnumValue.java
new file mode 100644
index 00000000000..3d4d2092b28
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IEnumValue.java
@@ -0,0 +1,6 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IEnumValue<T extends Enum<T>> extends IValue<T> {
+
+    Class<T> getEnumClass();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IFloatValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IFloatValue.java
new file mode 100644
index 00000000000..91df2287614
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IFloatValue.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IFloatValue<T> extends IValue<T> {
+
+    float getFloatValue();
+
+    void setFloatValue(float val);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IIntValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IIntValue.java
new file mode 100644
index 00000000000..c61b4fe51a4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IIntValue.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IIntValue<T> extends IValue<T> {
+
+    int getIntValue();
+
+    void setIntValue(int val);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/ILongValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/ILongValue.java
new file mode 100644
index 00000000000..fe271ae8e4c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/ILongValue.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface ILongValue<T> extends IValue<T> {
+
+    long getLongValue();
+
+    void setLongValue(long val);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IStringValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IStringValue.java
new file mode 100644
index 00000000000..c6983326c70
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IStringValue.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+public interface IStringValue<T> extends IValue<T> {
+
+    String getStringValue();
+
+    void setStringValue(String val);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/ISyncOrValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/ISyncOrValue.java
new file mode 100644
index 00000000000..9ab9466ac16
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/ISyncOrValue.java
@@ -0,0 +1,126 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * An interface that is implemented on {@link IValue} and {@link com.gregtechceu.gtceu.api.mui.value.sync.SyncHandler
+ * SyncHandler} for easier
+ * validation and setters.
+ */
+@ApiStatus.NonExtendable
+public interface ISyncOrValue {
+
+    /**
+     * A sync handler or value representing null.
+     */
+    ISyncOrValue EMPTY = new ISyncOrValue() {
+
+        @Override
+        public <T> @Nullable T castNullable(Class<T> type) {
+            return null;
+        }
+
+        @Override
+        public boolean isTypeOrEmpty(Class<?> type) {
+            return true;
+        }
+    };
+
+    /**
+     * Returns the given sync handler or value or {@link #EMPTY} if null.
+     *
+     * @param syncOrValue sync handler or value
+     * @return a non-null representation of the given sync handler or value
+     */
+    @NotNull
+    static ISyncOrValue orEmpty(@Nullable ISyncOrValue syncOrValue) {
+        return syncOrValue != null ? syncOrValue : EMPTY;
+    }
+
+    /**
+     * Returns if this sync handler or value is an instance of the given type or if this represents null. This is
+     * useful, when the value or
+     * sync handler can be null in the widget.
+     *
+     * @param type type to check for
+     * @return if this sync handler or value is an instance of the type or empty
+     */
+    default boolean isTypeOrEmpty(Class<?> type) {
+        return type.isAssignableFrom(getClass());
+    }
+
+    /**
+     * Casts this sync handler or value to the given type or null if this isn't a subtype of the given type.
+     *
+     * @param type type to cast this sync handle or value to
+     * @param <T>  type to cast to
+     * @return this cast sync handler or value
+     */
+    @Nullable
+    @SuppressWarnings("unchecked")
+    default <T> T castNullable(Class<T> type) {
+        return type.isAssignableFrom(getClass()) ? (T) this : null;
+    }
+
+    /**
+     * Casts this sync handler or value to a {@link IValue IValue&lt;V&gt;} if it is a value handler and the containing
+     * value is of type
+     * {@link V} else null.
+     *
+     * @param valueType expected type of the containing value
+     * @param <V>       expected type of the containing value
+     * @return a {@link IValue IValue&lt;V&gt;} if types match or null
+     */
+    @Nullable
+    default <V> IValue<V> castValueNullable(Class<V> valueType) {
+        return null;
+    }
+
+    /**
+     * Casts this sync handler or value to the given type or throws an exception if this isn't a subtype of the given
+     * type.
+     *
+     * @param type type to cast this sync handle or value to
+     * @param <T>  type to cast to
+     * @return this cast sync handler or value
+     * @throws IllegalStateException if this is not a subtype of the given type
+     */
+    default <T> T castOrThrow(Class<T> type) {
+        T t = castNullable(type);
+        if (t == null) {
+            if (!isSyncHandler() && !isValueHandler()) {
+                throw new IllegalStateException("Empty sync handler or value can't be used for anything.");
+            }
+            String self = isSyncHandler() ? "sync handler" : "value";
+            throw new IllegalStateException("Can't cast " + self + " of type '" + getClass().getSimpleName() +
+                    "' to type '" + type.getSimpleName() + "'.");
+        }
+        return t;
+    }
+
+    /**
+     * Returns if the containing value of this is of the given type. If this is not a value it will always return false.
+     *
+     * @param type expected value type
+     * @return if the containing value of this is of the given type
+     */
+    default boolean isValueOfType(Class<?> type) {
+        return false;
+    }
+
+    /**
+     * @return if this is a sync handler (false if this represents null)
+     */
+    default boolean isSyncHandler() {
+        return false;
+    }
+
+    /**
+     * @return if this is a value handler (false if this represents null)
+     */
+    default boolean isValueHandler() {
+        return false;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IValue.java
new file mode 100644
index 00000000000..2e3e0f9fe77
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/IValue.java
@@ -0,0 +1,40 @@
+package com.gregtechceu.gtceu.api.mui.base.value;
+
+/**
+ * A value wrapper for widgets.
+ *
+ * @param <T> value type
+ */
+public interface IValue<T> extends ISyncOrValue {
+
+    /**
+     * Gets the current value.
+     *
+     * @return the current value
+     */
+    T getValue();
+
+    /**
+     * Updates the current value.
+     *
+     * @param value new value
+     */
+    void setValue(T value);
+
+    Class<T> getValueType();
+
+    default boolean isValueOfType(Class<?> type) {
+        return type.isAssignableFrom(getValueType());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    default <V> IValue<V> castValueNullable(Class<V> valueType) {
+        return isValueOfType(valueType) ? (IValue<V>) this : null;
+    }
+
+    @Override
+    default boolean isValueHandler() {
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IBoolSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IBoolSyncValue.java
new file mode 100644
index 00000000000..a043de7df29
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IBoolSyncValue.java
@@ -0,0 +1,37 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IBoolValue;
+
+/**
+ * A helper interface for sync values which can be turned into an integer.
+ *
+ * @param <T> value type
+ */
+public interface IBoolSyncValue<T> extends IValueSyncHandler<T>, IBoolValue<T>, IIntSyncValue<T> {
+
+    @Override
+    default void setBoolValue(boolean val) {
+        setBoolValue(val, true, true);
+    }
+
+    default void setBoolValue(boolean val, boolean setSource) {
+        setBoolValue(val, setSource, true);
+    }
+
+    void setBoolValue(boolean value, boolean setSource, boolean sync);
+
+    @Override
+    default void setIntValue(int value, boolean setSource, boolean sync) {
+        setBoolValue(value == 1, setSource, sync);
+    }
+
+    @Override
+    default int getIntValue() {
+        return IBoolValue.super.getIntValue();
+    }
+
+    @Override
+    default void setIntValue(int val) {
+        IBoolValue.super.setIntValue(val);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IByteSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IByteSyncValue.java
new file mode 100644
index 00000000000..c47b3e2da37
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IByteSyncValue.java
@@ -0,0 +1,17 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IByteValue;
+
+public interface IByteSyncValue<T> extends IByteValue<T>, IValueSyncHandler<T> {
+
+    @Override
+    default void setByteValue(byte val) {
+        setByteValue(val, true);
+    }
+
+    default void setByteValue(byte val, boolean setSource) {
+        setByteValue(val, setSource, true);
+    }
+
+    void setByteValue(byte value, boolean setSource, boolean sync);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IDoubleSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IDoubleSyncValue.java
new file mode 100644
index 00000000000..b1c9aa10f0e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IDoubleSyncValue.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IDoubleValue;
+
+/**
+ * A helper interface for sync values which can be turned into an integer.
+ *
+ * @param <T> value type
+ */
+public interface IDoubleSyncValue<T> extends IValueSyncHandler<T>, IDoubleValue<T> {
+
+    @Override
+    default void setDoubleValue(double val) {
+        setDoubleValue(val, true, true);
+    }
+
+    default void setDoubleValue(double val, boolean setSource) {
+        setDoubleValue(val, setSource, true);
+    }
+
+    void setDoubleValue(double value, boolean setSource, boolean sync);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IFloatSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IFloatSyncValue.java
new file mode 100644
index 00000000000..cfa3353e30c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IFloatSyncValue.java
@@ -0,0 +1,17 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IFloatValue;
+
+public interface IFloatSyncValue<T> extends IValueSyncHandler<T>, IFloatValue<T> {
+
+    @Override
+    default void setFloatValue(float val) {
+        setFloatValue(val, true, true);
+    }
+
+    default void setFloatValue(float val, boolean setSource) {
+        setFloatValue(val, setSource, true);
+    }
+
+    void setFloatValue(float value, boolean setSource, boolean sync);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IIntSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IIntSyncValue.java
new file mode 100644
index 00000000000..630bd244375
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IIntSyncValue.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+
+/**
+ * A helper interface for sync values which can be turned into an integer.
+ *
+ * @param <T> value type
+ */
+public interface IIntSyncValue<T> extends IValueSyncHandler<T>, IIntValue<T> {
+
+    @Override
+    default void setIntValue(int val) {
+        setIntValue(val, true, true);
+    }
+
+    default void setIntValue(int val, boolean setSource) {
+        setIntValue(val, setSource, true);
+    }
+
+    void setIntValue(int value, boolean setSource, boolean sync);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/ILongSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/ILongSyncValue.java
new file mode 100644
index 00000000000..5259e61ba0a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/ILongSyncValue.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.ILongValue;
+
+/**
+ * A helper interface for sync values which can be turned into an integer.
+ *
+ * @param <T> value type
+ */
+public interface ILongSyncValue<T> extends IValueSyncHandler<T>, ILongValue<T> {
+
+    @Override
+    default void setLongValue(long val) {
+        setLongValue(val, true, true);
+    }
+
+    default void setLongValue(long val, boolean setSource) {
+        setLongValue(val, setSource, true);
+    }
+
+    void setLongValue(long value, boolean setSource, boolean sync);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IServerKeyboardAction.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IServerKeyboardAction.java
new file mode 100644
index 00000000000..412770b744a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IServerKeyboardAction.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.utils.KeyboardData;
+
+public interface IServerKeyboardAction {
+
+    void onServerKeyboardAction(KeyboardData data);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IServerMouseAction.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IServerMouseAction.java
new file mode 100644
index 00000000000..bc9e0bcca2e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IServerMouseAction.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+
+public interface IServerMouseAction {
+
+    void onServerMouseAction(MouseData mouseData);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IStringSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IStringSyncValue.java
new file mode 100644
index 00000000000..1a73864b374
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IStringSyncValue.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+
+/**
+ * A helper interface for sync values which can be turned into a string.
+ *
+ * @param <T> value type
+ */
+public interface IStringSyncValue<T> extends IValueSyncHandler<T>, IStringValue<T> {
+
+    @Override
+    default void setStringValue(String val) {
+        setStringValue(val, true, true);
+    }
+
+    default void setStringValue(String val, boolean setSource) {
+        setStringValue(val, setSource, true);
+    }
+
+    void setStringValue(String value, boolean setSource, boolean sync);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IValueSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IValueSyncHandler.java
new file mode 100644
index 00000000000..c7398c27aeb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/value/sync/IValueSyncHandler.java
@@ -0,0 +1,76 @@
+package com.gregtechceu.gtceu.api.mui.base.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+/**
+ * A helper interface for syncing an object value.
+ *
+ * @param <T> object value type
+ */
+public interface IValueSyncHandler<T> extends IValue<T> {
+
+    /**
+     * Updates the current value and the source and syncs it to client/server.
+     *
+     * @param value new value
+     */
+    @Override
+    default void setValue(T value) {
+        setValue(value, true, true);
+    }
+
+    /**
+     * Updates the current value and syncs it to client/server.
+     *
+     * @param value     new value
+     * @param setSource whether the source should be updated with the new value
+     */
+    default void setValue(T value, boolean setSource) {
+        setValue(value, setSource, true);
+    }
+
+    /**
+     * Updates the current value.
+     *
+     * @param value     new value
+     * @param setSource whether the source should be updated with the new value
+     * @param sync      whether the new value should be synced to client/server
+     */
+    void setValue(T value, boolean setSource, boolean sync);
+
+    /**
+     * Determines if the current value is different from source and updates the current value if it is.
+     *
+     * @param isFirstSync true if it's the first tick in the ui
+     * @return true if the current value was different from source
+     */
+    boolean updateCacheFromSource(boolean isFirstSync);
+
+    /**
+     * Updates the cache from source and syncs it to the other sides.
+     * <p>
+     * Usually this is
+     * <code>
+     * setValue(getter.get(), false, true);
+     * </code>
+     * </p>
+     * Where {@code getter} is the source.
+     */
+    void notifyUpdate();
+
+    /**
+     * Writes the current value to the buffer
+     *
+     * @param buffer buffer to write to
+     */
+    void write(FriendlyByteBuf buffer);
+
+    /**
+     * Reads a value from the buffer and sets the current value
+     *
+     * @param buffer buffer to read from
+     */
+    void read(FriendlyByteBuf buffer);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDelegatingWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDelegatingWidget.java
new file mode 100644
index 00000000000..2e7713861c2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDelegatingWidget.java
@@ -0,0 +1,18 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import net.minecraft.world.inventory.Slot;
+
+public interface IDelegatingWidget extends IWidget, IVanillaSlot {
+
+    IWidget getDelegate();
+
+    @Override
+    default Slot getVanillaSlot() {
+        return getDelegate() instanceof IVanillaSlot vanillaSlot ? vanillaSlot.getVanillaSlot() : null;
+    }
+
+    @Override
+    default boolean handleAsVanillaSlot() {
+        return getDelegate() instanceof IVanillaSlot vanillaSlot && vanillaSlot.handleAsVanillaSlot();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDragResizeable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDragResizeable.java
new file mode 100644
index 00000000000..aea715db3fe
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDragResizeable.java
@@ -0,0 +1,119 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+/**
+ * Implement this interface on a {@link IWidget} to allow it being resized by dragging the edges similar to windows.
+ */
+public interface IDragResizeable {
+
+    /**
+     * @return if this widget can currently be resized by dragging an edge
+     */
+    default boolean isCurrentlyResizable() {
+        return true;
+    }
+
+    /**
+     * @return if the center position of this widget should be retained, by also resizing the opposite edge
+     */
+    default boolean keepPosOnDragResize() {
+        return true;
+    }
+
+    /**
+     * Called every time the mouse moves one or more pixels while this widget is resized by dragging an edge.
+     */
+    default void onDragResize() {
+        ((IWidget) this).scheduleResize();
+    }
+
+    /**
+     * @return The border size in which to allow drag resizing in pixels.
+     */
+    default int getDragAreaSize() {
+        return 3;
+    }
+
+    /**
+     * @return The minimum width this widget can be dragged to.
+     */
+    default int getMinDragWidth() {
+        return 18;
+    }
+
+    /**
+     * @return The minimum height this widget can be dragged to.
+     */
+    default int getMinDragHeight() {
+        return 18;
+    }
+
+    /**
+     * An internal method to detect if the mouse is currently hovering an area where a drag resize can be started.
+     */
+    static ResizeDragArea getDragResizeCorner(IDragResizeable widget, Area area, IViewportStack stack, int x, int y) {
+        if (!widget.isCurrentlyResizable()) return null;
+
+        int mx = stack.unTransformX(x, y);
+        int my = stack.unTransformY(x, y);
+
+        if (mx < 0 || my < 0 || mx > area.w() || my > area.h()) return null;
+
+        int ras = widget.getDragAreaSize();
+        if (mx < ras) {
+            if (my < ras) return ResizeDragArea.TOP_LEFT;
+            if (my > area.h() - ras) return ResizeDragArea.BOTTOM_LEFT;
+            return ResizeDragArea.LEFT;
+        }
+        if (mx > area.w() - ras) {
+            if (my < ras) return ResizeDragArea.TOP_RIGHT;
+            if (my > area.h() - ras) return ResizeDragArea.BOTTOM_RIGHT;
+            return ResizeDragArea.RIGHT;
+        }
+        if (my < ras) return ResizeDragArea.TOP;
+        if (my > area.h() - ras) return ResizeDragArea.BOTTOM;
+        return null;
+    }
+
+    /**
+     * An internal method to actually resize the widget while an edge is being dragged.
+     */
+    static void applyDrag(IDragResizeable resizeable, IWidget widget, ResizeDragArea dragArea, Area startArea, int dx,
+                          int dy) {
+        int keepPosFactor = resizeable.keepPosOnDragResize() || GTUtil.isShiftDown() ? 2 : 1;
+        if (dx != 0) {
+            if (dragArea.left) {
+                int s = startArea.width - dx * keepPosFactor;
+                if (s >= resizeable.getMinDragWidth()) {
+                    widget.resizer().left(startArea.rx + dx);
+                    widget.resizer().width(s);
+                }
+            } else if (dragArea.right) {
+                int s = startArea.width + dx * keepPosFactor;
+                if (s >= resizeable.getMinDragWidth()) {
+                    widget.resizer().left(startArea.rx - dx * (keepPosFactor - 1));
+                    widget.resizer().width(s);
+                }
+            }
+        }
+        if (dy != 0) {
+            if (dragArea.top) {
+                int s = startArea.height - dy * keepPosFactor;
+                if (s >= resizeable.getMinDragHeight()) {
+                    widget.resizer().top(startArea.ry + dy);
+                    widget.resizer().height(s);
+                }
+            } else if (dragArea.bottom) {
+                int s = startArea.height + dy * keepPosFactor;
+                if (s >= resizeable.getMinDragHeight()) {
+                    widget.resizer().top(startArea.ry - dy * (keepPosFactor - 1));
+                    widget.resizer().height(s);
+                }
+            }
+        }
+        resizeable.onDragResize();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDraggable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDraggable.java
new file mode 100644
index 00000000000..339392b0a29
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IDraggable.java
@@ -0,0 +1,68 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.widget.DraggableWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Marks a widget as draggable.
+ * The dragging is handled by ModularUI.
+ *
+ * @see DraggableWidget
+ */
+public interface IDraggable {
+
+    /**
+     * Gets called every frame after everything else is rendered.
+     * Is only called when {@link #isMoving()} is true.
+     * Translate to the mouse pos and draw with
+     * {@link WidgetTree#drawTree(IWidget, ModularGuiContext, boolean, boolean)}.
+     *
+     * @param graphics
+     * @param partialTicks difference from last from
+     */
+    void drawMovingState(GuiGraphics graphics, ModularGuiContext context, float partialTicks);
+
+    /**
+     * @param button the mouse button that's holding down
+     * @return false if the action should be canceled
+     */
+    boolean onDragStart(int button);
+
+    /**
+     * The dragging has ended and getState == IDLE
+     *
+     * @param successful is false if this returned to its old position
+     */
+    void onDragEnd(boolean successful);
+
+    void onDrag(int mouseButton, double timeSinceLastClick);
+
+    /**
+     * Gets called when the mouse is released
+     *
+     * @param widget current top most widget below the mouse
+     * @return if the location is valid
+     */
+    default boolean canDropHere(int x, int y, @Nullable IWidget widget) {
+        return true;
+    }
+
+    /**
+     * @return the size and pos during move
+     */
+    @Nullable
+    Area getMovingArea();
+
+    boolean isMoving();
+
+    void setMoving(boolean moving);
+
+    void transform(IViewportStack viewportStack);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IFocusedWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IFocusedWidget.java
new file mode 100644
index 00000000000..518acdcabb4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IFocusedWidget.java
@@ -0,0 +1,29 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+/**
+ * An interface for {@link IWidget}'s, that makes them focusable.
+ * Usually used for text fields to receive keyboard and mouse input first, no matter if its hovered or not.
+ */
+public interface IFocusedWidget {
+
+    /**
+     * @return this widget is currently focused
+     */
+    boolean isFocused();
+
+    /**
+     * Called when this widget gets focused
+     *
+     * @param context gui context
+     */
+    void onFocus(ModularGuiContext context);
+
+    /**
+     * Called when the focus is removed from this widget
+     *
+     * @param context gui context
+     */
+    void onRemoveFocus(ModularGuiContext context);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IGuiAction.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IGuiAction.java
new file mode 100644
index 00000000000..4eeb2471f3e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IGuiAction.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+/**
+ * Gui action listeners that can be registered in {@link ModularScreen#registerGuiActionListener(IGuiAction)}
+ */
+public interface IGuiAction {
+
+    @FunctionalInterface
+    interface MousePressed extends IGuiAction {
+
+        boolean press(double mouseX, double mouseY, int button);
+    }
+
+    @FunctionalInterface
+    interface MouseReleased extends IGuiAction {
+
+        boolean release(double mouseX, double mouseY, int button);
+    }
+
+    @FunctionalInterface
+    interface KeyPressed extends IGuiAction {
+
+        boolean press(int keyCode, int scanCode, int modifiers);
+    }
+
+    @FunctionalInterface
+    interface KeyReleased extends IGuiAction {
+
+        boolean release(int keyCode, int scanCode, int modifiers);
+    }
+
+    @FunctionalInterface
+    interface CharTyped extends IGuiAction {
+
+        boolean type(char codePoint, int modifiers);
+    }
+
+    @FunctionalInterface
+    interface MouseScroll extends IGuiAction {
+
+        boolean scroll(double mouseX, double mouseY, double delta);
+    }
+
+    @FunctionalInterface
+    interface MouseDrag extends IGuiAction {
+
+        boolean drag(double mouseX, double mouseY, int button, double dragX, double dragY);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/INotifyEnabled.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/INotifyEnabled.java
new file mode 100644
index 00000000000..5f65fb976d1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/INotifyEnabled.java
@@ -0,0 +1,6 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+public interface INotifyEnabled {
+
+    void onChildChangeEnabled(IWidget child, boolean enabled);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IParentWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IParentWidget.java
new file mode 100644
index 00000000000..6231cba2552
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IParentWidget.java
@@ -0,0 +1,29 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import java.util.function.Supplier;
+
+public interface IParentWidget<I extends IWidget, W extends IParentWidget<I, W>> {
+
+    W getThis();
+
+    boolean addChild(I child, int index);
+
+    default W child(int index, I child) {
+        if (!addChild(child, index)) {
+            throw new IllegalStateException("Failed to add child");
+        }
+        return getThis();
+    }
+
+    default W child(I child) {
+        if (!addChild(child, -1)) {
+            throw new IllegalStateException("Failed to add child");
+        }
+        return getThis();
+    }
+
+    default W childIf(boolean condition, Supplier<I> child) {
+        if (condition) return child(child.get());
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IPositioned.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IPositioned.java
new file mode 100644
index 00000000000..5048f1c9121
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IPositioned.java
@@ -0,0 +1,515 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.*;
+
+import java.util.function.Consumer;
+import java.util.function.DoubleSupplier;
+
+/**
+ * Helper interface for position and size builder methods for widgets.
+ *
+ * @param <W> widget type
+ */
+@SuppressWarnings({ "unused", "UnusedReturnValue" })
+public interface IPositioned<W extends IPositioned<W>> {
+
+    StandardResizer resizer();
+
+    Area getArea();
+
+    void scheduleResize();
+
+    boolean requiresResize();
+
+    @SuppressWarnings("unchecked")
+    default W getThis() {
+        return (W) this;
+    }
+
+    default W coverChildrenWidth() {
+        resizer().coverChildrenWidth();
+        return getThis();
+    }
+
+    default W coverChildrenHeight() {
+        resizer().coverChildrenHeight();
+        return getThis();
+    }
+
+    default W coverChildren() {
+        return coverChildrenWidth().coverChildrenHeight();
+    }
+
+    default W expanded() {
+        resizer().expanded();
+        return getThis();
+    }
+
+    @Deprecated
+    default W relative(Area area) {
+        return relative(new AreaResizer(area));
+    }
+
+    default W relative(ResizeNode resizeNode) {
+        resizer().relative(resizeNode);
+        return getThis();
+    }
+
+    default W relative(IWidget widget) {
+        return relative(widget.resizer());
+    }
+
+    default W relativeToScreen() {
+        resizer().relativeToScreen();
+        return getThis();
+    }
+
+    default W relativeToParent() {
+        resizer().relativeToParent();
+        return getThis();
+    }
+
+    default W left(int val) {
+        resizer().left(val, 0, 0, Unit.Measure.PIXEL, true);
+        return getThis();
+    }
+
+    default W leftRel(float val) {
+        resizer().left(val, 0, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W leftRelOffset(float val, int offset) {
+        resizer().left(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W leftRelAnchor(float val, float anchor) {
+        resizer().left(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W leftRel(float val, int offset, float anchor) {
+        resizer().left(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W left(float val, int offset, float anchor, Unit.Measure measure) {
+        resizer().left(val, offset, anchor, measure, false);
+        return getThis();
+    }
+
+    default W left(DoubleSupplier val, Unit.Measure measure) {
+        resizer().left(val, 0, 0, measure, true);
+        return getThis();
+    }
+
+    default W leftRelOffset(DoubleSupplier val, int offset) {
+        resizer().left(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W leftRelAnchor(DoubleSupplier val, float anchor) {
+        resizer().left(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W leftRel(DoubleSupplier val, int offset, float anchor) {
+        resizer().left(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W right(int val) {
+        resizer().right(val, 0, 0, Unit.Measure.PIXEL, true);
+        return getThis();
+    }
+
+    default W rightRel(float val) {
+        resizer().right(val, 0, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W rightRelOffset(float val, int offset) {
+        resizer().right(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W rightRelAnchor(float val, float anchor) {
+        resizer().right(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W rightRel(float val, int offset, float anchor) {
+        resizer().right(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W right(float val, int offset, float anchor, Unit.Measure measure) {
+        resizer().right(val, offset, anchor, measure, false);
+        return getThis();
+    }
+
+    default W right(DoubleSupplier val, Unit.Measure measure) {
+        resizer().right(val, 0, 0, measure, true);
+        return getThis();
+    }
+
+    default W rightRelOffset(DoubleSupplier val, int offset) {
+        resizer().right(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W rightRelAnchor(DoubleSupplier val, float anchor) {
+        resizer().right(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W rightRel(DoubleSupplier val, int offset, float anchor) {
+        resizer().right(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W top(int val) {
+        resizer().top(val, 0, 0, Unit.Measure.PIXEL, true);
+        return getThis();
+    }
+
+    default W topRel(float val) {
+        resizer().top(val, 0, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W topRelOffset(float val, int offset) {
+        resizer().top(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W topRelAnchor(float val, float anchor) {
+        resizer().top(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W topRel(float val, int offset, float anchor) {
+        resizer().top(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W top(float val, int offset, float anchor, Unit.Measure measure) {
+        resizer().top(val, offset, anchor, measure, false);
+        return getThis();
+    }
+
+    default W top(DoubleSupplier val, Unit.Measure measure) {
+        resizer().top(val, 0, 0, measure, true);
+        return getThis();
+    }
+
+    default W topRelOffset(DoubleSupplier val, int offset) {
+        resizer().top(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W topRelAnchor(DoubleSupplier val, float anchor) {
+        resizer().top(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W topRel(DoubleSupplier val, int offset, float anchor) {
+        resizer().top(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W bottom(int val) {
+        resizer().bottom(val, 0, 0, Unit.Measure.PIXEL, true);
+        return getThis();
+    }
+
+    default W bottomRel(float val) {
+        resizer().bottom(val, 0, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W bottomRelOffset(float val, int offset) {
+        resizer().bottom(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W bottomRelAnchor(float val, float anchor) {
+        resizer().bottom(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W bottomRel(float val, int offset, float anchor) {
+        resizer().bottom(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W bottom(float val, int offset, float anchor, Unit.Measure measure) {
+        resizer().bottom(val, offset, anchor, measure, false);
+        return getThis();
+    }
+
+    default W bottom(DoubleSupplier val, Unit.Measure measure) {
+        resizer().bottom(val, 0, 0, measure, true);
+        return getThis();
+    }
+
+    default W bottomRelOffset(DoubleSupplier val, int offset) {
+        resizer().bottom(val, offset, 0, Unit.Measure.RELATIVE, true);
+        return getThis();
+    }
+
+    default W bottomRelAnchor(DoubleSupplier val, float anchor) {
+        resizer().bottom(val, 0, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W bottomRel(DoubleSupplier val, int offset, float anchor) {
+        resizer().bottom(val, offset, anchor, Unit.Measure.RELATIVE, false);
+        return getThis();
+    }
+
+    default W width(int val) {
+        resizer().width(val, 0, Unit.Measure.PIXEL);
+        return getThis();
+    }
+
+    default W widthRel(float val) {
+        resizer().width(val, 0, Unit.Measure.RELATIVE);
+        return getThis();
+    }
+
+    default W widthRelOffset(float val, int offset) {
+        resizer().width(val, offset, Unit.Measure.RELATIVE);
+        return getThis();
+    }
+
+    default W width(float val, Unit.Measure measure) {
+        resizer().width(val, 0, measure);
+        return getThis();
+    }
+
+    default W width(DoubleSupplier val, Unit.Measure measure) {
+        resizer().width(val, 0, measure);
+        return getThis();
+    }
+
+    default W height(int val) {
+        resizer().height(val, 0, Unit.Measure.PIXEL);
+        return getThis();
+    }
+
+    default W heightRel(float val) {
+        resizer().height(val, 0, Unit.Measure.RELATIVE);
+        return getThis();
+    }
+
+    default W height(float val, Unit.Measure measure) {
+        resizer().height(val, 0, measure);
+        return getThis();
+    }
+
+    default W heightRelOffset(float val, int offset) {
+        resizer().height(val, offset, Unit.Measure.RELATIVE);
+        return getThis();
+    }
+
+    default W heightRelOffset(DoubleSupplier val, int offset) {
+        resizer().height(val, offset, Unit.Measure.RELATIVE);
+        return getThis();
+    }
+
+    default W height(DoubleSupplier val, Unit.Measure measure) {
+        resizer().height(val, 0, measure);
+        return getThis();
+    }
+
+    default W pos(int x, int y) {
+        left(x).top(y);
+        return getThis();
+    }
+
+    default W posRel(float x, float y) {
+        leftRel(x).topRel(y);
+        return getThis();
+    }
+
+    default W size(int w, int h) {
+        width(w).height(h);
+        return getThis();
+    }
+
+    default W sizeRel(float w, float h) {
+        widthRel(w).heightRel(h);
+        return getThis();
+    }
+
+    default W size(int val) {
+        return width(val).height(val);
+    }
+
+    default W sizeRel(float val) {
+        return widthRel(val).heightRel(val);
+    }
+
+    default W fullWidth() {
+        return widthRel(1f);
+    }
+
+    default W fullHeight() {
+        return heightRel(1f);
+    }
+
+    default W full() {
+        return widthRel(1f).heightRel(1f);
+    }
+
+    default W anchorLeft(float val) {
+        resizer().anchorLeft(val);
+        return getThis();
+    }
+
+    default W anchorRight(float val) {
+        resizer().anchorRight(val);
+        return getThis();
+    }
+
+    default W anchorTop(float val) {
+        resizer().anchorTop(val);
+        return getThis();
+    }
+
+    default W anchorBottom(float val) {
+        resizer().anchorBottom(val);
+        return getThis();
+    }
+
+    default W anchor(Alignment alignment) {
+        resizer().anchor(alignment);
+        return getThis();
+    }
+
+    default W alignX(float val) {
+        leftRel(val).anchorLeft(val);
+        return getThis();
+    }
+
+    default W alignX(Alignment alignment) {
+        return alignX(alignment.x);
+    }
+
+    default W alignY(float val) {
+        topRel(val).anchorTop(val);
+        return getThis();
+    }
+
+    default W alignY(Alignment alignment) {
+        return alignY(alignment.y);
+    }
+
+    default W align(Alignment alignment) {
+        return alignX(alignment).alignY(alignment);
+    }
+
+    default W horizontalCenter() {
+        return alignX(Alignment.CENTER);
+    }
+
+    default W verticalCenter() {
+        return alignY(Alignment.CENTER);
+    }
+
+    default W center() {
+        return align(Alignment.Center);
+    }
+
+    default W resizer(Consumer<StandardResizer> resizerConsumer) {
+        resizerConsumer.accept(resizer());
+        return getThis();
+    }
+
+    default W padding(int left, int right, int top, int bottom) {
+        getArea().getPadding().all(left, right, top, bottom);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W padding(int horizontal, int vertical) {
+        getArea().getPadding().all(horizontal, vertical);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W padding(int all) {
+        getArea().getPadding().all(all);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W paddingLeft(int val) {
+        getArea().getPadding().left(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W paddingRight(int val) {
+        getArea().getPadding().right(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W paddingTop(int val) {
+        getArea().getPadding().top(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W paddingBottom(int val) {
+        getArea().getPadding().bottom(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W margin(int left, int right, int top, int bottom) {
+        getArea().getMargin().all(left, right, top, bottom);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W margin(int horizontal, int vertical) {
+        getArea().getMargin().all(horizontal, vertical);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W margin(int all) {
+        getArea().getMargin().all(all);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W marginLeft(int val) {
+        getArea().getMargin().left(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W marginRight(int val) {
+        getArea().getMargin().right(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W marginTop(int val) {
+        getArea().getMargin().top(val);
+        scheduleResize();
+        return getThis();
+    }
+
+    default W marginBottom(int val) {
+        getArea().getMargin().bottom(val);
+        scheduleResize();
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ISynced.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ISynced.java
new file mode 100644
index 00000000000..5be499d2a32
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ISynced.java
@@ -0,0 +1,107 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandler;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Marks a widget as synced
+ *
+ * @param <W> widget type
+ */
+public interface ISynced<W extends IWidget> {
+
+    /**
+     * @return this cast to the true widget type
+     */
+    @SuppressWarnings("unchecked")
+    default W getThis() {
+        return (W) this;
+    }
+
+    /**
+     * Called when this widget gets initialised or when this widget is added to the gui
+     *
+     * @param syncManager sync manager
+     * @param late        if this is called at any point after the panel this widget belongs to opened
+     */
+    void initialiseSyncHandler(ModularSyncManager syncManager, boolean late);
+
+    /**
+     * Returns if the given value or sync handler is valid for this widget. This is usually a call to
+     * {@link ISyncOrValue#isTypeOrEmpty(Class)}. If the widget must specify a value (disallow null) instanceof check
+     * can be used. You can
+     * check for primitive types which don't have a dedicated {@link com.gregtechceu.gtceu.api.mui.base.value.IValue
+     * IValue} interface with
+     * {@link ISyncOrValue#isValueOfType(Class)}.
+     *
+     * @param syncOrValue a sync handler or a value, but never null
+     * @return if the value or sync handler is valid for this class
+     */
+    default boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return false;
+    }
+
+    /**
+     * Checks if the given sync handler is valid for this widget and throws an exception if not.
+     * Override {@link #isValidSyncOrValue(ISyncOrValue)}
+     *
+     * @param syncHandler given sync handler
+     * @throws IllegalStateException if the given sync handler is invalid for this widget.
+     */
+    @ApiStatus.NonExtendable
+    default void checkValidSyncOrValue(ISyncOrValue syncHandler) {
+        if (!isValidSyncOrValue(syncHandler)) {
+            throw new IllegalStateException(
+                    "SyncHandler of type '" + syncHandler.getClass().getSimpleName() + "' is not valid " +
+                            "for widget '" + this + "'.");
+        }
+    }
+
+    /**
+     * @return true if this widget has a valid sync handler
+     */
+    boolean isSynced();
+
+    /**
+     * @return the sync handler of this widget
+     * @throws IllegalStateException if this widget has no valid sync handler
+     */
+    @NotNull
+    SyncHandler getSyncHandler();
+
+    /**
+     * Sets the sync handler key. The sync handler will be obtained in
+     * {@link #initialiseSyncHandler(ModularSyncManager, boolean)}
+     *
+     * @param name sync handler key name
+     * @param id   sync handler key id
+     * @return this
+     */
+    W syncHandler(String name, int id);
+
+    /**
+     * Sets the sync handler key. The sync handler will be obtained in
+     * {@link #initialiseSyncHandler(ModularSyncManager, boolean)}
+     *
+     * @param key sync handler name
+     * @return this
+     */
+    default W syncHandler(String key) {
+        return syncHandler(key, 0);
+    }
+
+    /**
+     * Sets the sync handler key. The sync handler will be obtained in
+     * {@link #initialiseSyncHandler(ModularSyncManager, boolean)}
+     *
+     * @param id sync handler id
+     * @return this
+     */
+    default W syncHandler(int id) {
+        return syncHandler("_", id);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ITooltip.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ITooltip.java
new file mode 100644
index 00000000000..5e0b2438407
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ITooltip.java
@@ -0,0 +1,283 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.api.mui.drawable.text.StyledText;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+
+/**
+ * Helper interface with tooltip builder methods for widgets.
+ *
+ * @param <W> widget type
+ */
+public interface ITooltip<W extends ITooltip<W>> {
+
+    /**
+     * @return the current tooltip of this widget. Null if there is none
+     */
+    @Nullable
+    RichTooltip getTooltip();
+
+    /**
+     * @return the current tooltip of this widget. Creates a new one if there is none
+     */
+    @NotNull
+    RichTooltip tooltip();
+
+    /**
+     * Overwrites the current tooltip with the given one
+     *
+     * @param tooltip new tooltip
+     * @return this
+     */
+    W tooltip(RichTooltip tooltip);
+
+    /**
+     * @return true if this widget has a tooltip
+     */
+    default boolean hasTooltip() {
+        return getTooltip() != null && !getTooltip().isEmpty();
+    }
+
+    /**
+     * @return this cast to the true widget type
+     */
+    @SuppressWarnings("unchecked")
+    default W getThis() {
+        return (W) this;
+    }
+
+    /**
+     * Helper method to call tooltip setters within a widget tree initialisation.
+     * Only called once.
+     *
+     * @param tooltipConsumer tooltip function
+     * @return this
+     */
+    default W tooltip(Consumer<RichTooltip> tooltipConsumer) {
+        return tooltipStatic(tooltipConsumer);
+    }
+
+    /**
+     * Helper method to call tooltip setters within a widget tree initialisation.
+     * Only called once.
+     *
+     * @param tooltipConsumer tooltip function
+     * @return this
+     */
+    default W tooltipStatic(Consumer<RichTooltip> tooltipConsumer) {
+        tooltipConsumer.accept(tooltip());
+        return getThis();
+    }
+
+    /**
+     * Sets a tooltip builder. The builder will be called every time the tooltip is marked dirty.
+     * Should be used for dynamic tooltips.
+     *
+     * @param tooltipBuilder tooltip function
+     * @return this
+     */
+    default W tooltipBuilder(Consumer<RichTooltip> tooltipBuilder) {
+        return tooltipDynamic(tooltipBuilder);
+    }
+
+    /**
+     * Sets a tooltip builder. The builder will be called every time the tooltip is marked dirty.
+     * Should be used for dynamic tooltips.
+     *
+     * @param tooltipBuilder tooltip function
+     * @return this
+     */
+    default W tooltipDynamic(Consumer<RichTooltip> tooltipBuilder) {
+        tooltip().tooltipBuilder(tooltipBuilder);
+        return getThis();
+    }
+
+    /**
+     * Sets a general tooltip position. The true position is calculated every frame.
+     *
+     * @param pos tooltip pos
+     * @return this
+     */
+    default W tooltipPos(RichTooltip.Pos pos) {
+        tooltip().pos(pos);
+        return getThis();
+    }
+
+    /**
+     * Sets a fixed tooltip position.
+     *
+     * @param x x pos
+     * @param y y pos
+     * @return this
+     */
+    default W tooltipPos(int x, int y) {
+        tooltip().pos(x, y);
+        return getThis();
+    }
+
+    /**
+     * Sets an alignment. The alignment determines how the content is aligned in the tooltip.
+     *
+     * @param alignment alignment
+     * @return this
+     */
+    default W tooltipAlignment(Alignment alignment) {
+        tooltip().alignment(alignment);
+        return getThis();
+    }
+
+    /**
+     * Sets if the tooltip text should have shadow enabled by default.
+     * Can be overridden with {@link StyledText} lines.
+     *
+     * @param textShadow true if text should have a shadow
+     * @return this
+     */
+    default W tooltipTextShadow(boolean textShadow) {
+        tooltip().textShadow(textShadow);
+        return getThis();
+    }
+
+    /**
+     * Sets a default tooltip text color. Can be overridden with text formatting.
+     *
+     * @param textColor text color
+     * @return this
+     */
+    default W tooltipTextColor(int textColor) {
+        tooltip().textColor(textColor);
+        return getThis();
+    }
+
+    /**
+     * Sets a tooltip scale. The whole tooltip with content will be drawn with this scale.
+     *
+     * @param scale scale
+     * @return this
+     */
+    default W tooltipScale(float scale) {
+        tooltip().scale(scale);
+        return getThis();
+    }
+
+    /**
+     * Sets a show up timer. This is the time in ticks needed for the cursor to hover this widget for the tooltip to
+     * appear.
+     *
+     * @param showUpTimer show up timer in ticks
+     * @return this
+     */
+    default W tooltipShowUpTimer(int showUpTimer) {
+        tooltip().showUpTimer(showUpTimer);
+        return getThis();
+    }
+
+    /**
+     * Sets whether the tooltip should automatically update on every render tick. In most of the cases you don't need
+     * this,
+     * as ValueSyncHandler handles tooltip update for you when value is updated. However, if you don't handle
+     * differently,
+     * you either need to manually set change listener for the sync value, or set auto update to true.
+     *
+     * @param update true if the tooltip should automatically update
+     * @return this
+     */
+    default W tooltipAutoUpdate(boolean update) {
+        tooltip().autoUpdate(update);
+        return getThis();
+    }
+
+    /**
+     * Sets whether the tooltip has a title margin, which is 2px space between first and second line inserted by
+     * default.
+     *
+     * @param hasTitleMargin true if the tooltip should have a title margin
+     * @return this
+     */
+    default W tooltipHasTitleMargin(boolean hasTitleMargin) {
+        // tooltip().setHasTitleMargin(hasTitleMargin);
+        return getThis();
+    }
+
+    /**
+     * Sets the line padding for the tooltip. 1px by default, and you can disable it by passing 0.
+     *
+     * @param linePadding line padding in px
+     * @return this
+     */
+    default W tooltipLinePadding(int linePadding) {
+        // tooltip().setLinePadding(linePadding);
+        return getThis();
+    }
+
+    default W addTooltipElement(String s) {
+        tooltip().add(s);
+        return getThis();
+    }
+
+    default W addTooltipElement(IDrawable drawable) {
+        tooltip().add(drawable);
+        return getThis();
+    }
+
+    default W addTooltipLine(ITextLine line) {
+        tooltip().addLine(line);
+        return getThis();
+    }
+
+    /**
+     * Adds any drawable as a new line. Inlining elements is currently not possible.
+     *
+     * @param drawable drawable element.
+     * @return this
+     */
+    default W addTooltipLine(IDrawable drawable) {
+        tooltip().add(drawable).newLine();
+        return getThis();
+    }
+
+    /**
+     * Helper method to add a simple string as a line. Adds multiple lines if string contains <code>\n</code>.
+     *
+     * @param line text line
+     * @return this
+     */
+    default W addTooltipLine(String line) {
+        return addTooltipLine(IKey.str(line));
+    }
+
+    /**
+     * Helper method to add multiple drawable lines.
+     *
+     * @param lines collection of drawable elements
+     * @return this
+     */
+    default W addTooltipDrawableLines(Iterable<IDrawable> lines) {
+        tooltip().addDrawableLines(lines);
+        return getThis();
+    }
+
+    /**
+     * Helper method to add multiple text lines.
+     *
+     * @param lines lines of text
+     * @return this
+     */
+    default W addTooltipStringLines(Iterable<String> lines) {
+        tooltip().addStringLines(lines);
+        return getThis();
+    }
+
+    default W removeAllTooltips() {
+        tooltip().reset();
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IValueWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IValueWidget.java
new file mode 100644
index 00000000000..e3f7cf72915
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IValueWidget.java
@@ -0,0 +1,14 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+/**
+ * Marks a widget as containing a value
+ *
+ * @param <T>
+ */
+public interface IValueWidget<T> extends IWidget {
+
+    /**
+     * @return stored value
+     */
+    T getWidgetValue();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IVanillaSlot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IVanillaSlot.java
new file mode 100644
index 00000000000..950b6aa86d9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IVanillaSlot.java
@@ -0,0 +1,16 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import net.minecraft.world.inventory.Slot;
+
+/**
+ * Marks a {@link IWidget} as containing a vanilla item slot.
+ */
+public interface IVanillaSlot {
+
+    /**
+     * @return the item slot of this widget
+     */
+    Slot getVanillaSlot();
+
+    boolean handleAsVanillaSlot();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IWidget.java
new file mode 100644
index 00000000000..4137719be58
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/IWidget.java
@@ -0,0 +1,377 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.ITreeNode;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Stencil;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.StandardResizer;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
+
+import com.google.common.base.CharMatcher;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * A widget in a GUI.
+ */
+public interface IWidget extends ITreeNode<IWidget> {
+
+    String WIDGET_TRANSLATION_KEY_FORMAT = "widget.%s.name";
+    /**
+     * This char matcher is used to remove any non-{@code [a-z0-9_.-]} characters in translation keys.
+     * In essence, it
+     */
+    CharMatcher DISALLOWED_TRANSLATION_KEY_CHARS = CharMatcher.inRange('a', 'z')
+            .or(CharMatcher.inRange('0', '9'))
+            .or(CharMatcher.anyOf("-_."))
+            .negate();
+
+    default String getTranslationId() {
+        String className = FormattingUtil.toLowerCaseUnderscore(this.getClass().getSimpleName());
+        className = DISALLOWED_TRANSLATION_KEY_CHARS.removeFrom(className);
+        return WIDGET_TRANSLATION_KEY_FORMAT.formatted(className);
+    }
+
+    /**
+     * @return the screen this element is in
+     */
+    ModularScreen getScreen();
+
+    /**
+     * @return the parent of this widget
+     */
+    @NotNull
+    @Override
+    IWidget getParent();
+
+    @Override
+    default boolean hasParent() {
+        return isValid();
+    }
+
+    /**
+     * @return the context the current screen
+     */
+    ModularGuiContext getContext();
+
+    /**
+     * @return the panel this widget is in
+     */
+    @NotNull
+    ModularPanel getPanel();
+
+    /**
+     * @return the area this widget occupies
+     */
+    Area getArea();
+
+    /**
+     * Shortcut to get the area of the parent
+     *
+     * @return parent area
+     */
+    default Area getParentArea() {
+        return getParent().getArea();
+    }
+
+    /**
+     * Calculates if a given pos is inside this widgets area.
+     * This should be used over {@link Area#isInside(int, int)}, since this accounts for transformations.
+     *
+     * @param stack viewport stack
+     * @param mx    x pos
+     * @param my    y pos
+     * @return if pos is inside this widgets area
+     */
+    default boolean isInside(IViewportStack stack, int mx, int my) {
+        return isInside(stack, mx, my, true);
+    }
+
+    /**
+     * Calculates if a given pos is inside this widgets area.
+     * This should be used over {@link Area#isInside(int, int)}, since this accounts for transformations.
+     *
+     * @param stack    viewport stack
+     * @param mx       x pos
+     * @param my       y pos
+     * @param absolute true if the position is absolute or relative to the current stack transform otherwise
+     * @return if pos is inside this widgets area
+     */
+    default boolean isInside(IViewportStack stack, int mx, int my, boolean absolute) {
+        int x = mx;
+        int y = my;
+        if (absolute) {
+            x = stack.unTransformX(mx, my);
+            y = stack.unTransformY(mx, my);
+        }
+        return x >= 0 && x < getArea().w() && y >= 0 && y < getArea().h();
+    }
+
+    /**
+     * Called when the mouse hovers this element. This means this element is directly below the mouse or there are
+     * widgets in between which
+     * all allow to pass hover through. This is not called when the element is at any point below the mouse.
+     */
+    default void onMouseStartHover() {}
+
+    /**
+     * Called when the mouse no longer hovers this element. This widget can still be below the mouse on some level.
+     */
+    default void onMouseEndHover() {}
+
+    /**
+     * Called when the mouse enters this elements area with any amount of widgets above it from the current panel.
+     */
+    default void onMouseEnterArea() {}
+
+    /**
+     * Called when the mouse leaves the area, or it started hovering a different panel.
+     */
+    default void onMouseLeaveArea() {}
+
+    /**
+     * @return if this widget is currently right below the mouse
+     */
+    default boolean isHovering() {
+        return isHoveringFor(0);
+    }
+
+    /**
+     * Returns if this element is right blow the mouse for a certain amount of time
+     *
+     * @param ticks time in ticks
+     * @return if this element is right blow the mouse for a certain amount of time
+     */
+    default boolean isHoveringFor(int ticks) {
+        return false;
+    }
+
+    default boolean isBelowMouse() {
+        return isBelowMouseFor(0);
+    }
+
+    default boolean isBelowMouseFor(int ticks) {
+        return false;
+    }
+
+    /**
+     * If this widget can be seen on the screen even partly. If this returns false it will be culled. This is visually
+     * only!
+     *
+     * @param stack viewport stack
+     * @return false if this widget can not be seen currently and should not be drawn
+     */
+    default boolean canBeSeen(IViewportStack stack) {
+        return Stencil.isInsideScissorArea(getArea(), stack);
+    }
+
+    /**
+     * Determines if this widget can have any hover interaction. Interactions with mouse or keyboard like clicks ignore
+     * this.
+     * This is useful, when you have a widget which changes its background when hovered or has a tooltip and some
+     * decoration child. Normally
+     * you can click through the child, but while you hover it the widget will not show its tooltip etc. To change that
+     * return false here.
+     *
+     * @return if this widget can have any hover interaction
+     */
+    default boolean canHover() {
+        return true;
+    }
+
+    /**
+     * Determines if widgets below this can receive a click callback. This is only called when this widget didn't
+     * consume the click.
+     *
+     * @return if widgets below this should be able to receive a click
+     */
+    default boolean canClickThrough() {
+        return true;
+    }
+
+    default boolean canHoverThrough() {
+        return false;
+    }
+
+    /**
+     * @return default width if it can't be calculated
+     */
+    default int getDefaultWidth() {
+        return 18;
+    }
+
+    /**
+     * @return default height if it can't be calculated
+     */
+    default int getDefaultHeight() {
+        return 18;
+    }
+
+    /**
+     * Validates and initialises this element.
+     * This element now becomes valid
+     *
+     * @param parent the parent this element belongs to
+     * @param late   true if this is called some time after the widget tree of the parent has been initialised
+     */
+    void initialise(@NotNull IWidget parent, boolean late);
+
+    /**
+     * Invalidates this element.
+     */
+    void dispose();
+
+    /**
+     * Determines if this element exist in an active gui.
+     *
+     * @return if this is in a valid gui
+     */
+    boolean isValid();
+
+    /**
+     * Called 20 times per second.
+     */
+    default void onUpdate() {}
+
+    /**
+     * Draws the background of this widget.
+     *
+     * @param context     gui context
+     * @param widgetTheme widget theme of this widget
+     */
+    default void drawBackground(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    /**
+     * Draws extra elements of this widget. Called after {@link #drawBackground(ModularGuiContext, WidgetThemeEntry)}
+     * and before
+     * {@link #drawOverlay(ModularGuiContext, WidgetThemeEntry)}
+     *
+     * @param context     gui context
+     * @param widgetTheme widget theme
+     */
+    default void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    /**
+     * Draws the overlay of this theme.
+     *
+     * @param context     gui context
+     * @param widgetTheme widget theme
+     */
+    default void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    /**
+     * Draws foreground elements of this widget. For example tooltips.
+     * No transformations are applied here.
+     *
+     * @param context gui context
+     */
+    default void drawForeground(ModularGuiContext context) {}
+
+    default void transform(IViewportStack stack) {
+        stack.translate(getArea().rx, getArea().ry, 0);
+    }
+
+    default Object getAdditionalHoverInfo(IViewportStack viewportStack, int mouseX, int mouseY) {
+        return null;
+    }
+
+    default WidgetThemeEntry<?> getWidgetTheme(ITheme theme) {
+        return theme.getFallback();
+    }
+
+    /**
+     * @return all children of this widget
+     */
+    @NotNull
+    @Override
+    default List<IWidget> getChildren() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * @return if this widget has any children
+     */
+    @Override
+    default boolean hasChildren() {
+        return !getChildren().isEmpty();
+    }
+
+    void scheduleResize();
+
+    boolean requiresResize();
+
+    /**
+     * @return resizer of this widget
+     */
+    @NotNull
+    StandardResizer resizer();
+
+    default IWidget resizerBuilder(Consumer<StandardResizer> builder) {
+        builder.accept(resizer());
+        return this;
+    }
+
+    /**
+     * Called before a widget is resized.
+     */
+    default void beforeResize(boolean onOpen) {}
+
+    /**
+     * Called after a widget is fully resized.
+     */
+    default void onResized() {}
+
+    /**
+     * Called after the full widget tree is resized and the absolute positions are calculated.
+     */
+    default void postResize() {}
+
+    /**
+     * Returns if this element is enabled. Disabled elements are not drawn and can not be interacted with. If this is
+     * disabled, the children
+     * will be considered disabled to without actually being disabled.
+     *
+     * @return if this element is enabled
+     */
+    boolean isEnabled();
+
+    void setEnabled(boolean enabled);
+
+    /**
+     * Checks if all ancestors are enabled. Only then this widget is visible and interactable.
+     *
+     * @return if all ancestors are enabled.
+     */
+    default boolean areAncestorsEnabled() {
+        IWidget parent = this;
+        do {
+            if (!parent.isEnabled()) return false;
+            parent = parent.getParent();
+        } while (parent.hasParent());
+        return true;
+    }
+
+    @Nullable
+    String getName();
+
+    default boolean isName(String name) {
+        return name.equals(getName());
+    }
+
+    default boolean isType(Class<? extends IWidget> type) {
+        return type.isAssignableFrom(getClass());
+    }
+
+    default boolean isNameAndType(String name, Class<? extends IWidget> type) {
+        return isName(name) && isType(type);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/Interactable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/Interactable.java
new file mode 100644
index 00000000000..5bd576ae2ce
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/Interactable.java
@@ -0,0 +1,232 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.resources.sounds.SimpleSoundInstance;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+
+/**
+ * An interface that handles user interactions on {@link IWidget} objects.
+ * These methods get called on the client
+ */
+public interface Interactable {
+
+    /**
+     * Called when this widget is pressed.
+     *
+     * @param mouseX the X coordinate of the mouse.
+     * @param mouseY the Y coordinate of the mouse.
+     * @param button mouse button that was pressed.
+     * @return result that determines what happens to other widgets
+     *         {@link #onMouseTapped(double, double, int)} is only called if this returns {@link Result#ACCEPT} or
+     *         {@link Result#SUCCESS}
+     */
+    @NotNull
+    default Result onMousePressed(double mouseX, double mouseY, int button) {
+        return Result.ACCEPT;
+    }
+
+    /**
+     * Called when a mouse button was released over this widget.
+     *
+     * @param mouseX the X coordinate of the mouse.
+     * @param mouseY the Y coordinate of the mouse.
+     * @param button mouse button that was released.
+     * @return whether other widgets should get called to. If this returns false,
+     *         {@link #onMouseTapped(double, double, int)} will NOT be called.
+     */
+    default boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        return false;
+    }
+
+    /**
+     * Called when this widget was pressed and then released within a certain time frame.
+     *
+     * @param mouseX the X coordinate of the mouse.
+     * @param mouseY the Y coordinate of the mouse.
+     * @param button mouse button that was pressed.
+     * @return result that determines if other widgets should get tapped to
+     *         {@link Result#IGNORE IGNORE} and {@link Result#ACCEPT ACCEPT} will both "ignore" the result and
+     *         {@link Result#STOP STOP} and {@link Result#SUCCESS SUCCESS} will both stop other widgets
+     *         from getting tapped.
+     */
+    @NotNull
+    default Result onMouseTapped(double mouseX, double mouseY, int button) {
+        return Result.IGNORE;
+    }
+
+    /**
+     * Called when a key over this widget is pressed.
+     *
+     * @param keyCode   key that was pressed.
+     * @param scanCode  character that was pressed.
+     * @param modifiers any modifiers that were used.
+     * @return result that determines what happens to other widgets
+     *         {@link #onKeyTapped(int, int, int)} is only called if this returns {@link Result#ACCEPT} or
+     *         {@link Result#SUCCESS}
+     */
+    @NotNull
+    default Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        return Result.IGNORE;
+    }
+
+    /**
+     * Called when a key was released over this widget.
+     *
+     * @param keyCode   key that was pressed.
+     * @param scanCode  character that was pressed.
+     * @param modifiers any modifiers that were used.
+     * @return whether other widgets should get called too. If this returns false, {@link #onKeyTapped(int, int, int)}
+     *         will NOT be called.
+     */
+    default boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        return false;
+    }
+
+    /**
+     * Called when this widget was pressed and then released within a certain time frame.
+     *
+     * @param keyCode   key that was pressed.
+     * @param scanCode  character that was pressed.
+     * @param modifiers any modifiers that were used.
+     * @return result that determines if other widgets should get tapped to
+     *         {@link Result#IGNORE} and {@link Result#ACCEPT} will both "ignore" the result and {@link Result#STOP} and
+     *         {@link Result#SUCCESS} will both stop other widgets from getting tapped.
+     */
+    @NotNull
+    default Result onKeyTapped(int keyCode, int scanCode, int modifiers) {
+        return Result.IGNORE;
+    }
+
+    /**
+     * Called when a key over this widget is pressed.
+     *
+     * @param codePoint character that was typed
+     * @param modifiers any modifiers that were used.
+     * @return result that determines what happens to other widgets
+     *         {@link #onKeyTapped(int, int, int)} is only called if this returns {@link Result#ACCEPT} or
+     *         {@link Result#SUCCESS}
+     */
+    @NotNull
+    default Result onCharTyped(char codePoint, int modifiers) {
+        return Result.IGNORE;
+    }
+
+    /**
+     * Called when this widget is focused or when the mouse is above this widget.
+     * This method should return true if it can scroll at all and not if it scrolled right now.
+     * If this scroll view scrolled to the end and this returns false, the scroll will get passed through another scroll
+     * view below this.
+     *
+     * @param mouseX the X coordinate of the mouse.
+     * @param mouseY the Y coordinate of the mouse.
+     * @param delta  amount scrolled by (usually irrelevant)
+     * @return true if this widget can be scrolled at all
+     */
+    default boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        return false;
+    }
+
+    /**
+     * Called when this widget was clicked and mouse is now dragging.
+     *
+     * @param mouseX current mouse X coordinate relative to the screen
+     * @param mouseY current mouse Y coordinate relative to the screen
+     * @param button mouse button that is held down
+     *               (0 = left button, 1 = right button, 2 = scroll button, 4 and 5 = side buttons)
+     * @param dragX  amount of drag on the X axis (e.g. the distance that has been dragged)
+     * @param dragY  amount of drag on the Y axis (e.g. the distance that has been dragged)
+     */
+    default void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {}
+
+    /**
+     * @return if left or right ctrl/cmd is pressed
+     */
+    @OnlyIn(Dist.CLIENT)
+    static boolean hasControlDown() {
+        return Screen.hasControlDown();
+    }
+
+    /**
+     * @return if left or right shift is pressed
+     */
+    @OnlyIn(Dist.CLIENT)
+    static boolean hasShiftDown() {
+        return Screen.hasShiftDown();
+    }
+
+    /**
+     * @return if alt or alt gr is pressed
+     */
+    @OnlyIn(Dist.CLIENT)
+    static boolean hasAltDown() {
+        return Screen.hasAltDown();
+    }
+
+    static boolean isModifierActive(int mod, int key) {
+        return (mod & key) != 0;
+    }
+
+    static boolean isControl(int mod) {
+        return isModifierActive(mod, GLFW.GLFW_MOD_CONTROL);
+    }
+
+    static boolean isShift(int mod) {
+        return isModifierActive(mod, GLFW.GLFW_MOD_SHIFT);
+    }
+
+    static boolean isAlt(int mod) {
+        return isModifierActive(mod, GLFW.GLFW_MOD_ALT);
+    }
+
+    /**
+     * @param key key id, see {@link InputConstants}
+     * @return if the key is pressed
+     */
+    @OnlyIn(Dist.CLIENT)
+    static boolean isKeyPressed(int key) {
+        return InputConstants.isKeyDown(Minecraft.getInstance().getWindow().getWindow(), key);
+    }
+
+    /**
+     * Plays the default button click sound
+     */
+    @OnlyIn(Dist.CLIENT)
+    static void playButtonClickSound() {
+        Minecraft.getInstance().getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+    }
+
+    enum Result {
+
+        /**
+         * Nothing happens.
+         */
+        IGNORE(false, false),
+        /**
+         * Interaction is accepted, but other widgets will get checked.
+         */
+        ACCEPT(true, false),
+        /**
+         * Interaction is rejected and no other widgets will get checked.
+         */
+        STOP(false, true),
+        /**
+         * Interaction is accepted and no other widgets will get checked.
+         */
+        SUCCESS(true, true);
+
+        public final boolean accepts;
+        public final boolean stops;
+
+        Result(boolean accepts, boolean stops) {
+            this.accepts = accepts;
+            this.stops = stops;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ResizeDragArea.java b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ResizeDragArea.java
new file mode 100644
index 00000000000..afe811efdbf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/base/widget/ResizeDragArea.java
@@ -0,0 +1,23 @@
+package com.gregtechceu.gtceu.api.mui.base.widget;
+
+public enum ResizeDragArea {
+
+    TOP_LEFT(true, true, false, false),
+    TOP_RIGHT(true, false, false, true),
+    BOTTOM_LEFT(false, true, true, false),
+    BOTTOM_RIGHT(false, false, true, true),
+    TOP(true, false, false, false),
+    LEFT(false, true, false, false),
+    BOTTOM(false, false, true, false),
+    RIGHT(false, false, false, true);
+
+    public final boolean top, left, bottom, right;
+
+    ResizeDragArea(boolean top, boolean left, boolean bottom, boolean right) {
+        if (top && bottom || left && right) throw new IllegalArgumentException();
+        this.top = top;
+        this.left = left;
+        this.bottom = bottom;
+        this.right = right;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/AdaptableUITexture.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/AdaptableUITexture.java
new file mode 100644
index 00000000000..e568335764a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/AdaptableUITexture.java
@@ -0,0 +1,226 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.resources.ResourceLocation;
+
+import com.google.gson.JsonObject;
+import com.mojang.blaze3d.systems.RenderSystem;
+import org.joml.Matrix4f;
+
+/**
+ * This class is a <a href="https://en.wikipedia.org/wiki/9-slice_scaling">9-slice texture</a>. It can be created using
+ * {@link UITexture.Builder#adaptable(int, int, int, int)}.
+ */
+public class AdaptableUITexture extends UITexture {
+
+    private final int imageWidth, imageHeight, bl, bt, br, bb;
+    private final boolean tiled;
+
+    /**
+     * Use {@link UITexture#builder()} with {@link Builder#adaptable(int, int)}
+     */
+    AdaptableUITexture(ResourceLocation location, float u0, float v0, float u1, float v1, ColorType colorType,
+                       boolean nonOpaque, int imageWidth, int imageHeight, int bl, int bt, int br, int bb,
+                       boolean tiled) {
+        super(location, u0, v0, u1, v1, colorType, nonOpaque);
+        this.imageWidth = imageWidth;
+        this.imageHeight = imageHeight;
+        this.bl = bl;
+        this.bt = bt;
+        this.br = br;
+        this.bb = bb;
+        this.tiled = tiled;
+    }
+
+    @Override
+    public AdaptableUITexture getSubArea(float uStart, float vStart, float uEnd, float vEnd) {
+        return new AdaptableUITexture(this.location, lerpU(uStart), lerpV(vStart), lerpU(uEnd), lerpV(vEnd),
+                this.colorType, this.nonOpaque, this.imageWidth, this.imageHeight, this.bl, this.bt, this.br, this.bb,
+                this.tiled);
+    }
+
+    @Override
+    public void draw(GuiContext context, float x, float y, float width, float height) {
+        if (width == this.imageWidth && height == this.imageHeight) {
+            super.draw(context, x, y, width, height);
+            return;
+        }
+        if (this.tiled) {
+            drawTiled(context, x, y, width, height);
+        } else {
+            drawStretched(context, x, y, width, height);
+        }
+    }
+
+    public void drawStretched(GuiContext context, float x, float y, float width, float height) {
+        Matrix4f pose = context.getLastGraphicsPose();
+
+        if (this.bl <= 0 && this.bt <= 0 && this.br <= 0 && this.bb <= 0) {
+            super.draw(context, x, y, width, height);
+            return;
+        }
+        if (this.nonOpaque) {
+            RenderSystem.enableBlend();
+        } else {
+            RenderSystem.disableBlend();
+        }
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        RenderSystem.setShaderTexture(0, this.location);
+
+        float uBl = this.bl * 1f / this.imageWidth, uBr = this.br * 1f / this.imageWidth;
+        float vBt = this.bt * 1f / this.imageHeight, vBb = this.bb * 1f / this.imageHeight;
+        float x1 = x + width, y1 = y + height;
+        float uInnerStart = this.u0 + uBl, vInnerStart = this.v0 + vBt, uInnerEnd = this.u1 - uBr,
+                vInnerEnd = this.v1 - vBb;
+
+        if ((this.bl > 0 || this.br > 0) && this.bt <= 0 && this.bb <= 0) {
+            // left border
+            GuiDraw.drawTexture(pose, x, y, x + this.bl, y1, this.u0, this.v0, uInnerStart, this.v1);
+            // right border
+            GuiDraw.drawTexture(pose, x1 - this.br, y, x1, y1, uInnerEnd, this.v0, this.u1, this.v1);
+            // center
+            GuiDraw.drawTexture(pose, x + this.bl, y, x1 - this.br, y1, uInnerStart, this.v0, uInnerEnd, this.v1);
+        } else if (this.bl <= 0 && this.br <= 0) {
+            // top border
+            GuiDraw.drawTexture(pose, x, y, x1, y + this.bt, this.u0, this.v0, this.u1, vInnerStart);
+            // bottom border
+            GuiDraw.drawTexture(pose, x, y1 - this.bb, x1, y1, this.u0, vInnerEnd, this.u1, this.v1);
+            // center
+            GuiDraw.drawTexture(pose, x, y + this.bt, x1, y1 - this.bb, this.u0, vInnerStart, this.u1, vInnerEnd);
+        } else {
+            // top left corner
+            GuiDraw.drawTexture(pose, x, y, x + this.bl, y + this.bt, this.u0, this.v0, uInnerStart, vInnerStart);
+            // top right corner
+            GuiDraw.drawTexture(pose, x1 - this.br, y, x1, y + this.bt, uInnerEnd, this.v0, this.u1, vInnerStart);
+            // bottom left corner
+            GuiDraw.drawTexture(pose, x, y1 - this.bb, x + this.bl, y1, this.u0, vInnerEnd, uInnerStart, this.v1);
+            // bottom right corner
+            GuiDraw.drawTexture(pose, x1 - this.br, y1 - this.bb, x1, y1, uInnerEnd, vInnerEnd, this.u1, this.v1);
+
+            // left border
+            GuiDraw.drawTexture(pose, x, y + this.bt, x + this.bl, y1 - this.bb, this.u0, vInnerStart, uInnerStart,
+                    vInnerEnd);
+            // top border
+            GuiDraw.drawTexture(pose, x + this.bl, y, x1 - this.br, y + this.bt, uInnerStart, this.v0, uInnerEnd,
+                    vInnerStart);
+            // right border
+            GuiDraw.drawTexture(pose, x1 - this.br, y + this.bt, x1, y1 - this.bb, uInnerEnd, vInnerStart, this.u1,
+                    vInnerEnd);
+            // bottom border
+            GuiDraw.drawTexture(pose, x + this.bl, y1 - this.bb, x1 - this.br, y1, uInnerStart, vInnerEnd, uInnerEnd,
+                    this.v1);
+
+            // center
+            GuiDraw.drawTexture(pose, x + this.bl, y + this.bt, x1 - this.br, y1 - this.bb, uInnerStart, vInnerStart,
+                    uInnerEnd, vInnerEnd);
+        }
+        RenderSystem.disableBlend();
+    }
+
+    public void drawTiled(GuiContext context, float x, float y, float width, float height) {
+        Matrix4f pose = context.getLastGraphicsPose();
+
+        if (this.bl <= 0 && this.bt <= 0 && this.br <= 0 && this.bb <= 0) {
+            GuiDraw.drawTiledTexture(pose, this.location, x, y, width, height, this.u0, this.v0, this.u1, this.v1,
+                    this.imageWidth, this.imageHeight, 0);
+            return;
+        }
+        if (this.nonOpaque) {
+            RenderSystem.enableBlend();
+        } else {
+            RenderSystem.disableBlend();
+        }
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        RenderSystem.setShaderTexture(0, this.location);
+
+        float uBl = this.bl * 1f / this.imageWidth, uBr = this.br * 1f / this.imageWidth;
+        float vBt = this.bt * 1f / this.imageHeight, vBb = this.bb * 1f / this.imageHeight;
+        float x1 = x + width, y1 = y + height;
+        float uInnerStart = this.u0 + uBl, vInnerStart = this.v0 + vBt, uInnerEnd = this.u1 - uBr,
+                vInnerEnd = this.v1 - vBb;
+
+        int tw = (int) (this.imageWidth * (this.u1 - this.u0));
+        int th = (int) (this.imageHeight * (this.v1 - this.v0));
+
+        if ((this.bl > 0 || this.br > 0) && this.bt <= 0 && this.bb <= 0) {
+            // left border
+            GuiDraw.drawTiledTexture(pose, x, y, this.bl, height, this.u0, this.v0, uInnerStart, this.v1, this.bl, th,
+                    0);
+            // right border
+            GuiDraw.drawTiledTexture(pose, x1 - this.br, y, this.br, height, uInnerEnd, this.v0, this.u1, this.v1,
+                    this.br, th, 0);
+            // center
+            GuiDraw.drawTiledTexture(pose, x + this.bl, y, width - this.bl - this.br, height, uInnerStart, this.v0,
+                    uInnerEnd, this.v1, tw - this.bl - this.br, th, 0);
+        } else if (this.bl <= 0 && this.br <= 0) {
+            // top border
+            GuiDraw.drawTiledTexture(pose, x, y, width, this.bt, this.u0, this.v0, this.u1, vInnerStart, tw, this.bt,
+                    0);
+            // bottom border
+            GuiDraw.drawTiledTexture(pose, x, y1 - this.bb, width, this.bb, this.u0, vInnerEnd, this.u1, this.v1, tw,
+                    this.bb, 0);
+            // center
+            GuiDraw.drawTiledTexture(pose, x, y + this.bt, width, height - this.bt - this.bb, this.u0, vInnerStart,
+                    this.u1, vInnerEnd, tw, th - this.bt - this.bb, 0);
+        } else {
+            // top left corner
+            GuiDraw.drawTiledTexture(pose, x, y, this.bl, this.bt, this.u0, this.v0, uInnerStart, vInnerStart, this.bl,
+                    this.bt, 0);
+            // top right corner
+            GuiDraw.drawTiledTexture(pose, x1 - this.br, y, this.br, this.bt, uInnerEnd, this.v0, this.u1, vInnerStart,
+                    this.br, this.bt, 0);
+            // bottom left corner
+            GuiDraw.drawTiledTexture(pose, x, y1 - this.bb, this.bl, this.bb, this.u0, vInnerEnd, uInnerStart, this.v1,
+                    this.bl, this.bb, 0);
+            // bottom right corner
+            GuiDraw.drawTiledTexture(pose, x1 - this.br, y1 - this.bb, this.br, this.bb, uInnerEnd, vInnerEnd, this.u1,
+                    this.v1, this.br, this.bb, 0);
+
+            // left border
+            GuiDraw.drawTiledTexture(pose, x, y + this.bt, this.bl, height - this.bt - this.bb, this.u0, vInnerStart,
+                    uInnerStart, vInnerEnd, this.bl, th - this.bt - this.bb, 0);
+            // top border
+            GuiDraw.drawTiledTexture(pose, x + this.bl, y, width - this.bl - this.br, this.bt, uInnerStart, this.v0,
+                    uInnerEnd, vInnerStart, tw - this.bl - this.bb, this.bt, 0);
+            // right border
+            GuiDraw.drawTiledTexture(pose, x1 - this.br, y + this.bt, this.br, height - this.bt - this.bb, uInnerEnd,
+                    vInnerStart, this.u1, vInnerEnd, this.br, th - this.bt - this.bb, 0);
+            // bottom border
+            GuiDraw.drawTiledTexture(pose, x + this.bl, y1 - this.bb, width - this.bl - this.br, this.bb, uInnerStart,
+                    vInnerEnd, uInnerEnd, this.v1, tw - this.bl - this.br, this.bb, 0);
+
+            // center
+            GuiDraw.drawTiledTexture(pose, x + this.bl, y + this.bt, width - this.bl - this.br,
+                    height - this.bt - this.bb, uInnerStart, vInnerStart, uInnerEnd, vInnerEnd,
+                    tw - this.bl - this.br, th - this.bt - this.bb, 0);
+        }
+        RenderSystem.disableBlend();
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        super.saveToJson(json);
+        if (json.entrySet().size() == 1) return true;
+        json.addProperty("imageWidth", this.imageWidth);
+        json.addProperty("imageHeight", this.imageHeight);
+        json.addProperty("bl", this.bl);
+        json.addProperty("br", this.br);
+        json.addProperty("bt", this.bt);
+        json.addProperty("bb", this.bb);
+        json.addProperty("tiled", this.tiled);
+        return true;
+    }
+
+    @Override
+    protected AdaptableUITexture copy() {
+        return new AdaptableUITexture(location, u0, v0, u1, v1, colorType, nonOpaque, imageWidth, imageHeight, bl, bt,
+                br, bb, tiled);
+    }
+
+    @Override
+    public AdaptableUITexture withColorOverride(int color) {
+        return (AdaptableUITexture) super.withColorOverride(color);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/BorderDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/BorderDrawable.java
new file mode 100644
index 00000000000..0dbaf0cd222
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/BorderDrawable.java
@@ -0,0 +1,44 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+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/api/mui/drawable/Circle.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Circle.java
new file mode 100644
index 00000000000..73f6a24acfe
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Circle.java
@@ -0,0 +1,94 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.animation.IAnimatable;
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonObject;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+@Accessors(fluent = true, chain = true)
+public class Circle implements IDrawable, IJsonSerializable<Circle>, IAnimatable<Circle> {
+
+    @Setter
+    private int colorInner, colorOuter, segments;
+
+    public Circle() {
+        this.colorInner = 0;
+        this.colorOuter = 0;
+        this.segments = 40;
+    }
+
+    public Circle setColorInner(int colorInner) {
+        return colorInner(colorInner);
+    }
+
+    public Circle setColorOuter(int colorOuter) {
+        return colorOuter(colorOuter);
+    }
+
+    public Circle setColor(int inner, int outer) {
+        return color(inner, outer);
+    }
+
+    public Circle setSegments(int segments) {
+        return segments(segments);
+    }
+
+    public Circle color(int inner, int outer) {
+        this.colorInner = inner;
+        this.colorOuter = outer;
+        return this;
+    }
+
+    public Circle color(int color) {
+        return color(color, color);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x0, int y0, int width, int height, WidgetTheme widgetTheme) {
+        applyColor(widgetTheme.getColor());
+        GuiDraw.drawEllipse(context.getGraphics(), x0, y0, width, height,
+                this.colorInner, this.colorOuter, this.segments);
+    }
+
+    @Override
+    public void loadFromJson(JsonObject json) {
+        this.colorInner = JsonHelper.getColor(json, Color.WHITE.main, "colorInner", "color");
+        this.colorOuter = JsonHelper.getColor(json, Color.WHITE.main, "colorOuter", "color");
+        this.segments = JsonHelper.getInt(json, 40, "segments");
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        json.addProperty("colorInner", this.colorInner);
+        json.addProperty("colorOuter", this.colorOuter);
+        json.addProperty("segments", this.segments);
+        return true;
+    }
+
+    @Override
+    public Circle interpolate(Circle start, Circle end, float t) {
+        this.colorInner = Color.lerp(start.colorInner, end.colorInner, t);
+        this.colorOuter = Color.lerp(start.colorOuter, end.colorOuter, t);
+        this.segments = Interpolations.lerp(start.segments, end.segments, t);
+        return this;
+    }
+
+    @Override
+    public Circle copyOrImmutable() {
+        return new Circle()
+                .setColor(this.colorInner, this.colorOuter)
+                .setSegments(this.segments);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/ColorType.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/ColorType.java
new file mode 100644
index 00000000000..865d312d993
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/ColorType.java
@@ -0,0 +1,36 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import lombok.Getter;
+
+import java.util.Map;
+import java.util.function.ToIntFunction;
+
+public class ColorType {
+
+    private static final Map<String, ColorType> COLOR_TYPES = new Object2ObjectOpenHashMap<>();
+
+    public static ColorType get(String name) {
+        return COLOR_TYPES.getOrDefault(name, DEFAULT);
+    }
+
+    public static final ColorType DEFAULT = new ColorType("default", WidgetTheme::getColor);
+    public static final ColorType TEXT = new ColorType("text", WidgetTheme::getTextColor);
+    public static final ColorType ICON = new ColorType("default", WidgetTheme::getIconColor);
+
+    @Getter
+    private final String name;
+    private final ToIntFunction<WidgetTheme> colorGetter;
+
+    public ColorType(String name, ToIntFunction<WidgetTheme> colorGetter) {
+        this.name = name;
+        this.colorGetter = colorGetter;
+        COLOR_TYPES.put(name, this);
+    }
+
+    public int getColor(WidgetTheme theme) {
+        return colorGetter.applyAsInt(theme);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DelegateDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DelegateDrawable.java
new file mode 100644
index 00000000000..d451834f7ed
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DelegateDrawable.java
@@ -0,0 +1,64 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class DelegateDrawable implements IDrawable {
+
+    @NotNull
+    private IDrawable drawable;
+
+    public DelegateDrawable(@Nullable IDrawable drawable) {
+        setDrawable(drawable);
+    }
+
+    // protected, so subclasses can define mutability
+    protected void setDrawable(@Nullable IDrawable drawable) {
+        this.drawable = drawable != null ? drawable : IDrawable.EMPTY;
+    }
+
+    @NotNull
+    public IDrawable getWrappedDrawable() {
+        return drawable;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        this.drawable.draw(context, x, y, width, height, widgetTheme);
+    }
+
+    @Override
+    public boolean canApplyTheme() {
+        return this.drawable.canApplyTheme();
+    }
+
+    @Override
+    public void applyColor(int themeColor) {
+        this.drawable.applyColor(themeColor);
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return this.drawable.getDefaultWidth();
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return this.drawable.getDefaultHeight();
+    }
+
+    @Override
+    public Widget<?> asWidget() {
+        return this.drawable.asWidget();
+    }
+
+    @Override
+    public Icon asIcon() {
+        return this.drawable.asIcon();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DelegateIcon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DelegateIcon.java
new file mode 100644
index 00000000000..fd8ac8e3827
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DelegateIcon.java
@@ -0,0 +1,61 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+public class DelegateIcon implements IIcon {
+
+    private IIcon icon;
+
+    public DelegateIcon(IIcon icon) {
+        this.icon = icon;
+    }
+
+    @Override
+    public int getWidth() {
+        return this.icon.getWidth();
+    }
+
+    @Override
+    public int getHeight() {
+        return this.icon.getHeight();
+    }
+
+    @Override
+    public Box getMargin() {
+        return this.icon.getMargin();
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        this.icon.draw(context, x, y, width, height, widgetTheme);
+    }
+
+    @Override
+    public IIcon getWrappedDrawable() {
+        return icon;
+    }
+
+    public IIcon getDelegate() {
+        return icon;
+    }
+
+    public IIcon findRootDelegate() {
+        IIcon icon = this;
+        while (icon instanceof DelegateIcon di) {
+            icon = di.getDelegate();
+        }
+        return icon;
+    }
+
+    protected void setDelegate(IIcon icon) {
+        this.icon = icon;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(" + this.icon + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DrawableSerialization.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DrawableSerialization.java
new file mode 100644
index 00000000000..63dad61c32f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DrawableSerialization.java
@@ -0,0 +1,224 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.utils.ObjectList;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+
+import com.google.gson.*;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Type;
+import java.util.Map;
+import java.util.function.Function;
+
+public class DrawableSerialization implements JsonSerializer<IDrawable>, JsonDeserializer<IDrawable> {
+
+    private static final Map<String, Function<JsonObject, ? extends IDrawable>> DRAWABLE_TYPES = new Object2ObjectOpenHashMap<>();
+    private static final Map<Class<? extends IDrawable>, String> REVERSE_DRAWABLE_TYPES = new Object2ObjectOpenHashMap<>();
+    private static final Map<String, UITexture> TEXTURES = new Object2ObjectOpenHashMap<>();
+    private static final Map<UITexture, String> REVERSE_TEXTURES = new Object2ObjectOpenHashMap<>();
+
+    public static void registerTexture(String s, UITexture texture) {
+        TEXTURES.put(s, texture);
+        REVERSE_TEXTURES.put(texture, s);
+    }
+
+    public static UITexture getTexture(String s) {
+        return TEXTURES.get(s);
+    }
+
+    public static String getTextureId(UITexture texture) {
+        return REVERSE_TEXTURES.get(texture);
+    }
+
+    public static <
+            T extends IDrawable & IJsonSerializable<T>> void registerDrawableType(String id, Class<T> type,
+                                                                                  Function<@NotNull JsonObject, ? extends @NotNull IDrawable> creator) {
+        if (DRAWABLE_TYPES.containsKey(id)) {
+            throw new IllegalArgumentException("Drawable type '" + id + "' already exists!");
+        }
+        DRAWABLE_TYPES.put(id, creator);
+        if (type != null) {
+            REVERSE_DRAWABLE_TYPES.put(type, id);
+        }
+    }
+
+    @ApiStatus.Internal
+    public static void init() {
+        // empty, none and text are special cases
+        registerDrawableType("texture", UITexture.class, UITexture::parseFromJson);
+        registerDrawableType("color", Rectangle.class, json -> new Rectangle());
+        registerDrawableType("rectangle", Rectangle.class, json -> new Rectangle());
+        registerDrawableType("ellipse", Circle.class, json -> new Circle());
+        registerDrawableType("item", ItemDrawable.class, ItemDrawable::ofJson);
+        registerDrawableType("icon", Icon.class, Icon::ofJson);
+        registerDrawableType("stack", DrawableStack.class, DrawableStack::parseJson);
+        registerDrawableType("scrollbar", Scrollbar.class, Scrollbar::ofJson);
+    }
+
+    public static IDrawable deserialize(JsonElement json) {
+        return JsonHelper.deserialize(json, IDrawable.class);
+    }
+
+    public static JsonElement serialize(IDrawable drawable) {
+        return JsonHelper.serialize(drawable);
+    }
+
+    @Override
+    public IDrawable deserialize(JsonElement element, Type typeOfT,
+                                 JsonDeserializationContext context) throws JsonParseException {
+        if (element.isJsonNull()) {
+            return IDrawable.EMPTY;
+        }
+        if (element.isJsonPrimitive()) {
+            if ("empty".equals(element.getAsString()) || "null".equals(element.getAsString())) {
+                return IDrawable.EMPTY;
+            }
+            if ("none".equals(element.getAsString())) {
+                return IDrawable.NONE;
+            }
+        }
+        if (element.isJsonArray()) {
+            return DrawableStack.parseJson(element.getAsJsonArray());
+        }
+        if (!element.isJsonObject()) {
+            GTCEu.LOGGER.throwing(new JsonParseException("Drawable json should be an object or an array."));
+            return IDrawable.EMPTY;
+        }
+        JsonObject json = element.getAsJsonObject();
+        if (json.entrySet().isEmpty()) {
+            return IDrawable.EMPTY;
+        }
+        String type = JsonHelper.getString(json, "empty", "type");
+        if ("text".equals(type)) {
+            IKey key = parseText(json);
+            key.loadFromJson(json);
+            return key;
+        }
+        if (!DRAWABLE_TYPES.containsKey(type)) {
+            GTCEu.LOGGER
+                    .throwing(new JsonParseException("Drawable type '" + type + "' is not json serializable!"));
+            return IDrawable.EMPTY;
+        }
+        IDrawable drawable = DRAWABLE_TYPES.get(type).apply(json);
+        ((IJsonSerializable<?>) drawable).loadFromJson(json);
+        return drawable;
+    }
+
+    @Override
+    public JsonElement serialize(IDrawable src, Type typeOfSrc, JsonSerializationContext context) {
+        if (src == IDrawable.EMPTY) return JsonNull.INSTANCE;
+        if (src == IDrawable.NONE) return new JsonPrimitive("none");
+        if (src instanceof DrawableStack drawableStack) {
+            JsonArray jsonArray = new JsonArray();
+            for (IDrawable drawable : drawableStack.getDrawables()) {
+                jsonArray.add(JsonHelper.serialize(drawable));
+            }
+            return jsonArray;
+        }
+        JsonObject json = new JsonObject();
+        if (src instanceof IKey key) {
+            json.addProperty("type", "text");
+            // TODO serialize text properly
+            json.addProperty("text", Component.Serializer.toJson(key.getFormatted()));
+        } else if (!(src instanceof IJsonSerializable<?> serializable)) {
+            throw new IllegalArgumentException("Can't serialize IDrawable which doesn't implement IJsonSerializable!");
+        } else {
+            Class<?> type = src.getClass();
+            String key = REVERSE_DRAWABLE_TYPES.get(type);
+            while (key == null && type != null && type != Object.class) {
+                type = type.getSuperclass();
+                key = REVERSE_DRAWABLE_TYPES.get(type);
+            }
+            if (key == null) {
+                GTCEu.LOGGER.error(
+                        "Serialization of drawable {} failed, because a key for the type could not be found!",
+                        src.getClass().getSimpleName());
+                return JsonNull.INSTANCE;
+            }
+            json.addProperty("type", key);
+            if (!serializable.saveToJson(json)) {
+                GTCEu.LOGGER.error("Serialization of drawable {} failed!", src.getClass().getSimpleName());
+            }
+        }
+        return json;
+    }
+
+    private static IKey parseText(JsonObject json) throws JsonParseException {
+        JsonParseException exception = new JsonParseException("Could not parse IKey from %s".formatted(json));
+        try {
+            MutableComponent component = Component.Serializer.fromJson(json);
+            if (component != null) {
+                return unpackSiblings(component);
+            }
+        } catch (JsonSyntaxException e) {
+            exception = e;
+        }
+        JsonElement element = JsonHelper.getJsonElement(json, "text", "string", "key");
+        if (element == null || element.isJsonNull()) {
+            return IKey.str("No text found!");
+        } else if (element.isJsonPrimitive()) {
+            String s = element.getAsString();
+            if (s.startsWith("translate:")) {
+                return IKey.lang(s.substring(10));
+            }
+            return JsonHelper.getBoolean(json, false, "lang", "translate") ? IKey.lang(s) : IKey.str(s);
+        } else if (element.isJsonArray()) {
+            ObjectList<IKey> strings = ObjectList.create();
+            for (JsonElement element1 : element.getAsJsonArray()) {
+                strings.add(parseText(element1));
+            }
+            strings.trim();
+            return IKey.comp(strings.elements());
+        }
+        throw exception;
+    }
+
+    private static IKey parseText(JsonElement element) throws JsonParseException {
+        JsonParseException exception = new JsonParseException("Could not parse IKey from %s".formatted(element));
+        try {
+            MutableComponent component = Component.Serializer.fromJson(element);
+            if (component != null) {
+                return IKey.lang(component);
+            }
+        } catch (JsonSyntaxException e) {
+            exception = e;
+        }
+        if (element.isJsonPrimitive()) {
+            String s = element.getAsString();
+            if (s.startsWith("translate:")) {
+                return IKey.lang(s.substring(10));
+            }
+            return IKey.str(s);
+        }
+        if (element.isJsonObject()) {
+            return parseText(element.getAsJsonObject());
+        }
+        throw exception;
+    }
+
+    private static IKey parseKeyFromJson(JsonObject json, Function<String, IKey> keyFunction) {
+        return keyFunction.apply(JsonHelper.getString(json, "No text found!", "text", "string", "key"));
+    }
+
+    private static IKey unpackSiblings(Component component) {
+        if (component.getSiblings().isEmpty()) {
+            return IKey.lang(component);
+        }
+        ObjectArrayList<IKey> siblings = new ObjectArrayList<>();
+        for (Component sibling : component.getSiblings()) {
+            siblings.add(unpackSiblings(sibling));
+        }
+        siblings.trim();
+        return IKey.comp(siblings.elements());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DrawableStack.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DrawableStack.java
new file mode 100644
index 00000000000..49aea3410a1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DrawableStack.java
@@ -0,0 +1,92 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A stack of {@link IDrawable} backed by an array which are drawn on top of each other.
+ */
+public class DrawableStack implements IDrawable, IJsonSerializable<DrawableStack> {
+
+    public static final IDrawable[] EMPTY_BACKGROUND = {};
+    public static final DrawableStack EMPTY = new DrawableStack(EMPTY_BACKGROUND);
+
+    @Getter
+    private final IDrawable[] drawables;
+
+    public DrawableStack(IDrawable... drawables) {
+        this.drawables = drawables == null || drawables.length == 0 ? EMPTY_BACKGROUND : drawables;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        for (IDrawable drawable : this.drawables) {
+            if (drawable != null) drawable.draw(context, x, y, width, height, widgetTheme);
+        }
+    }
+
+    @Override
+    public boolean canApplyTheme() {
+        for (IDrawable drawable : this.drawables) {
+            if (drawable != null && drawable.canApplyTheme()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static IDrawable parseJson(JsonObject json) {
+        JsonElement drawables = JsonHelper.getJsonElement(json, "drawables", "children");
+        if (drawables != null && drawables.isJsonArray()) {
+            return parseJson(drawables.getAsJsonArray());
+        }
+        GTCEu.LOGGER.throwing(
+                new JsonParseException("DrawableStack json should have an array named 'drawables' or 'children'."));
+        return IDrawable.EMPTY;
+    }
+
+    public static IDrawable parseJson(JsonArray drawables) {
+        List<IDrawable> list = new ArrayList<>();
+        for (JsonElement child : drawables) {
+            IDrawable drawable = JsonHelper.deserialize(child, IDrawable.class);
+            if (drawable != null) {
+                list.add(drawable);
+            }
+        }
+        if (list.isEmpty()) {
+            return IDrawable.EMPTY;
+        }
+        if (list.size() == 1) {
+            return list.get(0);
+        }
+        return new DrawableStack(list.toArray(IDrawable[]::new));
+    }
+
+    // this method should never be called, but the special casing code is copied here in case it does.
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        JsonArray jsonArray = new JsonArray();
+        for (IDrawable drawable : this.getDrawables()) {
+            jsonArray.add(JsonHelper.serialize(drawable));
+        }
+        json.add("drawables", jsonArray);
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DynamicDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DynamicDrawable.java
new file mode 100644
index 00000000000..147c2a72bcb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/DynamicDrawable.java
@@ -0,0 +1,47 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+
+import java.util.function.Supplier;
+
+/**
+ * Takes supplier of {@link IDrawable} and draws conditional drawable.
+ * Return value of the supplier should be deterministic per render frame,
+ * in order to apply {@link ITheme} to correct object.
+ */
+public class DynamicDrawable implements IDrawable {
+
+    @Getter
+    private final Supplier<IDrawable> supplier;
+
+    public DynamicDrawable(Supplier<IDrawable> supplier) {
+        this.supplier = supplier;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        IDrawable drawable = this.supplier.get();
+        if (drawable != null) {
+            drawable.draw(context, x, y, width, height, widgetTheme);
+        }
+    }
+
+    @Override
+    public boolean canApplyTheme() {
+        IDrawable drawable = this.supplier.get();
+        if (drawable != null) {
+            return drawable.canApplyTheme();
+        } else {
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/EntityDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/EntityDrawable.java
new file mode 100644
index 00000000000..7429c576112
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/EntityDrawable.java
@@ -0,0 +1,67 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.world.entity.Entity;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiConsumer;
+
+@Accessors(fluent = true, chain = true)
+public class EntityDrawable<T extends Entity> implements IDrawable {
+
+    @Getter
+    protected final T entity;
+    @Setter
+    protected @Nullable BiConsumer<GuiGraphics, T> preDraw;
+    @Setter
+    protected @Nullable BiConsumer<GuiGraphics, T> postDraw;
+
+    @Setter
+    private boolean followMouse;
+    private float lookTargetX = 0.0f;
+    private float lookTargetY = 0.0f;
+
+    public EntityDrawable(T entity) {
+        this(entity, null, null);
+    }
+
+    public EntityDrawable(T entity, @Nullable BiConsumer<GuiGraphics, T> preDraw,
+                          @Nullable BiConsumer<GuiGraphics, T> postDraw) {
+        this.entity = entity;
+        this.preDraw = preDraw;
+        this.postDraw = postDraw;
+    }
+
+    public EntityDrawable<T> followMouse() {
+        return followMouse(true);
+    }
+
+    public EntityDrawable<T> lookTowardAngle(float xAngle, float yAngle) {
+        this.followMouse = false;
+        this.lookTargetX = xAngle;
+        this.lookTargetY = yAngle;
+
+        return this;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        if (this.followMouse) {
+            GuiDraw.drawEntityLookingAtMouse(context.getGraphics(), this.entity, x, y, width, height,
+                    context.getCurrentDrawingZ(), context.getMouseX(), context.getMouseY(),
+                    this.preDraw, this.postDraw);
+        } else {
+            GuiDraw.drawEntityLookingAtAngle(context.getGraphics(), this.entity, x, y, width, height,
+                    context.getCurrentDrawingZ(), this.lookTargetX, this.lookTargetY,
+                    this.preDraw, this.postDraw);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/FlowDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/FlowDrawable.java
new file mode 100644
index 00000000000..6940afde4d6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/FlowDrawable.java
@@ -0,0 +1,199 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+
+public class FlowDrawable implements IDrawable {
+
+    public static FlowDrawable row() {
+        return new FlowDrawable(GuiAxis.X);
+    }
+
+    public static FlowDrawable column() {
+        return new FlowDrawable(GuiAxis.Y);
+    }
+
+    @Getter
+    private final GuiAxis axis;
+    @Getter
+    private final List<IIcon> icons = new ArrayList<>();
+    private Alignment.MainAxis mainAxisAlignment = Alignment.MainAxis.START;
+    private Alignment.CrossAxis crossAxisAlignment = Alignment.CrossAxis.CENTER;
+
+    public FlowDrawable(GuiAxis axis) {
+        this.axis = axis;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        if (this.icons.isEmpty()) return;
+        if (this.icons.size() == 1) {
+            this.icons.get(0).draw(context, x, y, width, height, widgetTheme);
+            return;
+        }
+
+        GuiAxis otherAxis = this.axis.getOther();
+        int size = this.axis.isHorizontal() ? width : height;
+        int crossSize = this.axis.isHorizontal() ? height : width;
+        int pos = this.axis.isHorizontal() ? x : y;
+        int amount = this.icons.size();
+        int childrenSize = 0;
+        int expandedAmount = 0;
+        int space = 0; // child margin
+
+        for (IIcon icon : this.icons) {
+            int s = icon.getSize(this.axis);
+            if (s <= 0) {
+                expandedAmount++;
+            } else {
+                childrenSize += s;
+            }
+        }
+        Alignment.MainAxis maa = this.mainAxisAlignment;
+        if (maa == Alignment.MainAxis.SPACE_BETWEEN || maa == Alignment.MainAxis.SPACE_AROUND) {
+            if (expandedAmount > 0) {
+                maa = Alignment.MainAxis.START;
+            } else {
+                space = 0;
+            }
+        }
+        final int spaceCount = Math.max(amount - 1, 0);
+        childrenSize += spaceCount * space;
+
+        int lastP = pos;
+        if (maa == Alignment.MainAxis.CENTER) {
+            lastP += (int) (size / 2f - childrenSize / 2f);
+        } else if (maa == Alignment.MainAxis.END) {
+            lastP += size - childrenSize;
+        }
+
+        int expanderSize = (size - childrenSize) / expandedAmount;
+        int is, ics, ip, icp; // s = size, p = pos, c = cross
+        for (IIcon icon : this.icons) {
+            Box margin = icon.getMargin();
+            int s = icon.getSize(this.axis);
+            int cs = icon.getSize(otherAxis);
+            is = s;
+            ics = cs;
+            ip = lastP;
+            icp = 0;
+            if (s <= 0) {
+                is = expanderSize;
+                if (margin != null) ip += margin.getStart(this.axis);
+            }
+            if (cs <= 0) {
+                ics = crossSize;
+                if (margin != null) {
+                    ics -= margin.getTotal(otherAxis);
+                    icp = margin.getStart(otherAxis);
+                }
+            } else {
+                if (this.crossAxisAlignment == Alignment.CrossAxis.CENTER) {
+                    icp = (crossSize - cs) / 2;
+                } else if (this.crossAxisAlignment == Alignment.CrossAxis.END) {
+                    icp = crossSize - cs;
+                }
+            }
+            if (this.axis.isHorizontal()) {
+                icon.draw(context, ip, icp, is, ics, widgetTheme);
+            } else {
+                icon.draw(context, icp, ip, ics, is, widgetTheme);
+            }
+            lastP += is;
+
+            if (maa == Alignment.MainAxis.SPACE_BETWEEN) {
+                lastP += (size - childrenSize) / spaceCount;
+            }
+        }
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return this.axis.isHorizontal() ? getMainAxisDefaultSize() : getCrossAxisDefaultSize();
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return this.axis.isHorizontal() ? getCrossAxisDefaultSize() : getMainAxisDefaultSize();
+    }
+
+    public int getMainAxisDefaultSize() {
+        int s = 0;
+        for (IIcon icon : this.icons) {
+            int is = icon.getSize(this.axis);
+            if (is <= 0) is = this.axis.isHorizontal() ? icon.getDefaultWidth() : icon.getDefaultHeight();
+            if (is <= 0) is = 10;
+            s += is + icon.getMargin().getTotal(this.axis);
+        }
+        return s;
+    }
+
+    public int getCrossAxisDefaultSize() {
+        int s = 0;
+        GuiAxis axis = this.axis.getOther();
+        for (IIcon icon : this.icons) {
+            int is = icon.getSize(axis);
+            if (is <= 0) is = axis.isHorizontal() ? icon.getDefaultWidth() : icon.getDefaultHeight();
+            if (is <= 0) is = 10;
+            s += is + icon.getMargin().getTotal(axis);
+        }
+        return s;
+    }
+
+    public FlowDrawable mainAxisAlignment(Alignment.MainAxis maa) {
+        this.mainAxisAlignment = maa;
+        return this;
+    }
+
+    public FlowDrawable crossAxisAlignment(Alignment.CrossAxis caa) {
+        this.crossAxisAlignment = caa;
+        return this;
+    }
+
+    public FlowDrawable icon(IIcon icon) {
+        this.icons.add(icon);
+        return this;
+    }
+
+    public FlowDrawable icons(int amount, IntFunction<IIcon> func) {
+        for (int i = 0; i < amount; i++) {
+            icon(func.apply(i));
+        }
+        return this;
+    }
+
+    public <T> FlowDrawable icons(Iterable<T> it, Function<T, IIcon> func) {
+        for (T t : it) {
+            icon(func.apply(t));
+        }
+        return this;
+    }
+
+    public FlowDrawable icons(Collection<IIcon> icons) {
+        this.icons.addAll(icons);
+        return this;
+    }
+
+    public FlowDrawable removeIcon(IIcon icon) {
+        this.icons.remove(icon);
+        return this;
+    }
+
+    public FlowDrawable removeAll() {
+        this.icons.clear();
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/FluidDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/FluidDrawable.java
new file mode 100644
index 00000000000..0052a92052b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/FluidDrawable.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+public class FluidDrawable implements IDrawable {
+
+    private FluidStack fluid = null;
+
+    public FluidDrawable() {}
+
+    /**
+     * Takes a fluid stack, it can be null but will not draw anything
+     *
+     * @param fluid - fluid stack to draw
+     */
+    public FluidDrawable(@NotNull FluidStack fluid) {
+        setFluid(fluid);
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        GuiDraw.drawFluidTexture(context.getGraphics(), fluid, x, y, width, height, context.getCurrentDrawingZ());
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return 16;
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return 16;
+    }
+
+    @Override
+    public Widget<?> asWidget() {
+        return IDrawable.super.asWidget().size(16);
+    }
+
+    public FluidDrawable setFluid(FluidStack fluid) {
+        this.fluid = fluid;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/GuiDraw.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/GuiDraw.java
new file mode 100644
index 00000000000..dd516c1a558
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/GuiDraw.java
@@ -0,0 +1,1090 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.RectangleF;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.GuiSpriteManager;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.event.RichTooltipEvent;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.client.renderer.GTRenderTypes;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRenderDispatcher;
+import net.minecraft.client.renderer.texture.MissingTextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+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.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.inventory.InventoryMenu;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.client.event.RenderTooltipEvent;
+import net.minecraftforge.client.extensions.common.IClientFluidTypeExtensions;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4d;
+import org.joml.Matrix4f;
+import org.joml.Quaternionf;
+import org.joml.Vector3d;
+
+import java.util.List;
+import java.util.function.BiConsumer;
+
+import static com.gregtechceu.gtceu.api.mui.drawable.UITexture.GUI_TEXTURE_ID_CONVERTER;
+import static net.minecraft.util.Mth.HALF_PI;
+import static net.minecraft.util.Mth.TWO_PI;
+
+public class GuiDraw {
+
+    private static final TextRenderer textRenderer = new TextRenderer();
+
+    public static void drawRect(GuiGraphics graphics, float x0, float y0, float w, float h, int color) {
+        Matrix4f pose = graphics.pose().last().pose();
+        VertexConsumer builder = graphics.bufferSource().getBuffer(RenderType.guiOverlay());
+        drawRectRaw(builder, pose, x0, y0, x0 + w, y0 + h, color);
+    }
+
+    public static void drawHorizontalGradientRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                                  int colorLeft, int colorRight) {
+        drawRect(graphics, x0, y0, w, h, colorLeft, colorRight, colorLeft, colorRight);
+    }
+
+    public static void drawVerticalGradientRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                                int colorTop, int colorBottom) {
+        drawRect(graphics, x0, y0, w, h, colorTop, colorTop, colorBottom, colorBottom);
+    }
+
+    public static void drawRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                int colorTL, int colorTR, int colorBL, int colorBR) {
+        Matrix4f pose = graphics.pose().last().pose();
+        VertexConsumer bufferbuilder = graphics.bufferSource().getBuffer(RenderType.guiOverlay());
+
+        float x1 = x0 + w, y1 = y0 + h;
+        bufferbuilder.vertex(pose, x0, y0, 0.0f)
+                .color(Color.getRed(colorTL), Color.getGreen(colorTL), Color.getBlue(colorTL), Color.getAlpha(colorTL))
+                .endVertex();
+        bufferbuilder.vertex(pose, x0, y1, 0.0f)
+                .color(Color.getRed(colorBL), Color.getGreen(colorBL), Color.getBlue(colorBL), Color.getAlpha(colorBL))
+                .endVertex();
+        bufferbuilder.vertex(pose, x1, y1, 0.0f)
+                .color(Color.getRed(colorBR), Color.getGreen(colorBR), Color.getBlue(colorBR), Color.getAlpha(colorBR))
+                .endVertex();
+        bufferbuilder.vertex(pose, x1, y0, 0.0f)
+                .color(Color.getRed(colorTR), Color.getGreen(colorTR), Color.getBlue(colorTR), Color.getAlpha(colorTR))
+                .endVertex();
+    }
+
+    public static void drawRectRaw(VertexConsumer buffer, Matrix4f pose, float x0, float y0, float x1, float y1,
+                                   int color) {
+        int r = Color.getRed(color);
+        int g = Color.getGreen(color);
+        int b = Color.getBlue(color);
+        int a = Color.getAlpha(color);
+        drawRectRaw(buffer, pose, x0, y0, x1, y1, r, g, b, a);
+    }
+
+    public static void drawRectRaw(VertexConsumer buffer, Matrix4f pose, float x0, float y0, float x1, float y1, int r,
+                                   int g, int b, int a) {
+        buffer.vertex(pose, x0, y0, 0.0f).color(r, g, b, a).endVertex();
+        buffer.vertex(pose, x0, y1, 0.0f).color(r, g, b, a).endVertex();
+        buffer.vertex(pose, x1, y1, 0.0f).color(r, g, b, a).endVertex();
+        buffer.vertex(pose, x1, y0, 0.0f).color(r, g, b, a).endVertex();
+    }
+
+    public static void drawCircle(GuiGraphics graphics, float x0, float y0, float diameter, int color, int segments) {
+        drawEllipse(graphics, x0, y0, diameter, diameter, color, color, segments);
+    }
+
+    public static void drawCircle(GuiGraphics graphics, float x0, float y0, float diameter,
+                                  int centerColor, int outerColor, int segments) {
+        drawEllipse(graphics, x0, y0, diameter, diameter, centerColor, outerColor, segments);
+    }
+
+    public static void drawEllipse(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                   int color, int segments) {
+        drawEllipse(graphics, x0, y0, w, h, color, color, segments);
+    }
+
+    public static void drawEllipse(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                   int centerColor, int outerColor, int segments) {
+        Matrix4f pose = graphics.pose().last().pose();
+        VertexConsumer bufferbuilder = graphics.bufferSource().getBuffer(GTRenderTypes.guiOverlayTriangleFan());
+
+        float x_2 = x0 + w / 2f, y_2 = y0 + h / 2f;
+        // start at center
+        bufferbuilder.vertex(pose, x_2, y_2, 0.0f)
+                .color(Color.getRed(centerColor), Color.getGreen(centerColor), Color.getBlue(centerColor),
+                        Color.getAlpha(centerColor))
+                .endVertex();
+        int a = Color.getAlpha(outerColor), r = Color.getRed(outerColor), g = Color.getGreen(outerColor),
+                b = Color.getBlue(outerColor);
+        float incr = TWO_PI / segments;
+        for (int i = 0; i <= segments; i++) {
+            float angle = incr * i;
+            float x = Mth.sin(angle) * (w / 2) + x_2;
+            float y = Mth.cos(angle) * (h / 2) + y_2;
+            bufferbuilder.vertex(x, y, 0.0f).color(r, g, b, a).endVertex();
+        }
+        RenderSystem.disableBlend();
+    }
+
+    public static void drawRoundedRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                       int color, int cornerRadius, int segments) {
+        drawRoundedRect(graphics, x0, y0, w, h, color, color, color, color, cornerRadius, segments);
+    }
+
+    public static void drawVerticalGradientRoundedRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                                       int colorTop, int colorBottom, int cornerRadius, int segments) {
+        drawRoundedRect(graphics, x0, y0, w, h, colorTop, colorTop, colorBottom, colorBottom, cornerRadius, segments);
+    }
+
+    public static void drawHorizontalGradientRoundedRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                                         int colorLeft, int colorRight,
+                                                         int cornerRadius, int segments) {
+        drawRoundedRect(graphics, x0, y0, w, h, colorLeft, colorRight, colorLeft, colorRight, cornerRadius, segments);
+    }
+
+    public static void drawRoundedRect(GuiGraphics graphics, float x0, float y0, float w, float h,
+                                       int colorTL, int colorTR, int colorBL, int colorBR,
+                                       int cornerRadius, int segments) {
+        Matrix4f pose = graphics.pose().last().pose();
+        VertexConsumer bufferbuilder = graphics.bufferSource().getBuffer(GTRenderTypes.guiOverlayTriangleFan());
+
+        float x1 = x0 + w, y1 = y0 + h;
+        int color = Color.average(colorBL, colorBR, colorTR, colorTL);
+        // start at center
+        bufferbuilder.vertex(pose, x0 + w / 2f, y0 + h / 2f, 0.0f)
+                .color(Color.getRed(color), Color.getGreen(color), Color.getBlue(color), Color.getAlpha(color))
+                .endVertex();
+        // left side
+        bufferbuilder.vertex(pose, x0, y0 + cornerRadius, 0.0f)
+                .color(Color.getRed(colorTL), Color.getGreen(colorTL), Color.getBlue(colorTL), Color.getAlpha(colorTL))
+                .endVertex();
+        bufferbuilder.vertex(pose, x0, y1 - cornerRadius, 0.0f)
+                .color(Color.getRed(colorBL), Color.getGreen(colorBL), Color.getBlue(colorBL), Color.getAlpha(colorBL))
+                .endVertex();
+        // bottom left corner
+        for (int i = 1; i <= segments; i++) {
+            float x = x0 + cornerRadius - Mth.cos(HALF_PI / segments * i) * cornerRadius;
+            float y = y1 - cornerRadius + Mth.sin(HALF_PI / segments * i) * cornerRadius;
+            bufferbuilder.vertex(pose, x, y, 0.0f)
+                    .color(Color.getRed(colorBL), Color.getGreen(colorBL), Color.getBlue(colorBL),
+                            Color.getAlpha(colorBL))
+                    .endVertex();
+        }
+        // bottom side
+        bufferbuilder.vertex(pose, x1 - cornerRadius, y1, 0.0f)
+                .color(Color.getRed(colorBR), Color.getGreen(colorBR), Color.getBlue(colorBR), Color.getAlpha(colorBR))
+                .endVertex();
+        // bottom right corner
+        for (int i = 1; i <= segments; i++) {
+            float x = x1 - cornerRadius + Mth.sin(HALF_PI / segments * i) * cornerRadius;
+            float y = y1 - cornerRadius + Mth.cos(HALF_PI / segments * i) * cornerRadius;
+            bufferbuilder.vertex(pose, x, y, 0.0f)
+                    .color(Color.getRed(colorBR), Color.getGreen(colorBR), Color.getBlue(colorBR),
+                            Color.getAlpha(colorBR))
+                    .endVertex();
+        }
+        // right side
+        bufferbuilder.vertex(pose, x1, y0 + cornerRadius, 0.0f)
+                .color(Color.getRed(colorTR), Color.getGreen(colorTR), Color.getBlue(colorTR), Color.getAlpha(colorTR))
+                .endVertex();
+        // top right corner
+        for (int i = 1; i <= segments; i++) {
+            float x = x1 - cornerRadius + Mth.cos(HALF_PI / segments * i) * cornerRadius;
+            float y = y0 + cornerRadius - Mth.sin(HALF_PI / segments * i) * cornerRadius;
+            bufferbuilder.vertex(pose, x, y, 0.0f)
+                    .color(Color.getRed(colorTR), Color.getGreen(colorTR), Color.getBlue(colorTR),
+                            Color.getAlpha(colorTR))
+                    .endVertex();
+        }
+        // top side
+        bufferbuilder.vertex(pose, x0 + cornerRadius, y0, 0.0f)
+                .color(Color.getRed(colorTL), Color.getGreen(colorTL), Color.getBlue(colorTL), Color.getAlpha(colorTL))
+                .endVertex();
+        // top left corner
+        for (int i = 1; i <= segments; i++) {
+            float x = x0 + cornerRadius - Mth.sin(HALF_PI / segments * i) * cornerRadius;
+            float y = y0 + cornerRadius - Mth.cos(HALF_PI / segments * i) * cornerRadius;
+            bufferbuilder.vertex(pose, x, y, 0.0f)
+                    .color(Color.getRed(colorTL), Color.getGreen(colorTL), Color.getBlue(colorTL),
+                            Color.getAlpha(colorTL))
+                    .endVertex();
+        }
+        bufferbuilder.vertex(pose, x0, y0 + cornerRadius, 0.0f)
+                .color(Color.getRed(colorTL), Color.getGreen(colorTL), Color.getBlue(colorTL), Color.getAlpha(colorTL))
+                .endVertex();
+    }
+
+    /**
+     * Set up the texture as a sampler differently depending on if it's part of the GUI atlas or not.
+     * <p>
+     * If the texture is part of the GUI atlas, the atlas will be used for drawing and the UV coordinates will be scaled
+     * to the atlas texture.<br>
+     * If it's not part of the GUI atlas, nothing special is done.
+     *
+     * @param location the texture <i>file's</i> location, e.g. {@code "modularui:textures/gui/slot/item.png"}
+     * @param u0       u0 UV coordinate
+     * @param v0       v0 UV coordinate
+     * @param u1       u1 UV coordinate
+     * @param v1       v1 UV coordinate
+     * @return If texture is in the GUI atlas, rescaled UV coordinates {@code u0, v0, u1, v1}.<br>
+     *         If not, the same coordinates that were passed in.
+     */
+    public static RectangleF setupTexture(ResourceLocation location, float u0, float v0, float u1, float v1) {
+        TextureAtlasSprite sprite = GuiSpriteManager.getInstance()
+                .getSprite(GUI_TEXTURE_ID_CONVERTER.fileToId(location));
+
+        // check if the atlas doesn't have this sprite, default to using the resloc as is if so
+        if (!sprite.contents().name().equals(MissingTextureAtlasSprite.getLocation())) {
+            RenderSystem.setShaderTexture(0, sprite.atlasLocation());
+
+            // have to multiply by 16 here because of MC weirdness
+            // REMOVE THE MULTIPLICATION IN 1.21!!!
+            return new RectangleF(sprite.getU(u0 * 16), sprite.getV(v0 * 16), sprite.getU(u1 * 16),
+                    sprite.getV(v1 * 16));
+        } else {
+            RenderSystem.setShaderTexture(0, location);
+            return new RectangleF(u0, v0, u1, v1);
+        }
+    }
+
+    public static boolean isGuiAtlasSprite(ResourceLocation location) {
+        location = GUI_TEXTURE_ID_CONVERTER.fileToId(location);
+        return GuiSpriteManager.getInstance().getSprite(location).atlasLocation() !=
+                MissingTextureAtlasSprite.getLocation();
+    }
+
+    public static void drawTexture(Matrix4f pose, ResourceLocation location, float x, float y, float w, float h,
+                                   int u, int v, int textureWidth, int textureHeight) {
+        if (!isGuiAtlasSprite(location)) {
+            RenderSystem.setShaderTexture(0, location);
+            drawTexture(pose, x, y, u, v, w, h, textureWidth, textureHeight);
+            return;
+        }
+
+        float tw = 1F / textureWidth;
+        float th = 1F / textureHeight;
+        RectangleF newUvs = setupTexture(location, u * tw, v * th, (u + w) * tw, (v + h) * th);
+        drawTexture(pose, x, y, x + w, y + h, newUvs.u0(), newUvs.v0(), newUvs.u1(), newUvs.v1());
+    }
+
+    public static void drawTexture(Matrix4f pose, float x, float y, int u, int v, float w, float h,
+                                   int textureW, int textureH) {
+        drawTexture(pose, x, y, u, v, w, h, textureW, textureH, 0);
+    }
+
+    /**
+     * Draw a textured quad with given UV, dimensions and custom texture size
+     */
+    public static void drawTexture(Matrix4f pose, float x, float y, int u, int v, float w, float h,
+                                   int textureW, int textureH, float z) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
+        drawTexture(pose, buffer, x, y, u, v, w, h, textureW, textureH, z);
+        tesselator.end();
+    }
+
+    public static void drawTexture(Matrix4f pose, VertexConsumer buffer, float x, float y, int u, int v,
+                                   float w, float h, int textureW, int textureH, float z) {
+        float tw = 1F / textureW;
+        float th = 1F / textureH;
+
+        buffer.vertex(pose, x, y + h, z).uv(u * tw, (v + h) * th).endVertex();
+        buffer.vertex(pose, x + w, y + h, z).uv((u + w) * tw, (v + h) * th).endVertex();
+        buffer.vertex(pose, x + w, y, z).uv((u + w) * tw, v * th).endVertex();
+        buffer.vertex(pose, x, y, z).uv(u * tw, v * th).endVertex();
+    }
+
+    public static void drawTexture(Matrix4f pose, float x, float y, int u, int v, float w, float h,
+                                   int textureW, int textureH, int tu, int tv) {
+        drawTexture(pose, x, y, u, v, w, h, textureW, textureH, tu, tv, 0);
+    }
+
+    /**
+     * Draw a textured quad with given UV, dimensions and custom texture size
+     */
+    public static void drawTexture(Matrix4f pose, float x, float y, int u, int v, float w, float h,
+                                   int textureW, int textureH, int tu, int tv, float z) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
+        drawTexture(pose, buffer, x, y, u, v, w, h, textureW, textureH, tu, tv, z);
+        tesselator.end();
+    }
+
+    public static void drawTexture(Matrix4f pose, VertexConsumer buffer, float x, float y, int u, int v,
+                                   float w, float h, int textureW, int textureH, int tu, int tv, float z) {
+        float tw = 1F / textureW;
+        float th = 1F / textureH;
+
+        buffer.vertex(pose, x, y + h, z).uv(u * tw, tv * th).endVertex();
+        buffer.vertex(pose, x + w, y + h, z).uv(tu * tw, tv * th).endVertex();
+        buffer.vertex(pose, x + w, y, z).uv(tu * tw, v * th).endVertex();
+        buffer.vertex(pose, x, y, z).uv(u * tw, v * th).endVertex();
+    }
+
+    public static void drawTexture(Matrix4f pose, ResourceLocation location, float x0, float y0, float x1, float y1,
+                                   float u0, float v0, float u1, float v1) {
+        drawTexture(pose, location, x0, y0, x1, y1, u0, v0, u1, v1, false);
+    }
+
+    public static void drawTexture(Matrix4f pose, ResourceLocation location, float x0, float y0, float x1, float y1,
+                                   float u0, float v0, float u1, float v1, boolean withBlend) {
+        RectangleF newUvs = setupTexture(location, u0, v0, u1, v1);
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        if (withBlend) {
+            RenderSystem.enableBlend();
+        } else {
+            RenderSystem.disableBlend();
+        }
+        drawTexture(pose, x0, y0, x1, y1, newUvs.u0(), newUvs.v0(), newUvs.u1(), newUvs.v1(), 0);
+    }
+
+    public static void drawTexture(Matrix4f pose, float x0, float y0, float x1, float y1,
+                                   float u0, float v0, float u1, float v1) {
+        drawTexture(pose, x0, y0, x1, y1, u0, v0, u1, v1, 0);
+    }
+
+    public static void drawTexture(Matrix4f pose, float x0, float y0, float x1, float y1,
+                                   float u0, float v0, float u1, float v1, float z) {
+        RenderSystem.disableDepthTest();
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
+        drawTexture(pose, buffer, x0, y0, x1, y1, u0, v0, u1, v1, z);
+        tesselator.end();
+    }
+
+    public static void drawTexture(Matrix4f pose, VertexConsumer buffer, float x0, float y0, float x1, float y1,
+                                   float u0, float v0, float u1, float v1, float z) {
+        buffer.vertex(pose, x0, y1, z).uv(u0, v1).endVertex();
+        buffer.vertex(pose, x1, y1, z).uv(u1, v1).endVertex();
+        buffer.vertex(pose, x1, y0, z).uv(u1, v0).endVertex();
+        buffer.vertex(pose, x0, y0, z).uv(u0, v0).endVertex();
+    }
+
+    public static void drawTiledTexture(Matrix4f pose, ResourceLocation location, float x, float y, float w, float h,
+                                        int u, int v, int tileWidth, int tileHeight, int textureWidth,
+                                        int textureHeight, float z) {
+        if (!isGuiAtlasSprite(location)) {
+            RenderSystem.setShaderTexture(0, location);
+            drawTiledTexture(pose, x, y, w, h, u, v, tileWidth, tileHeight, textureWidth, textureHeight, z);
+            return;
+        }
+
+        float wRatio = 1f / textureWidth;
+        float hRatio = 1f / textureHeight;
+        RectangleF newUvs = setupTexture(location, u * wRatio, v * hRatio, (u + w) * wRatio, (v + h) * hRatio);
+        drawTiledTexture(pose, x, y, x + w, y + h, newUvs.u0(), newUvs.v0(),
+                newUvs.u1(), newUvs.v1(), tileWidth, tileHeight, z);
+    }
+
+    public static void drawTiledTexture(Matrix4f pose, float x, float y, float w, float h,
+                                        int u, int v, int tileW, int tileH, int tw, int th, float z) {
+        int countX = (((int) w - 1) / tileW) + 1;
+        int countY = (((int) h - 1) / tileH) + 1;
+        float fillerX = w - (countX - 1) * tileW;
+        float fillerY = h - (countY - 1) * tileH;
+
+        RenderSystem.disableDepthTest();
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
+
+        for (int i = 0, c = countX * countY; i < c; i++) {
+            int ix = i % countX;
+            int iy = i / countX;
+            float xx = x + ix * tileW;
+            float yy = y + iy * tileH;
+            float xw = ix == countX - 1 ? fillerX : tileW;
+            float yh = iy == countY - 1 ? fillerY : tileH;
+
+            drawTexture(pose, buffer, xx, yy, u, v, xw, yh, tw, th, z);
+        }
+    }
+
+    public static void drawTiledTexture(Matrix4f pose, ResourceLocation location, float x, float y, float w, float h,
+                                        float u0, float v0, float u1, float v1,
+                                        int textureWidth, int textureHeight, float z) {
+        RenderSystem.enableBlend();
+        RectangleF newUvs = setupTexture(location, u0, v0, u1, v1);
+        drawTiledTexture(pose, x, y, w, h, newUvs.u0(), newUvs.v0(), newUvs.u1(), newUvs.v1(), textureWidth,
+                textureHeight, z);
+        RenderSystem.disableBlend();
+    }
+
+    public static void drawTiledTexture(Matrix4f pose, float x, float y, float w, float h,
+                                        float u0, float v0, float u1, float v1,
+                                        int tileWidth, int tileHeight, float z) {
+        int countX = (((int) w - 1) / tileWidth) + 1;
+        int countY = (((int) h - 1) / tileHeight) + 1;
+        float fillerX = w - (countX - 1) * tileWidth;
+        float fillerY = h - (countY - 1) * tileHeight;
+        float fillerU = u0 + (u1 - u0) * fillerX / tileWidth;
+        float fillerV = v0 + (v1 - v0) * fillerY / tileHeight;
+
+        RenderSystem.disableDepthTest();
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
+
+        for (int i = 0, c = countX * countY; i < c; i++) {
+            int ix = i % countX;
+            int iy = i / countX;
+            float xx = x + ix * tileWidth;
+            float yy = y + iy * tileHeight;
+            float xw = tileWidth, yh = tileHeight, uEnd = u1, vEnd = v1;
+            if (ix == countX - 1) {
+                xw = fillerX;
+                uEnd = fillerU;
+            }
+            if (iy == countY - 1) {
+                yh = fillerY;
+                vEnd = fillerV;
+            }
+
+            drawTexture(pose, buffer, xx, yy, xx + xw, yy + yh, u0, v0, uEnd, vEnd, z);
+        }
+
+        tesselator.end();
+    }
+
+    /**
+     * Draws an entity. Note that this does NOT do any necessary setup for rendering the entity. Please see
+     * {@link #drawEntity(GuiGraphics, Entity, float, float, float, float, float, BiConsumer, BiConsumer)} for a full
+     * draw method.
+     *
+     * @param graphics the current {@link GuiGraphics} instance.
+     * @param entity   entity to draw.
+     * @see #drawEntity(GuiGraphics, Entity, float, float, float, float, float, BiConsumer, BiConsumer)
+     */
+    public static void drawEntityRaw(GuiGraphics graphics, Entity entity) {
+        EntityRenderDispatcher entityRenderer = Minecraft.getInstance().getEntityRenderDispatcher();
+        entityRenderer.setRenderShadow(false);
+
+        RenderSystem.runAsFancy(() -> {
+            entityRenderer.render(entity, 0.0D, 0.0D, 0.0D, 0.0f, Minecraft.getInstance().getPartialTick(),
+                    graphics.pose(), graphics.bufferSource(), LightTexture.FULL_BRIGHT);
+        });
+        graphics.flush();
+        entityRenderer.setRenderShadow(true);
+    }
+
+    /**
+     * A simple method to a draw an entity in a GUI. Using the consumers is not always ideal to modify and restore
+     * entity state. In those cases just copy and paste this method and put your code where the consumers would be
+     * called. The entity will be scaled so that it fits right in the given size when untransformed (default). When
+     * transforming during pre draw, you may need to manually correct the scale and offset.
+     *
+     * @param graphics the current {@link GuiGraphics} instance.
+     * @param entity   entity to draw
+     * @param x        x pos
+     * @param y        y pos
+     * @param w        the width of the area where the entity should be drawn
+     * @param h        the height of the area where the entity should be drawn
+     * @param z        the z layer ({@link GuiContext#getCurrentDrawingZ()} if drawn in a MUI screen)
+     * @param preDraw  a function to call before rendering. Transform or modify the entity here.
+     * @param postDraw a function to call after rendering. Restore old entity state here if needed.
+     * @param <T>      type of the entity to render
+     */
+    public static <T extends Entity> void drawEntity(GuiGraphics graphics, T entity,
+                                                     float x, float y, float w, float h, float z,
+                                                     @Nullable BiConsumer<GuiGraphics, T> preDraw,
+                                                     @Nullable BiConsumer<GuiGraphics, T> postDraw) {
+        graphics.pose().pushPose();
+        setupDrawEntity(graphics, entity, x, y, w, h, z);
+        if (preDraw != null) preDraw.accept(graphics, entity);
+        drawEntityRaw(graphics, entity);
+        if (postDraw != null) postDraw.accept(graphics, entity);
+        endDrawEntity();
+        graphics.pose().popPose();
+    }
+
+    /**
+     * Draws an entity which looks in the direction of the mouse like the player render in the player inventory does.
+     * The code was copied from
+     * {@link net.minecraft.client.gui.screens.inventory.InventoryScreen#renderEntityInInventoryFollowsMouse(GuiGraphics, int, int, int, float, float, LivingEntity)
+     * InventoryScreen.renderEntityInInventoryFollowsMouse}.
+     *
+     * @param graphics the current {@link GuiGraphics} instance.
+     * @param entity   entity to draw
+     * @param x        x pos
+     * @param y        y pos
+     * @param w        the width of the area where the entity should be drawn
+     * @param h        the height of the area where the entity should be drawn
+     * @param z        the z layer ({@link GuiContext#getCurrentDrawingZ()} if drawn in a MUI screen)
+     * @param mouseX   current x pos of the mouse
+     * @param mouseY   current y pos of the mouse
+     */
+    public static <T extends Entity> void drawEntityLookingAtMouse(GuiGraphics graphics, T entity,
+                                                                   float x, float y, float w, float h, float z,
+                                                                   int mouseX, int mouseY,
+                                                                   @Nullable BiConsumer<GuiGraphics, T> preDraw,
+                                                                   @Nullable BiConsumer<GuiGraphics, T> postDraw) {
+        float xAngle = (float) Math.atan((x + w / 2 - mouseX) / h);
+        float yAngle = (float) Math.atan((y + h / 2 - mouseY) / h);
+        drawEntityLookingAtAngle(graphics, entity, x, y, w, h, z, xAngle, yAngle, preDraw, postDraw);
+    }
+
+    /**
+     * Draws an entity which looks toward a specific angle.
+     * The code was copied from
+     * {@link net.minecraft.client.gui.screens.inventory.InventoryScreen#renderEntityInInventoryFollowsAngle(GuiGraphics, int, int, int, float, float, LivingEntity)
+     * InventoryScreen.renderEntityInInventoryFollowsAngle}.
+     *
+     * @param graphics the current {@link GuiGraphics} instance.
+     * @param entity   entity to draw
+     * @param x        x pos
+     * @param y        y pos
+     * @param w        the width of the area where the entity should be drawn
+     * @param h        the height of the area where the entity should be drawn
+     * @param z        the z layer ({@link GuiContext#getCurrentDrawingZ()} if drawn in a MUI screen)
+     * @param xAngle   the x angle to look toward
+     * @param yAngle   the y angle to look toward
+     */
+    public static <T extends Entity> void drawEntityLookingAtAngle(GuiGraphics graphics, T entity,
+                                                                   float x, float y, float w, float h, float z,
+                                                                   float xAngle, float yAngle,
+                                                                   @Nullable BiConsumer<GuiGraphics, T> preDraw,
+                                                                   @Nullable BiConsumer<GuiGraphics, T> postDraw) {
+        graphics.pose().pushPose();
+        setupDrawEntity(graphics, entity, x, y, w, h, z);
+
+        // pre draw
+        float oldYRot = entity.getYRot();
+        float oldYRotO = entity.yRotO;
+        float oldXRot = entity.getXRot();
+        float oldXRotO = entity.xRotO;
+        float oldYBodyRot = 0.0f;
+        float oldYBodyRotO = 0.0f;
+        float oldYHeadRotO = 0.0f;
+        float oldYHeadRot = 0.0f;
+
+        entity.setYRot(entity.yRotO = 180.0f + xAngle * 40.0f);
+        entity.setXRot(entity.xRotO = -yAngle * 20.0f);
+        // made this method more generic by only updating these if the entity is a LivingEntity
+        if (entity instanceof LivingEntity livingEntity) {
+            oldYBodyRot = livingEntity.yBodyRot;
+            oldYBodyRotO = livingEntity.yBodyRotO;
+            oldYHeadRotO = livingEntity.yHeadRotO;
+            oldYHeadRot = livingEntity.yHeadRot;
+
+            livingEntity.yBodyRotO = livingEntity.yBodyRot = 180.0f + xAngle * 20.0f;
+            livingEntity.yHeadRotO = livingEntity.yHeadRot = entity.getYRot();
+        }
+
+        // skip rotating the render by 180° on the Z axis here, because we always do that in setupDrawEntity
+        Quaternionf cameraRot = new Quaternionf().rotateX(yAngle * 20.0f * Mth.DEG_TO_RAD);
+        graphics.pose().mulPose(cameraRot);
+        // set the camera orientation (vanilla also does this)
+        cameraRot.conjugate();
+        Minecraft.getInstance().getEntityRenderDispatcher().overrideCameraOrientation(cameraRot);
+
+        if (preDraw != null) preDraw.accept(graphics, entity);
+        drawEntityRaw(graphics, entity);
+        if (postDraw != null) postDraw.accept(graphics, entity);
+
+        // post draw
+        entity.setYRot(oldYRot);
+        entity.yRotO = oldYRotO;
+        entity.setXRot(oldXRot);
+        entity.xRotO = oldXRotO;
+        if (entity instanceof LivingEntity livingEntity) {
+            livingEntity.yBodyRot = oldYBodyRot;
+            livingEntity.yBodyRotO = oldYBodyRotO;
+            livingEntity.yHeadRotO = oldYHeadRotO;
+            livingEntity.yHeadRot = oldYHeadRot;
+        }
+
+        endDrawEntity();
+        graphics.pose().popPose();
+    }
+
+    /**
+     * Sets up the gl state for rendering an entity. The entity will be scaled so that it fits right in the given size
+     * when untransformed.
+     *
+     * @param graphics the current {@link GuiGraphics} instance.
+     * @param entity   entity to set up drawing for
+     * @param x        x pos
+     * @param y        y pos
+     * @param w        the width of the area where the entity should be drawn
+     * @param h        the height of the area where the entity should be drawn
+     * @param z        the z layer ({@link GuiContext#getCurrentDrawingZ()} if drawn in a MUI)
+     */
+    public static void setupDrawEntity(GuiGraphics graphics, Entity entity, float x, float y,
+                                       float w, float h, float z) {
+        float size;
+        float scale;
+        if (h / entity.getBbHeight() < w / entity.getBbWidth()) {
+            size = entity.getBbHeight();
+            scale = h / size;
+        } else {
+            size = entity.getBbWidth();
+            scale = w / size;
+        }
+        graphics.pose().translate(x + w / 2, y + h / 2, z + 50.0f);
+        graphics.pose().scale(scale, scale, -scale);
+        graphics.pose().translate(0, size / 2f, 0);
+        graphics.pose().mulPose(new Quaternionf().rotateZ(Mth.PI));
+
+        Lighting.setupForEntityInInventory();
+    }
+
+    public static void endDrawEntity() {
+        Lighting.setupFor3DItems();
+    }
+
+    public static void drawItem(GuiGraphics graphics, ItemStack item, int x, int y, float width, float height, int z) {
+        if (item.isEmpty()) return;
+        graphics.pose().pushPose();
+        graphics.pose().translate(x, y, z);
+        graphics.pose().scale(width / 16f, height / 16f, 1);
+        graphics.renderItem(item, 0, 0);
+        graphics.renderItemDecorations(Minecraft.getInstance().font, item, 0, 0);
+        graphics.pose().popPose();
+    }
+
+    public static void drawFluidTexture(GuiGraphics graphics, FluidStack content, float x0, float y0,
+                                        float width, float height, float z) {
+        if (content == null || content.isEmpty()) {
+            return;
+        }
+        Fluid fluid = content.getFluid();
+        ResourceLocation fluidStill = IClientFluidTypeExtensions.of(fluid).getStillTexture(content);
+        TextureAtlasSprite sprite = Minecraft.getInstance().getTextureAtlas(InventoryMenu.BLOCK_ATLAS)
+                .apply(fluidStill);
+        int fluidColor = IClientFluidTypeExtensions.of(fluid).getTintColor(content);
+        graphics.setColor(Color.getRedF(fluidColor), Color.getGreenF(fluidColor), Color.getBlueF(fluidColor),
+                Color.getAlphaF(fluidColor));
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        drawTiledTexture(graphics.pose().last().pose(), InventoryMenu.BLOCK_ATLAS, x0, y0, width, height,
+                sprite.getU0(), sprite.getV0(),
+                sprite.getU1(), sprite.getV1(), sprite.contents().width(), sprite.contents().height(), z);
+        graphics.setColor(1f, 1f, 1f, 1f);
+    }
+
+    public static void drawStandardSlotAmountText(GuiContext context, int amount, String format, Area area,
+                                                  float z) {
+        drawAmountText(context.getMuiContext(), amount, format, 0, 0, area.width, area.height, Alignment.BottomRight,
+                z);
+    }
+
+    public static void drawAmountText(ModularGuiContext context, int amount, String format,
+                                      int x, int y, int width, int height, Alignment alignment, float z) {
+        if (amount <= 1) return;
+
+        String amountText = FormattingUtil.formatNumberReadable(amount, false);
+        if (format != null) {
+            amountText = format + amountText;
+        }
+        drawScaledAlignedTextInBox(context, amountText, x, y, width, height, alignment, 1f, z);
+    }
+
+    public static void drawScaledAlignedTextInBox(ModularGuiContext context, String amountText,
+                                                  int x, int y, int width, int height,
+                                                  Alignment alignment) {
+        drawScaledAlignedTextInBox(context, amountText, x, y, width, height, alignment, 1f, 0.0f);
+    }
+
+    public static void drawScaledAlignedTextInBox(ModularGuiContext context, String amountText,
+                                                  int x, int y, int width, int height,
+                                                  Alignment alignment, float maxScale, float z) {
+        if (amountText == null || amountText.isEmpty()) return;
+        // render the amount overlay
+        textRenderer.setShadow(true);
+        textRenderer.setScale(1f);
+        textRenderer.setColor(Color.WHITE.main);
+        textRenderer.setAlignment(alignment, width, height);
+        textRenderer.setPos(x, y);
+        textRenderer.setHardWrapOnBorder(false);
+        RenderSystem.disableDepthTest();
+        RenderSystem.disableBlend();
+        if (amountText.length() > 2 && width > 16) { // we know that numbers below 100 will always fit in standard slots
+            // simulate and calculate scale with width
+            textRenderer.setSimulate(true);
+            textRenderer.draw(context.getGraphics(), amountText);
+            textRenderer.setSimulate(false);
+            textRenderer.setScale(Math.min(maxScale, width / textRenderer.getLastWidth()));
+        }
+        context.graphicsPose().translate(0, 0, 100 + z);
+        textRenderer.draw(context.getGraphics(), amountText);
+        textRenderer.setHardWrapOnBorder(true);
+        RenderSystem.enableDepthTest();
+        RenderSystem.enableBlend();
+    }
+
+    public static void drawSprite(Matrix4f pose, TextureAtlasSprite sprite, float x0, float y0, float w, float h) {
+        RenderSystem.enableBlend();
+        RenderSystem.setShaderTexture(0, sprite.atlasLocation());
+        drawTexture(pose, x0, y0, x0 + w, y0 + h, sprite.getU0(), sprite.getV0(), sprite.getU1(), sprite.getV1());
+        RenderSystem.disableBlend();
+    }
+
+    public static void drawTiledSprite(Matrix4f pose, TextureAtlasSprite sprite, float x0, float y0, float w, float h) {
+        RenderSystem.enableBlend();
+        RenderSystem.setShaderTexture(0, sprite.atlasLocation());
+        drawTiledTexture(pose, sprite.atlasLocation(), x0, y0, x0 + w, y0 + h, sprite.getU0(), sprite.getV0(),
+                sprite.getU1(), sprite.getV1(), sprite.contents().width(), sprite.contents().height(), 0);
+        RenderSystem.disableBlend();
+    }
+
+    public static void drawOutlineCenter(GuiGraphics graphics, int x, int y, int offset, int color) {
+        drawOutlineCenter(graphics, x, y, offset, color, 1);
+    }
+
+    public static void drawOutlineCenter(GuiGraphics graphics, int x, int y, int offset, int color, int border) {
+        drawOutline(graphics, x - offset, y - offset, x + offset, y + offset, color, border);
+    }
+
+    public static void drawOutline(GuiGraphics graphics, int left, int top, int right, int bottom, int color) {
+        drawOutline(graphics, left, top, right, bottom, color, 1);
+    }
+
+    /**
+     * Draw rectangle outline with given border
+     */
+    public static void drawOutline(GuiGraphics graphics, int left, int top, int right, int bottom,
+                                   int color, int border) {
+        graphics.fill(left, top, left + border, bottom, color);
+        graphics.fill(right - border, top, right, bottom, color);
+        graphics.fill(left + border, top, right - border, top + border, color);
+        graphics.fill(left + border, bottom - border, right - border, bottom, color);
+    }
+
+    private static void drawBorderLTRB(GuiGraphics graphics, float left, float top, float right, float bottom,
+                                       float border, int color, boolean outside) {
+        if (outside) {
+            left -= border;
+            top -= border;
+            right += border;
+            bottom += border;
+        }
+        float x0 = left, y0 = top, x1 = right, y1 = bottom, d = border;
+
+        var buffer = graphics.bufferSource().getBuffer(GTRenderTypes.guiTriangleStrip());
+        var pose = graphics.pose().last().pose();
+        pc(buffer, pose, x0, y0, color);
+        pc(buffer, pose, x1 - d, y0 + d, color);
+        pc(buffer, pose, x1, y0, color);
+        pc(buffer, pose, x1 - d, y1 - d, color);
+        pc(buffer, pose, x1, y1, color);
+        pc(buffer, pose, x0 + d, y1 - d, color);
+        pc(buffer, pose, x0, y1, color);
+        pc(buffer, pose, x0 + d, y0 + d, color);
+        pc(buffer, pose, x0, y0, color);
+        pc(buffer, pose, x1 - d, y0 + d, color);
+    }
+
+    public static void drawBorderOutsideLTRB(GuiGraphics graphics, float left, float top, float right, float bottom,
+                                             int color) {
+        drawBorderLTRB(graphics, left, top, right, bottom, 1, color, true);
+    }
+
+    public static void drawBorderOutsideLTRB(GuiGraphics graphics, float left, float top, float right, float bottom,
+                                             float border, int color) {
+        drawBorderLTRB(graphics, left, top, right, bottom, border, color, true);
+    }
+
+    public static void drawBorderInsideLTRB(GuiGraphics graphics, float left, float top, float right, float bottom,
+                                            int color) {
+        drawBorderLTRB(graphics, left, top, right, bottom, 1, color, false);
+    }
+
+    public static void drawBorderInsideLTRB(GuiGraphics graphics, float left, float top, float right, float bottom,
+                                            float border, int color) {
+        drawBorderLTRB(graphics, left, top, right, bottom, border, color, false);
+    }
+
+    private static void drawBorderXYWH(GuiGraphics graphics, float x, float y, float w, float h, float border,
+                                       int color, boolean outside) {
+        drawBorderLTRB(graphics, x, y, x + w, y + h, border, color, outside);
+    }
+
+    public static void drawBorderOutsideXYWH(GuiGraphics graphics, float x, float y, float w, float h, float border,
+                                             int color) {
+        drawBorderXYWH(graphics, x, y, w, h, border, color, true);
+    }
+
+    public static void drawBorderOutsideXYWH(GuiGraphics graphics, float x, float y, float w, float h, int color) {
+        drawBorderXYWH(graphics, x, y, w, h, 1, color, true);
+    }
+
+    public static void drawBorderInsideXYWH(GuiGraphics graphics, float x, float y, float w, float h, float border,
+                                            int color) {
+        drawBorderXYWH(graphics, x, y, w, h, border, color, false);
+    }
+
+    public static void drawBorderInsideXYWH(GuiGraphics graphics, float x, float y, float w, float h, int color) {
+        drawBorderXYWH(graphics, x, y, w, h, 1, color, false);
+    }
+
+    private static void pc(VertexConsumer buffer, Matrix4f pose, float x, float y, int c) {
+        buffer.vertex(pose, x, y, 0).color(Color.getRed(c), Color.getGreen(c), Color.getBlue(c), Color.getAlpha(c))
+                .endVertex();
+    }
+
+    /**
+     * Draws a rectangular shadow
+     *
+     * @param x      left of solid shadow part
+     * @param y      top of solid shadow part
+     * @param w      width of solid shadow part
+     * @param h      height of solid shadow part
+     * @param oX     shadow gradient size in x
+     * @param oY     shadow gradient size in y
+     * @param opaque solid shadow color
+     * @param shadow gradient end color
+     */
+    public static void drawDropShadow(Matrix4f pose, int x, int y, int w, int h, int oX, int oY,
+                                      int opaque, int shadow) {
+        float a1 = Color.getAlphaF(opaque);
+        float r1 = Color.getRedF(opaque);
+        float g1 = Color.getGreenF(opaque);
+        float b1 = Color.getBlueF(opaque);
+        float a2 = Color.getAlphaF(shadow);
+        float r2 = Color.getRedF(shadow);
+        float g2 = Color.getGreenF(shadow);
+        float b2 = Color.getBlueF(shadow);
+
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        RenderSystem.enableBlend();
+        RenderSystem.disableDepthTest();
+        RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA,
+                GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA,
+                GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);
+
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+
+        float x1 = x + w, y1 = y + h;
+
+        /* Draw opaque part */
+        buffer.vertex(pose, x1, y, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x, y, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x, y1, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x1, y1, 0).color(r1, g1, b1, a1).endVertex();
+
+        /* Draw top shadow */
+        buffer.vertex(pose, x1 + oX, y - oY, 0).color(r2, g2, b2, a2).endVertex();
+        buffer.vertex(pose, x - oX, y - oY, 0).color(r2, g2, b2, a2).endVertex();
+        buffer.vertex(pose, x, y, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x1, y, 0).color(r1, g1, b1, a1).endVertex();
+
+        /* Draw bottom shadow */
+        buffer.vertex(pose, x1, y1, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x, y1, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x - oX, y1 + oY, 0).color(r2, g2, b2, a2).endVertex();
+        buffer.vertex(pose, x1 + oX, y1 + oY, 0).color(r2, g2, b2, a2).endVertex();
+
+        /* Draw left shadow */
+        buffer.vertex(pose, x, y, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x - oX, y - oY, 0).color(r2, g2, b2, a2).endVertex();
+        buffer.vertex(pose, x - oX, y1 + oY, 0).color(r2, g2, b2, a2).endVertex();
+        buffer.vertex(pose, x, y1, 0).color(r1, g1, b1, a1).endVertex();
+
+        /* Draw right shadow */
+        buffer.vertex(pose, x1 + oX, y - oY, 0).color(r2, g2, b2, a2).endVertex();
+        buffer.vertex(pose, x1, y, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x1, y1, 0).color(r1, g1, b1, a1).endVertex();
+        buffer.vertex(pose, x1 + oX, y1 + oY, 0).color(r2, g2, b2, a2).endVertex();
+
+        tesselator.end();
+        RenderSystem.disableBlend();
+    }
+
+    public static void drawDropCircleShadow(GuiGraphics graphics, int x, int y, int radius, int segments,
+                                            int opaque, int shadow) {
+        Matrix4f pose = graphics.pose().last().pose();
+        Matrix4d poseD = new Matrix4d(pose);
+
+        float a1 = Color.getAlphaF(opaque);
+        float r1 = Color.getRedF(opaque);
+        float g1 = Color.getGreenF(opaque);
+        float b1 = Color.getBlueF(opaque);
+        float a2 = Color.getAlphaF(shadow);
+        float r2 = Color.getRedF(shadow);
+        float g2 = Color.getGreenF(shadow);
+        float b2 = Color.getBlueF(shadow);
+
+        VertexConsumer buffer = graphics.bufferSource().getBuffer(GTRenderTypes.guiOverlayTriangleFan());
+        buffer.vertex(pose, x, y, 0).color(r1, g1, b1, a1).endVertex();
+
+        Vector3d pos = new Vector3d();
+        for (int i = 0; i <= segments; i++) {
+            float a = i / (float) segments * TWO_PI - HALF_PI;
+            circleVertex(buffer, poseD, pos, x, Mth.cos(a), y, Mth.sin(a), radius).color(r2, g2, b2, a2).endVertex();
+        }
+    }
+
+    public static void drawDropCircleShadow(GuiGraphics graphics, int x, int y, int radius, int offset, int segments,
+                                            int opaque, int shadow) {
+        if (offset >= radius) {
+            drawDropCircleShadow(graphics, x, y, radius, segments, opaque, shadow);
+            return;
+        }
+        Matrix4f pose = graphics.pose().last().pose();
+        Matrix4d poseD = new Matrix4d(pose);
+
+        float a1 = Color.getAlphaF(opaque);
+        float r1 = Color.getRedF(opaque);
+        float g1 = Color.getGreenF(opaque);
+        float b1 = Color.getBlueF(opaque);
+        float a2 = Color.getAlphaF(shadow);
+        float r2 = Color.getRedF(shadow);
+        float g2 = Color.getGreenF(shadow);
+        float b2 = Color.getBlueF(shadow);
+
+        VertexConsumer buffer = graphics.bufferSource().getBuffer(GTRenderTypes.guiOverlayTriangleFan());
+        /* Draw opaque base */
+        buffer.vertex(pose, x, y, 0).color(r1, g1, b1, a1).endVertex();
+
+        Vector3d pos = new Vector3d();
+        for (int i = 0; i <= segments; i++) {
+            float a = i / (float) segments * TWO_PI - HALF_PI;
+            circleVertex(buffer, poseD, pos, x, Mth.cos(a), y, Mth.sin(a), offset).color(r1, g1, b1, a1).endVertex();
+        }
+
+        /* Draw outer shadow */
+        buffer = graphics.bufferSource().getBuffer(RenderType.gui());
+
+        for (int i = 0; i < segments; i++) {
+            float alpha1 = i / (float) segments * TWO_PI - HALF_PI;
+            float alpha2 = (i + 1) / (float) segments * TWO_PI - HALF_PI;
+
+            float cosA1 = Mth.cos(alpha1);
+            float cosA2 = Mth.cos(alpha2);
+            float sinA1 = Mth.sin(alpha1);
+            float sinA2 = Mth.sin(alpha2);
+
+            circleVertex(buffer, poseD, pos, x, cosA2, y, sinA2, offset).color(r1, g1, b1, a1).endVertex();
+            circleVertex(buffer, poseD, pos, x, cosA1, y, sinA1, offset).color(r1, g1, b1, a1).endVertex();
+            circleVertex(buffer, poseD, pos, x, cosA1, y, sinA1, radius).color(r2, g2, b2, a2).endVertex();
+            circleVertex(buffer, poseD, pos, x, cosA2, y, sinA2, radius).color(r2, g2, b2, a2).endVertex();
+        }
+    }
+
+    private static VertexConsumer circleVertex(VertexConsumer buffer, Matrix4d pose, Vector3d pos,
+                                               float x, float xOffset, float y, float yOffset, float mul) {
+        pos.x = x - xOffset * mul;
+        pos.y = y + yOffset * mul;
+        pose.transformPosition(pos);
+        return buffer.vertex(pos.x, pos.y, pos.z);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static void drawBorder(GuiGraphics graphics, float x, float y, float width, float height,
+                                  int color, float border) {
+        drawBorderLTRB(graphics, x, y, x + width, y + height, border, color, false);
+        // drawRect(graphics, x - border, y - border, width + 2 * border, border, color);
+        // drawRect(graphics, x - border, y + height, width + 2 * border, border, color);
+        // drawRect(graphics, x - border, y, border, height, color);
+        // drawRect(graphics, x + width, y, border, height, color);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static void drawText(GuiGraphics graphics, String text, float x, float y, float scale,
+                                int color, boolean shadow) {
+        graphics.pose().pushPose();
+        graphics.pose().scale(scale, scale, 0f);
+        float sf = 1 / scale;
+        graphics.drawString(Minecraft.getInstance().font, text, x * sf, y * sf, color, shadow);
+        graphics.pose().popPose();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static void drawText(GuiGraphics graphics, Component text, float x, float y, float scale,
+                                int color, boolean shadow) {
+        drawText(graphics, text.getVisualOrderText(), x, y, scale, color, shadow);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static void drawText(GuiGraphics graphics, FormattedCharSequence text, float x, float y, float scale,
+                                int color, boolean shadow) {
+        graphics.pose().pushPose();
+        graphics.pose().scale(scale, scale, 0f);
+        float sf = 1 / scale;
+        graphics.drawString(Minecraft.getInstance().font, text, x * sf, y * sf, color, shadow);
+        graphics.pose().popPose();
+    }
+
+    @SuppressWarnings("UnstableApiUsage")
+    public static void drawTooltipBackground(GuiContext context, ItemStack stack, List<ClientTooltipComponent> lines,
+                                             int x, int y, int textWidth, int height, @Nullable RichTooltip tooltip) {
+        GuiGraphics graphics = context.getGraphics();
+
+        // TODO theme color
+        int backgroundTop = 0xF0100010;
+        int backgroundBottom = backgroundTop;
+        int borderColorStart = 0x505000FF;
+        int borderColorEnd = (borderColorStart & 0xFEFEFE) >> 1 | borderColorStart & 0xFF000000;
+        RenderTooltipEvent.Color colorEvent;
+
+        if (tooltip != null) {
+            colorEvent = new RichTooltipEvent.Color(stack, graphics, x, y, context.getFont(),
+                    backgroundTop, borderColorStart, borderColorEnd, lines, tooltip);
+        } else {
+            colorEvent = new RenderTooltipEvent.Color(stack, graphics, x, y, context.getFont(),
+                    backgroundTop, borderColorStart, borderColorEnd, lines);
+        }
+
+        MinecraftForge.EVENT_BUS.post(colorEvent);
+        backgroundTop = colorEvent.getBackgroundStart();
+        backgroundBottom = colorEvent.getBackgroundEnd();
+        borderColorStart = colorEvent.getBorderStart();
+        borderColorEnd = colorEvent.getBorderEnd();
+
+        // top background border
+        drawVerticalGradientRect(graphics, x - 3, y - 4, textWidth + 6, 1, backgroundTop, backgroundTop);
+        // bottom background border
+        drawVerticalGradientRect(graphics, x - 3, y + height + 3, textWidth + 6, 1, backgroundBottom, backgroundBottom);
+        // center background
+        drawVerticalGradientRect(graphics, x - 3, y - 3, textWidth + 6, height + 6, backgroundTop, backgroundBottom);
+        // left background border
+        drawVerticalGradientRect(graphics, x - 4, y - 3, 1, height + 6, backgroundTop, backgroundBottom);
+        // right background border
+        drawVerticalGradientRect(graphics, x + textWidth + 3, y - 3, 1, height + 6, backgroundTop, backgroundBottom);
+
+        // left accent border
+        drawVerticalGradientRect(graphics, x - 3, y - 2, 1, height + 4, borderColorStart, borderColorEnd);
+        // right accent border
+        drawVerticalGradientRect(graphics, x + textWidth + 2, y - 2, 1, height + 4, borderColorStart, borderColorEnd);
+        // top accent border
+        drawVerticalGradientRect(graphics, x - 3, y - 3, textWidth + 6, 1, borderColorStart, borderColorStart);
+        // bottom accent border
+        drawVerticalGradientRect(graphics, x - 3, y + height + 2, textWidth + 6, 1, borderColorEnd, borderColorEnd);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/HoverableIcon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/HoverableIcon.java
new file mode 100644
index 00000000000..ab944967ecf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/HoverableIcon.java
@@ -0,0 +1,46 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IHoverable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.widget.ITooltip;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class HoverableIcon extends DelegateIcon implements IHoverable, ITooltip<HoverableIcon> {
+
+    private final Area area = new Area();
+    @Getter
+    private @Nullable RichTooltip tooltip;
+
+    public HoverableIcon(IIcon icon) {
+        super(icon);
+        setRenderedAt(0, 0);
+    }
+
+    @Override
+    public void setRenderedAt(int x, int y) {
+        this.area.set(x, y, getWidth(), getHeight());
+    }
+
+    @Override
+    public Area getRenderedArea() {
+        this.area.setSize(getWidth(), getHeight());
+        return this.area;
+    }
+
+    @Override
+    public @NotNull RichTooltip tooltip() {
+        if (this.tooltip == null) this.tooltip = new RichTooltip().parent(area -> area.set(getRenderedArea()));
+        return tooltip;
+    }
+
+    @Override
+    public HoverableIcon tooltip(RichTooltip tooltip) {
+        this.tooltip = tooltip;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/HueBar.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/HueBar.java
new file mode 100644
index 00000000000..11d91b38108
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/HueBar.java
@@ -0,0 +1,44 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+public class HueBar implements IDrawable {
+
+    private static final int[] COLORS = {
+            Color.ofHSV(60, 1f, 1f, 1f),
+            Color.ofHSV(120, 1f, 1f, 1f),
+            Color.ofHSV(180, 1f, 1f, 1f),
+            Color.ofHSV(240, 1f, 1f, 1f),
+            Color.ofHSV(300, 1f, 1f, 1f),
+            Color.ofHSV(0, 1f, 1f, 1f)
+    };
+
+    private final GuiAxis axis;
+
+    public HueBar(GuiAxis axis) {
+        this.axis = axis;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        applyColor(widgetTheme.getColor());
+        int size = this.axis.isHorizontal() ? width : height;
+        float step = size / 6f;
+        int previous = COLORS[5];
+        for (int i = 0; i < 6; i++) {
+            int current = COLORS[i];
+            if (this.axis.isHorizontal()) {
+                GuiDraw.drawHorizontalGradientRect(context.getGraphics(), x + step * i, y, step, height, previous,
+                        current);
+            } else {
+                GuiDraw.drawVerticalGradientRect(context.getGraphics(), x, y + step * i, width, step, previous,
+                        current);
+            }
+            previous = current;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Icon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Icon.java
new file mode 100644
index 00000000000..b26e8e7c513
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Icon.java
@@ -0,0 +1,195 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonObject;
+import lombok.Getter;
+
+/**
+ * A {@link IDrawable} wrapper with a fixed size and an alignment.
+ */
+public class Icon implements IIcon, IJsonSerializable<Icon> {
+
+    private final IDrawable drawable;
+    @Getter
+    private int width = 0, height = 0;
+    private float aspectRatio = 0;
+    @Getter
+    private Alignment alignment = Alignment.Center;
+    @Getter
+    private final Box margin = new Box();
+
+    public Icon(IDrawable drawable) {
+        this.drawable = drawable;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        x += this.margin.left();
+        y += this.margin.top();
+        width -= this.margin.horizontal();
+        height -= this.margin.vertical();
+        int frameWidth = width;
+        int frameHeight = height;
+        if (this.width > 0) width = this.width;
+        if (this.height > 0) height = this.height;
+        if (this.aspectRatio > 0) {
+            if (this.width <= 0) {
+                if (this.height <= 0) {
+                    // width and height is unset, so adjust width or height so that one of them takes the full space
+                    float w = width, h = height;
+                    float properW = this.aspectRatio * h;
+                    if (w > properW) {
+                        width = (int) properW;
+                    } else if (w < properW) {
+                        height = (int) (w / this.aspectRatio);
+                    }
+                } else {
+                    // height is set, so adjust width to height
+                    float properW = this.aspectRatio * height;
+                    width = (int) properW;
+                }
+            } else if (this.height <= 0) {
+                // width is set, so adjust height to width
+                height = (int) (width / this.aspectRatio);
+            } else if (GTCEu.isDev()) {
+                GTCEu.LOGGER.error("Aspect ratio in Icon can't be applied when width and height are specified");
+                // remove aspect ratio to avoid log spamming, it does nothing in the current state anyway
+                this.aspectRatio = 0;
+            }
+        }
+        // apply alignment
+        if (width != frameWidth) {
+            x += (int) (frameWidth * this.alignment.x - width * this.alignment.x);
+        }
+        if (height != frameHeight) {
+            y += (int) (frameHeight * this.alignment.y - height * this.alignment.y);
+        }
+        this.drawable.draw(context, x, y, width, height, widgetTheme);
+    }
+
+    @Override
+    public IDrawable getWrappedDrawable() {
+        return drawable;
+    }
+
+    public Icon expandWidth() {
+        return width(0);
+    }
+
+    public Icon expandHeight() {
+        return height(0);
+    }
+
+    public Icon width(int width) {
+        this.width = Math.max(0, width);
+        return this;
+    }
+
+    public Icon height(int height) {
+        this.height = Math.max(0, height);
+        return this;
+    }
+
+    public Icon size(int width, int height) {
+        return width(width).height(height);
+    }
+
+    public Icon size(int size) {
+        return width(size).height(size);
+    }
+
+    public Icon aspectRatio(float aspectRatio) {
+        this.aspectRatio = aspectRatio;
+        return this;
+    }
+
+    public Icon alignment(Alignment alignment) {
+        this.alignment = alignment;
+        return this;
+    }
+
+    public Icon center() {
+        return alignment(Alignment.Center);
+    }
+
+    public Icon margin(int left, int right, int top, int bottom) {
+        this.margin.all(left, right, top, bottom);
+        return this;
+    }
+
+    public Icon margin(int horizontal, int vertical) {
+        this.margin.all(horizontal, vertical);
+        return this;
+    }
+
+    public Icon margin(int all) {
+        this.margin.all(all);
+        return this;
+    }
+
+    public Icon marginLeft(int val) {
+        this.margin.left(val);
+        return this;
+    }
+
+    public Icon marginRight(int val) {
+        this.margin.right(val);
+        return this;
+    }
+
+    public Icon marginTop(int val) {
+        this.margin.top(val);
+        return this;
+    }
+
+    public Icon marginBottom(int val) {
+        this.margin.bottom(val);
+        return this;
+    }
+
+    @Override
+    public void loadFromJson(JsonObject json) {
+        this.width = (json.has("autoWidth") || json.has("autoSize")) &&
+                JsonHelper.getBoolean(json, true, "autoWidth", "autoSize") ? 0 :
+                        JsonHelper.getInt(json, 0, "width", "w", "size");
+        this.height = (json.has("autoHeight") || json.has("autoSize")) &&
+                JsonHelper.getBoolean(json, true, "autoHeight", "autoSize") ? 0 :
+                        JsonHelper.getInt(json, 0, "height", "h", "size");
+        this.aspectRatio = JsonHelper.getFloat(json, 0, "aspectRatio");
+        this.alignment = JsonHelper.deserialize(json, Alignment.class, Alignment.Center, "alignment", "align");
+        this.margin.fromJson(json);
+    }
+
+    public static Icon ofJson(JsonObject json) {
+        return JsonHelper.deserialize(json, IDrawable.class, IDrawable.EMPTY, "drawable", "icon").asIcon();
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        json.add("drawable", JsonHelper.serialize(this.drawable));
+        json.addProperty("width", this.width);
+        json.addProperty("height", this.height);
+        json.addProperty("aspectRatio", this.aspectRatio);
+        json.add("alignment", JsonHelper.serialize(this.alignment));
+        this.margin.toJson(json);
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(" + this.drawable.getClass().getSimpleName() + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/IconRenderer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/IconRenderer.java
new file mode 100644
index 00000000000..b1975cb18eb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/IconRenderer.java
@@ -0,0 +1,154 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.text.StyledText;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextIcon;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.FormattedCharSequence;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Deprecated
+public class IconRenderer {
+
+    public static final IconRenderer SHARED = new IconRenderer();
+
+    protected float maxWidth = -1, maxHeight = -1;
+    protected int x = 0, y = 0;
+    protected Alignment alignment = Alignment.TopLeft;
+    @Setter
+    protected float scale = 1f;
+    @Setter
+    protected boolean shadow = false;
+    @Setter
+    protected int color = 0;
+    @Setter
+    protected int linePadding = 1;
+    @Setter
+    protected boolean simulate;
+    @Getter
+    protected float lastWidth = 0, lastHeight = 0;
+    @Setter
+    protected boolean useWholeWidth = false;
+
+    public void setAlignment(Alignment alignment, float maxWidth) {
+        setAlignment(alignment, maxWidth, -1);
+    }
+
+    public void setAlignment(Alignment alignment, float maxWidth, float maxHeight) {
+        this.alignment = alignment;
+        this.maxWidth = maxWidth;
+        this.maxHeight = maxHeight;
+    }
+
+    public void setPos(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void draw(GuiContext context, IDrawable text) {
+        draw(context, Collections.singletonList(text));
+    }
+
+    public void draw(GuiContext context, List<IDrawable> lines) {
+        drawMeasuredLines(context, measureLines(lines));
+    }
+
+    public void drawMeasuredLines(GuiContext context, List<IIcon> lines) {
+        TextRenderer.SHARED.setColor(this.color);
+        TextRenderer.SHARED.setShadow(this.shadow);
+        TextRenderer.SHARED.setScale(this.scale);
+        TextRenderer.SHARED.setAlignment(this.alignment, this.maxWidth);
+        int totalHeight = -1, maxWidth = 0;
+        if (this.useWholeWidth) {
+            maxWidth = (int) this.maxWidth;
+        }
+        for (IIcon icon : lines) {
+            totalHeight += icon.getHeight() + this.linePadding;
+            if (!this.useWholeWidth && icon.getWidth() > 0) {
+                maxWidth = Math.max(maxWidth, icon.getWidth());
+            }
+        }
+        if (!lines.isEmpty()) {
+            // don't add padding to last line
+            totalHeight -= this.linePadding;
+        }
+        int y = getStartY(totalHeight);
+        for (IIcon icon : lines) {
+            int x = icon.getWidth() > 0 ? getStartX(icon.getWidth()) : this.x;
+            if (!this.simulate) {
+                icon.draw(context, x, y, maxWidth, icon.getHeight(), WidgetTheme.getDefault().getTheme());
+            }
+            y += (int) ((icon.getHeight() + this.linePadding) * this.scale);
+        }
+        this.lastWidth = this.maxWidth > 0 ? Math.min(this.maxWidth, maxWidth) : maxWidth;
+        this.lastHeight = totalHeight * this.scale;
+    }
+
+    public List<IIcon> measureLines(List<IDrawable> lines) {
+        List<IIcon> icons = new ArrayList<>();
+        for (IDrawable element : lines) {
+            if (element instanceof IIcon icon) {
+                icons.add(icon);
+            } else if (element instanceof IKey key) {
+                float scale = this.scale;
+                Alignment alignment1 = this.alignment;
+                if (element instanceof StyledText styledText) {
+                    scale = styledText.scale();
+                    alignment1 = styledText.alignment();
+                }
+                Component text = key.get();
+                int width = (int) (getFont().width(text) * scale);
+                icons.add(new TextIcon(text, width, (int) (getFont().lineHeight * scale), scale, alignment1));
+            } else {
+                icons.add(element.asIcon().height(getFont().lineHeight));
+            }
+        }
+        return icons;
+    }
+
+    public List<FormattedCharSequence> wrapLine(Component line, float scale) {
+        return this.maxWidth > 0 ? getFont().split(line, (int) (this.maxWidth / scale)) :
+                Collections.singletonList(line.getVisualOrderText());
+    }
+
+    protected int getStartY(int totalHeight) {
+        if (this.alignment.y > 0 && this.maxHeight > 0) {
+            float height = totalHeight * this.scale;
+            return (int) (this.y + (this.maxHeight * this.alignment.y) - height * this.alignment.y);
+        }
+        return this.y;
+    }
+
+    protected int getStartX(float lineWidth) {
+        if (this.alignment.x > 0 && this.maxWidth > 0) {
+            return (int) (this.x + (this.maxWidth * this.alignment.x) - lineWidth * this.alignment.x);
+        }
+        return this.x;
+    }
+
+    public float getFontHeight() {
+        return getFont().lineHeight * this.scale;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static Font getFont() {
+        return Minecraft.getInstance().font;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/IngredientDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/IngredientDrawable.java
new file mode 100644
index 00000000000..2d44f13ca7c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/IngredientDrawable.java
@@ -0,0 +1,61 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.Util;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Tolerate;
+
+public class IngredientDrawable implements IDrawable, IJsonSerializable<IngredientDrawable> {
+
+    @Getter
+    @Setter
+    private ItemStack[] items;
+    @Getter
+    @Setter
+    private int cycleTime = 1000;
+
+    public IngredientDrawable(Ingredient ingredient) {
+        this(ingredient.getItems());
+    }
+
+    public IngredientDrawable(ItemStack... items) {
+        setItems(items);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        if (this.items.length == 0) return;
+        ItemStack item = this.items[(int) (Util.getMillis() % (this.cycleTime * this.items.length)) / this.cycleTime];
+        if (item != null) {
+            GuiDraw.drawItem(context.getGraphics(), item, x, y, width, height, context.getCurrentDrawingZ());
+        }
+    }
+
+    /**
+     * Sets how many milliseconds each item shows up
+     *
+     * @param cycleTime time per item in milliseconds
+     * @return this
+     */
+    @Tolerate
+    public IngredientDrawable cycleTime(int cycleTime) {
+        this.cycleTime = cycleTime;
+        return this;
+    }
+
+    @Tolerate
+    public void setItems(Ingredient ingredient) {
+        setItems(ingredient.getItems());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/InteractableIcon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/InteractableIcon.java
new file mode 100644
index 00000000000..b3d780e9a3a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/InteractableIcon.java
@@ -0,0 +1,91 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.widget.IGuiAction;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+
+@Accessors(fluent = true, chain = true)
+public class InteractableIcon extends DelegateIcon implements Interactable {
+
+    @Setter
+    private IGuiAction.MousePressed onMousePressed;
+    @Setter
+    private IGuiAction.MouseReleased onMouseReleased;
+    @Setter
+    private IGuiAction.MousePressed onMouseTapped;
+    @Setter
+    private IGuiAction.MouseScroll onMouseScrolled;
+    @Setter
+    private IGuiAction.KeyPressed onKeyPressed;
+    @Setter
+    private IGuiAction.KeyReleased onKeyReleased;
+    @Setter
+    private IGuiAction.KeyPressed onKeyTapped;
+    @Setter
+    public boolean playClickSound = true;
+
+    public InteractableIcon(IIcon icon) {
+        super(icon);
+    }
+
+    public void playClickSound() {
+        if (this.playClickSound) {
+            Interactable.playButtonClickSound();
+        }
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        if (this.onMousePressed != null && this.onMousePressed.press(mouseX, mouseY, button)) {
+            playClickSound();
+            return Result.SUCCESS;
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        return this.onMouseReleased != null && this.onMouseReleased.release(mouseX, mouseY, button);
+    }
+
+    @NotNull
+    @Override
+    public Result onMouseTapped(double mouseX, double mouseY, int button) {
+        if (this.onMouseTapped != null && this.onMouseTapped.press(mouseX, mouseY, button)) {
+            playClickSound();
+            return Result.SUCCESS;
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public @NotNull Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        if (this.onKeyPressed != null && this.onKeyPressed.press(keyCode, scanCode, modifiers)) {
+            return Result.SUCCESS;
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        return this.onKeyReleased != null && this.onKeyReleased.release(keyCode, scanCode, modifiers);
+    }
+
+    @NotNull
+    @Override
+    public Result onKeyTapped(int keyCode, int scanCode, int modifiers) {
+        if (this.onKeyTapped != null && this.onKeyTapped.press(keyCode, scanCode, modifiers)) {
+            return Result.SUCCESS;
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        return this.onMouseScrolled != null && this.onMouseScrolled.scroll(mouseX, mouseY, delta);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/ItemDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/ItemDrawable.java
new file mode 100644
index 00000000000..49b86465cc0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/ItemDrawable.java
@@ -0,0 +1,140 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtOps;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.mojang.serialization.JsonOps;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.NoSuchElementException;
+
+public class ItemDrawable implements IDrawable, IJsonSerializable<ItemDrawable> {
+
+    @Getter
+    private ItemStack item = ItemStack.EMPTY;
+
+    public ItemDrawable() {}
+
+    public ItemDrawable(@NotNull ItemStack item) {
+        setItem(item);
+    }
+
+    public ItemDrawable(@NotNull Item item) {
+        setItem(item);
+    }
+
+    public ItemDrawable(@NotNull Item item, int amount) {
+        setItem(item, amount);
+    }
+
+    public ItemDrawable(@NotNull Item item, int amount, @Nullable CompoundTag nbt) {
+        setItem(item, amount, nbt);
+    }
+
+    public ItemDrawable(@NotNull Block item) {
+        setItem(item);
+    }
+
+    public ItemDrawable(@NotNull Block item, int amount) {
+        setItem(new ItemStack(item, amount));
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        applyColor(widgetTheme.getColor());
+        GuiDraw.drawItem(context.getGraphics(), this.item, x, y, width, height, context.getCurrentDrawingZ());
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return 16;
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return 16;
+    }
+
+    @Override
+    public Widget<?> asWidget() {
+        return IDrawable.super.asWidget().size(16);
+    }
+
+    public ItemDrawable setItem(@NotNull ItemStack item) {
+        this.item = item;
+        return this;
+    }
+
+    public ItemDrawable setItem(@NotNull Item item) {
+        return setItem(item, 1, null);
+    }
+
+    public ItemDrawable setItem(@NotNull Item item, int amount) {
+        return setItem(item, amount, null);
+    }
+
+    public ItemDrawable setItem(@NotNull Item item, int amount, @Nullable CompoundTag nbt) {
+        ItemStack itemStack = new ItemStack(item, amount);
+        itemStack.setTag(nbt);
+        return setItem(itemStack);
+    }
+
+    public ItemDrawable setItem(@NotNull Block item) {
+        return setItem(item, 1);
+    }
+
+    public ItemDrawable setItem(@NotNull Block item, int amount) {
+        return setItem(new ItemStack(item, amount));
+    }
+
+    public static ItemDrawable ofJson(JsonObject json) {
+        String itemName = JsonHelper.getString(json, null, "item");
+        if (itemName == null) throw new JsonParseException("Item property not found!");
+        if (itemName.isEmpty()) return new ItemDrawable();
+        ItemStack stack;
+        try {
+            ResourceLocation id = new ResourceLocation(itemName);
+            stack = new ItemStack(BuiltInRegistries.ITEM.get(id));
+        } catch (NoSuchElementException e) {
+            throw new JsonParseException(e);
+        }
+        if (json.has("nbt")) {
+            CompoundTag nbt = (CompoundTag) JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE,
+                    JsonHelper.getObject(json, new JsonObject(), o -> o, "nbt"));
+            stack.setTag(nbt);
+        }
+        return new ItemDrawable(stack);
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        if (this.item == null || this.item.isEmpty()) {
+            json.addProperty("item", "");
+            return true;
+        }
+        json.addProperty("item", this.item.getItemHolder().unwrapKey().get().location().toString());
+        if (this.item.hasTag()) {
+            json.addProperty("nbt", this.item.getTag().toString());
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/NamedDrawableRow.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/NamedDrawableRow.java
new file mode 100644
index 00000000000..0a5fe5b765f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/NamedDrawableRow.java
@@ -0,0 +1,66 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class NamedDrawableRow implements IDrawable {
+
+    @Getter
+    private IKey name;
+    @Getter
+    private IIcon drawable;
+
+    public NamedDrawableRow() {
+        this(null, null);
+    }
+
+    public NamedDrawableRow(@Nullable IKey name, @Nullable IIcon drawable) {
+        this.name = name;
+        this.drawable = drawable;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        if (this.name != null) {
+            this.name.drawAligned(context, x, y, width, height, widgetTheme, Alignment.CenterLeft);
+        }
+        if (this.drawable != null) {
+            int wd = this.drawable.getWidth() + this.drawable.getMargin().horizontal();
+            int xd = x + width - wd;
+            this.drawable.draw(context, xd, y, wd, height, widgetTheme);
+        }
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        int w = 0;
+        if (this.name != null) w += this.name.getDefaultWidth();
+        if (this.drawable != null) w += this.drawable.getWidth();
+        return w;
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        int h = 0;
+        if (this.name != null) h += this.name.getDefaultHeight();
+        if (this.drawable != null) h += this.drawable.getHeight();
+        return h;
+    }
+
+    public NamedDrawableRow name(@Nullable IKey key) {
+        this.name = key;
+        return this;
+    }
+
+    public NamedDrawableRow drawable(@Nullable IIcon drawable) {
+        this.drawable = drawable;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Rectangle.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Rectangle.java
new file mode 100644
index 00000000000..3222416724f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Rectangle.java
@@ -0,0 +1,209 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.animation.IAnimatable;
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.client.renderer.GTRenderTypes;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.joml.Matrix4f;
+
+import java.util.function.IntConsumer;
+
+@Accessors(fluent = true, chain = true)
+public class Rectangle implements IDrawable, IJsonSerializable<Rectangle>, IAnimatable<Rectangle> {
+
+    private int cornerRadius, colorTL, colorTR, colorBL, colorBR;
+    @Setter
+    private int cornerSegments;
+    private float borderThickness;
+    @Getter
+    @Setter
+    private boolean canApplyTheme = false;
+
+    public Rectangle() {
+        color(0xFFFFFFFF);
+        this.cornerRadius = 0;
+        this.cornerSegments = 6;
+    }
+
+    public int getColor() {
+        return this.colorTL;
+    }
+
+    public Rectangle cornerRadius(int cornerRadius) {
+        this.cornerRadius = Math.max(0, cornerRadius);
+        if (this.borderThickness > 0 && cornerRadius > 0) {
+            GTCEu.LOGGER.error("Hollow rectangles currently can't have a corner radius.");
+        }
+        return this;
+    }
+
+    public Rectangle color(int colorTL, int colorTR, int colorBL, int colorBR) {
+        this.colorTL = colorTL;
+        this.colorTR = colorTR;
+        this.colorBL = colorBL;
+        this.colorBR = colorBR;
+        return this;
+    }
+
+    public Rectangle verticalGradient(int colorTop, int colorBottom) {
+        return color(colorTop, colorTop, colorBottom, colorBottom);
+    }
+
+    public Rectangle horizontalGradient(int colorLeft, int colorRight) {
+        return color(colorLeft, colorRight, colorLeft, colorRight);
+    }
+
+    public Rectangle color(int color) {
+        return color(color, color, color, color);
+    }
+
+    public Rectangle solid() {
+        this.borderThickness = 0;
+        return this;
+    }
+
+    public Rectangle hollow(float borderThickness) {
+        this.borderThickness = borderThickness;
+        if (borderThickness > 0 && this.cornerRadius > 0) {
+            GTCEu.LOGGER.error("Hollow rectangles currently can't have a corner radius.");
+        }
+        return this;
+    }
+
+    public Rectangle hollow() {
+        return hollow(1);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x0, int y0, int width, int height, WidgetTheme widgetTheme) {
+        applyColor(widgetTheme.getColor());
+        if (this.borderThickness <= 0) {
+            if (this.cornerRadius <= 0) {
+                GuiDraw.drawRect(context.getGraphics(), x0, y0, width, height,
+                        this.colorTL, this.colorTR, this.colorBL, this.colorBR);
+                return;
+            }
+            GuiDraw.drawRoundedRect(context.getGraphics(), x0, y0, width, height,
+                    this.colorTL, this.colorTR, this.colorBL, this.colorBR,
+                    this.cornerRadius, this.cornerSegments);
+        } else {
+            float d = this.borderThickness;
+            float x1 = x0 + width, y1 = y0 + height;
+
+            Matrix4f pose = context.getGraphics().pose().last().pose();
+            VertexConsumer bufferbuilder = context.getGraphics().bufferSource()
+                    .getBuffer(GTRenderTypes.guiTriangleStrip());
+            v(pose, bufferbuilder, x0, y0, this.colorTL);
+            v(pose, bufferbuilder, x1 - d, y0 + d, this.colorTR);
+            v(pose, bufferbuilder, x1, y0, this.colorTR);
+            v(pose, bufferbuilder, x1 - d, y1 - d, this.colorBR);
+            v(pose, bufferbuilder, x1, y1, this.colorBR);
+            v(pose, bufferbuilder, x0 + d, y1 - d, this.colorBL);
+            v(pose, bufferbuilder, x0, y1, this.colorBL);
+            v(pose, bufferbuilder, x0 + d, y0 + d, this.colorTL);
+            v(pose, bufferbuilder, x0, y0, this.colorTL);
+            v(pose, bufferbuilder, x1 - d, y0 + d, this.colorTR);
+        }
+    }
+
+    private static void v(Matrix4f pose, VertexConsumer buffer, float x, float y, int c) {
+        buffer.vertex(pose, x, y, 0).color(Color.getRed(c), Color.getGreen(c), Color.getBlue(c), Color.getAlpha(c))
+                .endVertex();
+    }
+
+    @Override
+    public void loadFromJson(JsonObject json) {
+        if (json.has("color")) {
+            color(Color.ofJson(json.get("color")));
+        }
+        if (json.has("colorTop")) {
+            int c = Color.ofJson(json.get("colorTop"));
+            this.colorTL = c;
+            this.colorTR = c;
+        }
+        if (json.has("colorBottom")) {
+            int c = Color.ofJson(json.get("colorBottom"));
+            this.colorBL = c;
+            this.colorBR = c;
+        }
+        if (json.has("colorLeft")) {
+            int c = Color.ofJson(json.get("colorLeft"));
+            this.colorTL = c;
+            this.colorBL = c;
+        }
+        if (json.has("colorRight")) {
+            int c = Color.ofJson(json.get("colorRight"));
+            this.colorTR = c;
+            this.colorBR = c;
+        }
+        setColor(json, val -> this.colorTL = val, "colorTopLeft", "colorTL");
+        setColor(json, val -> this.colorTR = val, "colorTopRight", "colorTR");
+        setColor(json, val -> this.colorBL = val, "colorBottomLeft", "colorBL");
+        setColor(json, val -> this.colorBR = val, "colorBottomRight", "colorBR");
+        this.cornerRadius = JsonHelper.getInt(json, 0, "cornerRadius");
+        this.cornerSegments = JsonHelper.getInt(json, 10, "cornerSegments");
+        if (JsonHelper.getBoolean(json, false, "solid")) {
+            this.borderThickness = 0;
+        } else if (JsonHelper.getBoolean(json, false, "hollow")) {
+            this.borderThickness = 1;
+        } else {
+            this.borderThickness = JsonHelper.getFloat(json, 0, "borderThickness");
+        }
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        json.addProperty("colorTL", this.colorTL);
+        json.addProperty("colorTR", this.colorTR);
+        json.addProperty("colorBL", this.colorBL);
+        json.addProperty("colorBR", this.colorBR);
+        json.addProperty("cornerRadius", this.cornerRadius);
+        json.addProperty("cornerSegments", this.cornerSegments);
+        json.addProperty("borderThickness", this.borderThickness);
+        return true;
+    }
+
+    private void setColor(JsonObject json, IntConsumer color, String... keys) {
+        JsonElement element = JsonHelper.getJsonElement(json, keys);
+        if (element != null) {
+            color.accept(Color.ofJson(element));
+        }
+    }
+
+    @Override
+    public Rectangle interpolate(Rectangle start, Rectangle end, float t) {
+        this.cornerRadius = Interpolations.lerp(start.cornerRadius, end.cornerRadius, t);
+        this.cornerSegments = Interpolations.lerp(start.cornerSegments, end.cornerSegments, t);
+        this.colorTL = Color.lerp(start.colorTL, end.colorTL, t);
+        this.colorTR = Color.lerp(start.colorTR, end.colorTR, t);
+        this.colorBL = Color.lerp(start.colorBL, end.colorBL, t);
+        this.colorBR = Color.lerp(start.colorBR, end.colorBR, t);
+        return this;
+    }
+
+    @Override
+    public Rectangle copyOrImmutable() {
+        return new Rectangle()
+                .color(this.colorTL, this.colorTR, this.colorBL, this.colorBR)
+                .cornerRadius(this.cornerRadius)
+                .cornerSegments(this.cornerSegments)
+                .canApplyTheme(this.canApplyTheme);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/SchemaRenderer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/SchemaRenderer.java
new file mode 100644
index 00000000000..c9f4a10a285
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/SchemaRenderer.java
@@ -0,0 +1,96 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.schema.ISchema;
+import com.gregtechceu.gtceu.client.mui.schemarenderer.BaseSchemaRenderer;
+import com.gregtechceu.gtceu.client.mui.schemarenderer.BlockHighlight;
+import com.gregtechceu.gtceu.client.mui.schemarenderer.Camera;
+
+import net.minecraft.world.phys.BlockHitResult;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import lombok.experimental.Tolerate;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.*;
+
+@Accessors(fluent = true, chain = true)
+public class SchemaRenderer extends BaseSchemaRenderer {
+
+    @Setter
+    protected DoubleSupplier scale;
+    @Setter
+    protected BooleanSupplier disableBER;
+    @Setter
+    protected Consumer<SchemaRenderer> afterRender;
+    @Setter
+    protected BiConsumer<Camera, ISchema> cameraFunc;
+    @Setter
+    protected Supplier<BlockHighlight> highlight;
+    @Setter
+    protected boolean isometric = false;
+    @Setter
+    private boolean rayTracing = false;
+
+    public SchemaRenderer(ISchema schema) {
+        super(schema);
+    }
+
+    @Tolerate
+    public SchemaRenderer scale(double scale) {
+        this.scale = () -> scale;
+        return this;
+    }
+
+    @Tolerate
+    public SchemaRenderer disableBER(boolean disableBER) {
+        this.disableBER = () -> disableBER;
+        return this;
+    }
+
+    public SchemaRenderer highlightRenderer(BlockHighlight highlight) {
+        this.highlight = () -> highlight;
+        this.rayTracing = true;
+        return this;
+    }
+
+    @Override
+    protected void onSetupCamera() {
+        if (this.scale != null) {
+            camera().scaleDistanceKeepLookAt((float) this.scale.getAsDouble());
+        }
+        if (this.cameraFunc != null) {
+            this.cameraFunc.accept(camera(), schema());
+        }
+    }
+
+    @Override
+    protected void onRendered() {
+        if (this.afterRender != null) {
+            this.afterRender.accept(this);
+        }
+    }
+
+    @Override
+    protected void onSuccessfulRayTrace(PoseStack poseStack, @NotNull BlockHitResult result) {
+        if (this.highlight != null) {
+            this.highlight.get().renderHighlight(poseStack, result, camera().pos());
+        }
+    }
+
+    @Override
+    public boolean doRayTrace() {
+        return this.rayTracing;
+    }
+
+    @Override
+    public boolean isBEREnabled() {
+        return this.disableBER == null || !this.disableBER.getAsBoolean();
+    }
+
+    @Override
+    public boolean isIsometric() {
+        return isometric;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Scrollbar.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Scrollbar.java
new file mode 100644
index 00000000000..6886f662488
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/Scrollbar.java
@@ -0,0 +1,69 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.gson.JsonObject;
+import lombok.Getter;
+
+public class Scrollbar implements IDrawable, IJsonSerializable {
+
+    public static final Scrollbar DEFAULT = new Scrollbar(false);
+    public static final Scrollbar VANILLA = new Scrollbar(true);
+
+    public static Scrollbar ofJson(JsonObject json) {
+        if (JsonHelper.getBoolean(json, false, "striped", "vanilla")) {
+            return VANILLA;
+        }
+        return DEFAULT;
+    }
+
+    @Getter
+    private final boolean striped;
+
+    public Scrollbar(boolean striped) {
+        this.striped = striped;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        GuiDraw.drawRect(context.getGraphics(), x, y, width, height, Color.mix(0xFFEEEEEE, widgetTheme.getColor()));
+        GuiDraw.drawRect(context.getGraphics(), x + 1, y + 1, width - 1, height - 1,
+                Color.mix(0xFF666666, widgetTheme.getColor()));
+        GuiDraw.drawRect(context.getGraphics(), x + 1, y + 1, width - 2, height - 2,
+                Color.mix(0xFFAAAAAA, widgetTheme.getColor()));
+
+        if (isStriped()) {
+            if (height <= 5 && width <= 5) return;
+            int color = widgetTheme.getTextColor();
+            if (height >= width) {
+                int start = y + 2;
+                int end = height + start - 4;
+                for (int cy = start; cy < end; cy += 2) {
+                    GuiDraw.drawRect(context.getGraphics(), x + 2, cy, width - 4, 1, color);
+                }
+            } else {
+                int start = x + 2;
+                int end = width + start - 4;
+                for (int cx = start; cx < end; cx += 2) {
+                    GuiDraw.drawRect(context.getGraphics(), cx, y + 2, 1, height - 4, color);
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean canApplyTheme() {
+        return true;
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        json.addProperty("striped", this.striped);
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/SpriteDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/SpriteDrawable.java
new file mode 100644
index 00000000000..8b2c374511b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/SpriteDrawable.java
@@ -0,0 +1,43 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+public class SpriteDrawable implements IDrawable {
+
+    private final TextureAtlasSprite sprite;
+    private boolean canApplyTheme = false;
+
+    public SpriteDrawable(TextureAtlasSprite sprite) {
+        this.sprite = sprite;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        GuiDraw.drawSprite(context.getLastGraphicsPose(), this.sprite, x, y, width, height);
+    }
+
+    @Override
+    public Widget<?> asWidget() {
+        return IDrawable.super.asWidget().size(this.sprite.contents().width(), this.sprite.contents().height());
+    }
+
+    @Override
+    public Icon asIcon() {
+        return IDrawable.super.asIcon().size(this.sprite.contents().width(), this.sprite.contents().height());
+    }
+
+    public SpriteDrawable canApplyTheme(boolean canApplyTheme) {
+        this.canApplyTheme = canApplyTheme;
+        return this;
+    }
+
+    @Override
+    public boolean canApplyTheme() {
+        return canApplyTheme;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/TabTexture.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/TabTexture.java
new file mode 100644
index 00000000000..8d7ee69158b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/TabTexture.java
@@ -0,0 +1,102 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+import lombok.Getter;
+
+import java.util.Objects;
+
+public class TabTexture {
+
+    public static TabTexture of(UITexture texture, GuiAxis axis, boolean positive, int width, int height,
+                                int textureInset) {
+        Objects.requireNonNull(texture);
+        UITexture sa, ma, ea, si, mi, ei;
+        if (axis.isVertical() && !positive) {
+            si = texture.getSubArea(0, 0, 1 / 3f, 0.5f);
+            mi = texture.getSubArea(1 / 3f, 0, 2 / 3f, 0.5f);
+            ei = texture.getSubArea(2 / 3f, 0, 1f, 0.5f);
+            sa = texture.getSubArea(0, 0.5f, 1 / 3f, 1);
+            ma = texture.getSubArea(1 / 3f, 0.5f, 2 / 3f, 1);
+            ea = texture.getSubArea(2 / 3f, 0.5f, 1f, 1);
+        } else if (axis.isVertical()) {
+            sa = texture.getSubArea(0, 0, 1 / 3f, 0.5f);
+            ma = texture.getSubArea(1 / 3f, 0, 2 / 3f, 0.5f);
+            ea = texture.getSubArea(2 / 3f, 0, 1f, 0.5f);
+            si = texture.getSubArea(0, 0.5f, 1 / 3f, 1);
+            mi = texture.getSubArea(1 / 3f, 0.5f, 2 / 3f, 1);
+            ei = texture.getSubArea(2 / 3f, 0.5f, 1f, 1);
+        } else if (axis.isHorizontal() && !positive) {
+            si = texture.getSubArea(0, 0, 0.5f, 1 / 3f);
+            mi = texture.getSubArea(0, 1 / 3f, 0.5f, 2 / 3f);
+            ei = texture.getSubArea(0, 2 / 3f, 0.5f, 1f);
+            sa = texture.getSubArea(0.5f, 0, 1, 1 / 3f);
+            ma = texture.getSubArea(0.5f, 1 / 3f, 1, 2 / 3f);
+            ea = texture.getSubArea(0.5f, 2 / 3f, 1, 1f);
+        } else if (axis.isHorizontal()) {
+            sa = texture.getSubArea(0, 0, 0.5f, 1 / 3f);
+            ma = texture.getSubArea(0, 1 / 3f, 0.5f, 2 / 3f);
+            ea = texture.getSubArea(0, 2 / 3f, 0.5f, 1f);
+            si = texture.getSubArea(0.5f, 0, 1, 1 / 3f);
+            mi = texture.getSubArea(0.5f, 1 / 3f, 1, 2 / 3f);
+            ei = texture.getSubArea(0.5f, 2 / 3f, 1, 1f);
+        } else {
+            throw new IllegalArgumentException();
+        }
+        return new TabTexture(sa, ma, ea, si, mi, ei, width, height, textureInset, axis, positive);
+    }
+
+    private final UITexture startActive;
+    private final UITexture active;
+    private final UITexture endActive;
+
+    private final UITexture startInactive;
+    private final UITexture inactive;
+    private final UITexture endInactive;
+    @Getter
+    private final int width, height;
+    @Getter
+    private final int textureInset;
+    @Getter
+    private final GuiAxis axis;
+    @Getter
+    private final boolean positive;
+
+    public TabTexture(UITexture startActive, UITexture active, UITexture endActive, UITexture startInactive,
+                      UITexture inactive, UITexture endInactive, int width, int height, int textureInset, GuiAxis axis,
+                      boolean positive) {
+        this.startActive = startActive;
+        this.active = active;
+        this.endActive = endActive;
+        this.startInactive = startInactive;
+        this.inactive = inactive;
+        this.endInactive = endInactive;
+        this.width = width;
+        this.height = height;
+        this.textureInset = textureInset;
+        this.axis = axis;
+        this.positive = positive;
+    }
+
+    public UITexture getStart(boolean active) {
+        return active ? this.startActive : this.startInactive;
+    }
+
+    public UITexture getMiddle(boolean active) {
+        return active ? this.active : this.inactive;
+    }
+
+    public UITexture getEnd(boolean active) {
+        return active ? this.endActive : this.endInactive;
+    }
+
+    public UITexture get(int location, boolean active) {
+        if (location == 0) {
+            return getMiddle(active);
+        }
+        if (location < 0) {
+            return getStart(active);
+        }
+        return getEnd(active);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/TiledUITexture.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/TiledUITexture.java
new file mode 100644
index 00000000000..aa94aee4431
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/TiledUITexture.java
@@ -0,0 +1,55 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.resources.ResourceLocation;
+
+import com.google.gson.JsonObject;
+import com.mojang.blaze3d.systems.RenderSystem;
+
+public class TiledUITexture extends UITexture {
+
+    private final int imageWidth, imageHeight;
+
+    /**
+     * Use {@link UITexture#builder()} with {@link Builder#tiled()}
+     */
+    TiledUITexture(ResourceLocation location, float u0, float v0, float u1, float v1, int imageWidth, int imageHeight,
+                   ColorType colorType, boolean nonOpaque) {
+        super(location, u0, v0, u1, v1, colorType, nonOpaque);
+        this.imageWidth = imageWidth;
+        this.imageHeight = imageHeight;
+    }
+
+    @Override
+    public void draw(GuiContext context, float x, float y, float width, float height) {
+        if (width == this.imageWidth && height == this.imageHeight) {
+            super.draw(context, x, y, width, height);
+            return;
+        }
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        GuiDraw.drawTiledTexture(context.getLastGraphicsPose(), this.location, x, y, width, height,
+                this.u0, this.v0, this.u1, this.v1,
+                this.imageWidth, this.imageHeight, 0);
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        super.saveToJson(json);
+        if (json.entrySet().size() > 1) {
+            json.addProperty("tiled", true);
+        }
+        return true;
+    }
+
+    @Override
+    protected TiledUITexture copy() {
+        return new TiledUITexture(location, u0, v0, u1, v1, imageWidth, imageHeight, colorType, nonOpaque);
+    }
+
+    @Override
+    public TiledUITexture withColorOverride(int color) {
+        return (TiledUITexture) super.withColorOverride(color);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/UITexture.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/UITexture.java
new file mode 100644
index 00000000000..d03ee52243f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/UITexture.java
@@ -0,0 +1,585 @@
+package com.gregtechceu.gtceu.api.mui.drawable;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IJsonSerializable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraft.resources.FileToIdConverter;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.Nullable;
+
+@Accessors(fluent = true, chain = true)
+public class UITexture implements IDrawable, IJsonSerializable<UITexture> {
+
+    public static final UITexture DEFAULT = fullImage("gui/options_background", ColorType.DEFAULT);
+    public static final FileToIdConverter GUI_TEXTURE_ID_CONVERTER = new FileToIdConverter("textures/gui", ".png");
+
+    private static final ResourceLocation ICONS_LOCATION = GTCEu.id("textures/gui/icons.png");
+
+    // only for usage in GuiTextures
+    static UITexture icon(String name, int x, int y, int w, int h) {
+        return UITexture.builder()
+                .location(ICONS_LOCATION)
+                .imageSize(256, 256)
+                .subAreaXYWH(x, y, w, h)
+                .iconColorType()
+                .name(name)
+                .build();
+    }
+
+    static UITexture icon(String name, int x, int y) {
+        return icon(name, x, y, 16, 16);
+    }
+
+    private static final String TEXTURES_PREFIX = "textures/";
+    private static final String PNG_SUFFIX = ".png";
+
+    @Getter
+    public final ResourceLocation location;
+    public final float u0, v0, u1, v1;
+    @Getter
+    @Nullable
+    public final ColorType colorType;
+    public final boolean nonOpaque;
+
+    private int colorOverride = 0;
+
+    /**
+     * Creates a drawable texture
+     *
+     * @param location  location of the texture
+     * @param u0        x offset of the image (0-1)
+     * @param v0        y offset of the image (0-1)
+     * @param u1        x end offset of the image (0-1)
+     * @param v1        y end offset of the image (0-1)
+     * @param colorType a function to get which color from a widget theme should be used to color this texture.
+     */
+    public UITexture(ResourceLocation location, float u0, float v0, float u1, float v1, @Nullable ColorType colorType) {
+        this(location, u0, v0, u1, v1, colorType, false);
+    }
+
+    /**
+     * Creates a drawable texture
+     *
+     * @param location  location of the texture
+     * @param u0        x offset of the image (0-1)
+     * @param v0        y offset of the image (0-1)
+     * @param u1        x end offset of the image (0-1)
+     * @param v1        y end offset of the image (0-1)
+     * @param colorType a function to get which color from a widget theme should be used to color this texture.
+     * @param nonOpaque whether the texture should draw with blend (if true) or not (if false)
+     */
+    public UITexture(ResourceLocation location, float u0, float v0, float u1, float v1, @Nullable ColorType colorType,
+                     boolean nonOpaque) {
+        this.colorType = colorType;
+        boolean png = !location.getPath().endsWith(".png");
+        boolean textures = !location.getPath().startsWith("textures/");
+        if (png || textures) {
+            String path = location.getPath();
+            path = png ? (textures ? TEXTURES_PREFIX + path + PNG_SUFFIX : path + PNG_SUFFIX) : TEXTURES_PREFIX + path;
+            location = new ResourceLocation(location.getNamespace(), path);
+        }
+        this.location = location;
+        this.u0 = u0;
+        this.v0 = v0;
+        this.u1 = u1;
+        this.v1 = v1;
+        this.nonOpaque = nonOpaque;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static UITexture fullImage(ResourceLocation location) {
+        return new UITexture(location, 0, 0, 1, 1, null);
+    }
+
+    public static UITexture fullImage(String location) {
+        return fullImage(new ResourceLocation(location), null);
+    }
+
+    public static UITexture fullImage(String mod, String location) {
+        return fullImage(new ResourceLocation(mod, location), null);
+    }
+
+    public static UITexture fullImage(ResourceLocation location, ColorType colorType) {
+        return new UITexture(location, 0, 0, 1, 1, colorType);
+    }
+
+    public static UITexture fullImage(String location, ColorType colorType) {
+        return fullImage(new ResourceLocation(location), colorType);
+    }
+
+    public static UITexture fullImage(String mod, String location, ColorType colorType) {
+        return fullImage(new ResourceLocation(mod, location), colorType);
+    }
+
+    public UITexture getSubArea(Area bounds) {
+        return getSubArea(bounds.x, bounds.y, bounds.ex(), bounds.ey());
+    }
+
+    /**
+     * Returns a texture with a sub area relative to this area texture
+     *
+     * @param uStart x offset of the image (0-1)
+     * @param vStart y offset of the image (0-1)
+     * @param uEnd   x end offset of the image (0-1)
+     * @param vEnd   y end offset of the image (0-1)
+     * @return relative sub area
+     */
+    public UITexture getSubArea(float uStart, float vStart, float uEnd, float vEnd) {
+        return new UITexture(this.location, lerpU(uStart), lerpV(vStart), lerpU(uEnd), lerpV(vEnd), this.colorType);
+    }
+
+    protected final float lerpU(float u) {
+        return Interpolations.lerp(this.u0, this.u1, u);
+    }
+
+    protected final float lerpV(float v) {
+        return Interpolations.lerp(this.v0, this.v1, v);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        applyColor(this.colorType != null ? this.colorType.getColor(widgetTheme) :
+                ColorType.DEFAULT.getColor(widgetTheme));
+        draw(context, (float) x, y, width, height);
+    }
+
+    public void draw(GuiContext context, float x, float y, float width, float height) {
+        GuiDraw.drawTexture(context.getLastGraphicsPose(), this.location, x, y, x + width, y + height, this.u0, this.v0,
+                this.u1, this.v1);
+    }
+
+    public void drawSubArea(GuiContext context, float x, float y, float width, float height, float uStart, float vStart,
+                            float uEnd,
+                            float vEnd, WidgetTheme widgetTheme) {
+        applyColor(this.colorType != null ? this.colorType.getColor(widgetTheme) :
+                ColorType.DEFAULT.getColor(widgetTheme));
+        GuiDraw.drawTexture(context.getLastGraphicsPose(), this.location, x, y, x + width, y + height, lerpU(uStart),
+                lerpV(vStart), lerpU(uEnd),
+                lerpV(vEnd), this.nonOpaque);
+    }
+
+    @Override
+    public boolean canApplyTheme() {
+        return this.colorType != null;
+    }
+
+    @Override
+    public void applyColor(int themeColor) {
+        if (this.colorOverride != 0) {
+            Color.setGlColor(this.colorOverride);
+        } else {
+            IDrawable.super.applyColor(themeColor);
+        }
+    }
+
+    public static UITexture parseFromJson(JsonObject json) {
+        String name = JsonHelper.getString(json, null, "name", "id");
+        if (name != null) {
+            UITexture drawable = DrawableSerialization.getTexture(name);
+            if (drawable != null) return drawable;
+        }
+        Builder builder = builder();
+        builder.location(JsonHelper.getString(json, GTCEu.MOD_ID + ":gui/widgets/error", "location"))
+                .imageSize(JsonHelper.getInt(json, defaultImageWidth, "imageWidth", "iw"),
+                        JsonHelper.getInt(json, defaultImageHeight, "imageHeight", "ih"));
+        boolean mode1 = json.has("x") || json.has("y") || json.has("w") || json.has("h") || json.has("width") ||
+                json.has("height");
+        boolean mode2 = json.has("u0") || json.has("v0") || json.has("u1") || json.has("u1");
+        if (mode1) {
+            if (mode2) {
+                throw new JsonParseException("Tried to specify x, y, w, h and u0, v0, u1, v1!");
+            }
+            builder.subAreaXYWH(JsonHelper.getInt(json, 0, "x"),
+                    JsonHelper.getInt(json, 0, "y"),
+                    JsonHelper.getInt(json, builder.iw, "w", "width"),
+                    JsonHelper.getInt(json, builder.ih, "h", "height"));
+        } else if (mode2) {
+            builder.subAreaUV(JsonHelper.getFloat(json, 0, "u0"),
+                    JsonHelper.getFloat(json, 0, "v0"),
+                    JsonHelper.getFloat(json, 1, "u1"),
+                    JsonHelper.getFloat(json, 1, "v1"));
+        }
+        int bl = JsonHelper.getInt(json, 0, "bl", "borderLeft", "borderX", "border");
+        int br = JsonHelper.getInt(json, 0, "br", "borderRight", "borderY", "border");
+        int bt = JsonHelper.getInt(json, 0, "bt", "borderTop", "borderBottom", "border");
+        int bb = JsonHelper.getInt(json, 0, "bb", "borderBottom", "borderTop", "border");
+        if (bl > 0 || br > 0 || bt > 0 || bb > 0) {
+            builder.adaptable(bl, bt, br, bb);
+        }
+        if (JsonHelper.getBoolean(json, false, "tiled")) {
+            builder.tiled();
+        }
+        String colorTypeName = JsonHelper.getString(json, null, "colorType", "color");
+        if (colorTypeName != null) {
+            builder.colorType(ColorType.get(colorTypeName));
+        } else if (JsonHelper.getBoolean(json, false, "canApplyTheme")) {
+            builder.canApplyTheme();
+        }
+        UITexture uiTexture = builder.build();
+        uiTexture.colorOverride = JsonHelper.getColor(json, 0, "colorOverride");
+        return uiTexture;
+    }
+
+    @Override
+    public boolean saveToJson(JsonObject json) {
+        String name = DrawableSerialization.getTextureId(this);
+        if (name != null) {
+            json.addProperty("id", name);
+            return true;
+        }
+        json.addProperty("location", this.location.toString());
+        json.addProperty("u0", this.u0);
+        json.addProperty("v0", this.v0);
+        json.addProperty("u1", this.u1);
+        json.addProperty("v1", this.v1);
+        if (this.colorType != null) json.addProperty("colorType", this.colorType.getName());
+        json.addProperty("colorOverride", this.colorOverride);
+        return true;
+    }
+
+    protected UITexture copy() {
+        return new UITexture(this.location, this.u0, this.v0, this.u1, this.v1, this.colorType);
+    }
+
+    public UITexture withColorOverride(int color) {
+        UITexture t = copy();
+        t.colorOverride = color;
+        return t;
+    }
+
+    private static int defaultImageWidth = 16, defaultImageHeight = 16;
+
+    public static void setDefaultImageSize(int w, int h) {
+        defaultImageWidth = w;
+        defaultImageHeight = h;
+    }
+
+    /**
+     * A builder class to help create image textures.
+     */
+    public static class Builder {
+
+        private ResourceLocation location;
+        private int iw = defaultImageWidth, ih = defaultImageHeight;
+        private int x, y, w, h;
+        private float u0 = 0, v0 = 0, u1 = 1, v1 = 1;
+        private Mode mode = Mode.FULL;
+        private int bl = 0, bt = 0, br = 0, bb = 0;
+        private String name;
+        private boolean tiled = false;
+        private ColorType colorType = null;
+        private boolean nonOpaque = false;
+
+        /**
+         * @param loc location of the image to draw
+         */
+        public Builder location(ResourceLocation loc) {
+            this.location = loc;
+            return this;
+        }
+
+        /**
+         * @param mod  mod location of the image to draw
+         * @param path path of the image to draw
+         */
+        public Builder location(String mod, String path) {
+            this.location = new ResourceLocation(mod, path);
+            return this;
+        }
+
+        /**
+         * @param path path of the image to draw in minecraft asset folder
+         */
+        public Builder location(String path) {
+            this.location = new ResourceLocation(path);
+            return this;
+        }
+
+        /**
+         * Set the image size. Required for {@link #tiled()}, {@link #adaptable(int, int)} and
+         * {@link #subAreaXYWH(int, int, int, int)}
+         *
+         * @param w image width
+         * @param h image height
+         */
+        public Builder imageSize(int w, int h) {
+            this.iw = w;
+            this.ih = h;
+            return this;
+        }
+
+        /**
+         * This will make the image be drawn tiled rather than stretched.
+         *
+         * @param imageWidth  image width
+         * @param imageHeight image height
+         */
+        public Builder tiled(int imageWidth, int imageHeight) {
+            return tiled().imageSize(imageWidth, imageHeight);
+        }
+
+        /**
+         * This will make the image be drawn tiled rather than stretched.
+         */
+        public Builder tiled() {
+            this.tiled = true;
+            return this;
+        }
+
+        /**
+         * Will draw the whole image file.
+         */
+        public Builder fullImage() {
+            this.mode = Mode.FULL;
+            return this;
+        }
+
+        /**
+         * Specify a sub area of the image in pixels, with a position and a size.
+         *
+         * @param x x in pixels
+         * @param y y in pixels
+         * @param w width in pixels
+         * @param h height in pixels
+         */
+        public Builder subAreaXYWH(int x, int y, int w, int h) {
+            this.mode = Mode.PIXEL;
+            this.x = x;
+            this.y = y;
+            this.w = w;
+            this.h = h;
+            return this;
+        }
+
+        /**
+         * Specify a sub area of the image in pixels, with a start position and an end position.
+         *
+         * @param left   start position on the x-axis (equivalent to x in above methods)
+         * @param top    start position on the y-axis (equivalent to y in above methods)
+         * @param right  end position on the x-axis (equivalent to x + w in above methods)
+         * @param bottom end position on the y-axis (equivalent to y + h in above methods)
+         */
+        public Builder subAreaLTRB(int left, int top, int right, int bottom) {
+            return subAreaXYWH(left, top, right - left, bottom - top);
+        }
+
+        /**
+         * Specify a sub area of the image in relative uv values (0 - 1). u0 and v0 are start positions, while u1 and v1
+         * are end positions.
+         * This means that the relative size is u1 - u0 and v1 - v0.
+         *
+         * @param u0 x start
+         * @param v0 y start
+         * @param u1 x end
+         * @param v1 y end
+         */
+        public Builder subAreaUV(float u0, float v0, float u1, float v1) {
+            this.mode = Mode.RELATIVE;
+            this.u0 = u0;
+            this.v0 = v0;
+            this.u1 = u1;
+            this.v1 = v1;
+            return this;
+        }
+
+        /**
+         * This will draw the corners, edges and body of the image separately. This will only stretch/tile the
+         * body so the border looks right on all sizes. This is also known as a
+         * <a href="https://en.wikipedia.org/wiki/9-slice_scaling">9-slice texture</a>.
+         *
+         * @param bl left border width. Can be 0.
+         * @param bt top border width. Can be 0.
+         * @param br right border width. Can be 0.
+         * @param bb bottom border width. Can be 0.
+         */
+        public Builder adaptable(int bl, int bt, int br, int bb) {
+            this.bl = bl;
+            this.bt = bt;
+            this.br = br;
+            this.bb = bb;
+            return this;
+        }
+
+        /**
+         * This will draw the corners, edges and body of the image separately. This will only stretch/tile the
+         * body so the border looks right on all sizes. This is also known as a
+         * <a href="https://en.wikipedia.org/wiki/9-slice_scaling">9-slice texture</a>.
+         *
+         * @param borderX left and right border width. Can be 0.
+         * @param borderY top and bottom border width. Can be 0
+         */
+        public Builder adaptable(int borderX, int borderY) {
+            return adaptable(borderX, borderY, borderX, borderY);
+        }
+
+        /**
+         * This will draw the corners, edges and body of the image separately. This will only stretch/tile the
+         * body so the border looks right on all sizes. This is also known as a
+         * <a href="https://en.wikipedia.org/wiki/9-slice_scaling">9-slice texture</a>.
+         *
+         * @param border border width
+         */
+        public Builder adaptable(int border) {
+            return adaptable(border, border);
+        }
+
+        /**
+         * Specify if theme color should apply to this texture.
+         *
+         * @see #defaultColorType()
+         */
+        public Builder canApplyTheme() {
+            return defaultColorType();
+        }
+
+        /**
+         * Sets a function which defines how theme color is applied to this texture. Null means no color will be
+         * applied.
+         * <il>
+         * <li>Background textures should use {@link ColorType#DEFAULT} or {@link #defaultColorType()}</li>
+         * <li>White icons (only has a shape and some grey shading) should use {@link ColorType#ICON} or
+         * {@link #iconColorType()}</li>
+         * <li>Text should use {@link ColorType#TEXT} or {@link #textColorType()}</li>
+         * <li>Everything else (f.e. colored icons and overlays) should use null</li>
+         * </il>
+         *
+         * @param colorType function which defines how theme color is applied to this texture
+         * @return this
+         */
+        public Builder colorType(@Nullable ColorType colorType) {
+            this.colorType = colorType;
+            return this;
+        }
+
+        /**
+         * Sets this texture to use default theme color.
+         * Usually used for background textures (grey shaded).
+         *
+         * @return this
+         * @see #colorType(ColorType)
+         */
+        public Builder defaultColorType() {
+            return colorType(ColorType.DEFAULT);
+        }
+
+        /**
+         * Sets this texture to use text theme color.
+         * Usually used for texts.
+         *
+         * @return this
+         * @see #colorType(ColorType)
+         */
+        public Builder textColorType() {
+            return colorType(ColorType.TEXT);
+        }
+
+        /**
+         * Sets this texture to use icon theme color.
+         * Usually used for grey shaded icons without color.
+         *
+         * @return this
+         * @see #colorType(ColorType)
+         */
+        public Builder iconColorType() {
+            return colorType(ColorType.ICON);
+        }
+
+        /**
+         * Registers the texture with a name, so it can be used in json without creating the texture again.
+         * By default, theme color is applicable.
+         *
+         * @param name texture name
+         */
+        public Builder name(String name) {
+            this.name = name;
+            return this;
+        }
+
+        /**
+         * Sets this texture as at least partially transparent, will not disable glBlend when drawing.
+         */
+        public Builder nonOpaque() {
+            this.nonOpaque = true;
+            return this;
+        }
+
+        /**
+         * Creates the texture
+         *
+         * @return the created texture
+         */
+        public UITexture build() {
+            UITexture texture = create();
+            if (this.name == null) {
+                String[] p = texture.location.getPath().split("/");
+                p = p[p.length - 1].split("\\.");
+                this.name = texture.location.getNamespace().equals(GTCEu.MOD_ID) ? p[0] :
+                        texture.location.getNamespace() + ":" + p[0];
+                if (DrawableSerialization.getTexture(this.name) != null) {
+                    return texture;
+                }
+            }
+            DrawableSerialization.registerTexture(this.name, texture);
+            return texture;
+        }
+
+        private UITexture create() {
+            if (this.location == null) {
+                throw new NullPointerException("Location must not be null");
+            }
+            if (this.iw <= 0 || this.ih <= 0) throw new IllegalArgumentException("Image size must be > 0");
+            if (this.mode == Mode.FULL) {
+                this.u0 = 0;
+                this.v0 = 0;
+                this.u1 = 1;
+                this.v1 = 1;
+                this.mode = Mode.RELATIVE;
+            } else if (this.mode == Mode.PIXEL) {
+                float tw = 1f / this.iw, th = 1f / this.ih;
+                this.u0 = this.x * tw;
+                this.v0 = this.y * th;
+                this.u1 = (this.x + this.w) * tw;
+                this.v1 = (this.y + this.h) * th;
+                this.mode = Mode.RELATIVE;
+            }
+            if (this.mode == Mode.RELATIVE) {
+                if (this.u0 < 0 || this.v0 < 0 || this.u1 > 1 || this.v1 > 1)
+                    throw new IllegalArgumentException("UV values must be 0 - 1");
+                if (this.bl > 0 || this.bt > 0 || this.br > 0 || this.bb > 0) {
+                    return new AdaptableUITexture(this.location, this.u0, this.v0, this.u1, this.v1, this.colorType,
+                            this.nonOpaque, this.iw, this.ih, this.bl, this.bt, this.br, this.bb, this.tiled);
+                }
+                if (this.tiled) {
+                    return new TiledUITexture(this.location, this.u0, this.v0, this.u1, this.v1, this.iw, this.ih,
+                            this.colorType, this.nonOpaque);
+                }
+                return new UITexture(this.location, this.u0, this.v0, this.u1, this.v1, this.colorType, this.nonOpaque);
+            }
+            throw new IllegalStateException();
+        }
+    }
+
+    private enum Mode {
+        FULL,
+        PIXEL,
+        RELATIVE
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/AutoMajorTickFinder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/AutoMajorTickFinder.java
new file mode 100644
index 00000000000..62a6fd327c8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/AutoMajorTickFinder.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class AutoMajorTickFinder implements MajorTickFinder {
+
+    @Getter
+    private final boolean autoAdjust;
+    @Setter
+    private double multiple = 10;
+
+    public AutoMajorTickFinder(boolean autoAdjust) {
+        this.autoAdjust = autoAdjust;
+    }
+
+    public AutoMajorTickFinder(double multiple) {
+        autoAdjust = false;
+        this.multiple = multiple;
+    }
+
+    @Override
+    public double[] find(double min, double max, double[] ticks) {
+        int s = (int) Math.ceil((max - min) / multiple) + 2;
+        if (s > ticks.length) ticks = new double[s];
+        double next = (Math.floor(min / multiple) * multiple);
+        for (int i = 0; i < s; i++) {
+            ticks[i] = next;
+            if (next > max) {
+                s = i + 1;
+                break;
+            }
+            next += multiple;
+        }
+        if (ticks.length > s) ticks[s] = Float.NaN;
+        return ticks;
+    }
+
+    void calculateAutoTickMultiple(double min, double max) {
+        double step = (max - min) / 5;
+        if (step < 1) {
+            int significantPlaces = (int) Math.abs(Math.log10(step)) + 2;
+            double ten = Math.pow(10, significantPlaces);
+            step = (int) (step * ten + 0.2f) / ten;
+        } else if (step == 1) {
+            step = 0.2f;
+        } else {
+            int significantPlaces = (int) Math.log10(step) - 1;
+            double ten = Math.pow(10, significantPlaces);
+            step = (int) (step / ten + 0.2f) * ten;
+        }
+        setMultiple(step);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/AutoMinorTickFinder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/AutoMinorTickFinder.java
new file mode 100644
index 00000000000..6354eff7af7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/AutoMinorTickFinder.java
@@ -0,0 +1,32 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+public class AutoMinorTickFinder implements MinorTickFinder {
+
+    private int amountBetweenMajors;
+
+    public AutoMinorTickFinder(int amountBetweenMajors) {
+        this.amountBetweenMajors = amountBetweenMajors;
+    }
+
+    @Override
+    public double[] find(double min, double max, double[] majorTicks, double[] ticks) {
+        int s = majorTicks.length * this.amountBetweenMajors;
+        if (ticks.length < s) ticks = new double[s];
+        int k = 0;
+        for (int i = 0; i < majorTicks.length - 1; i++) {
+            if (Double.isNaN(majorTicks[i + 1])) break;
+            double next = majorTicks[i];
+            double d = (majorTicks[i + 1] - next) / (amountBetweenMajors + 1);
+            for (int j = 0; j < amountBetweenMajors; j++) {
+                next += d;
+                if (next >= min) ticks[k++] = next;
+                if (next > max) {
+                    ticks[k] = Float.NaN;
+                    break;
+                }
+            }
+        }
+        if (k < ticks.length) ticks[k] = Float.NaN;
+        return ticks;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphAxis.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphAxis.java
new file mode 100644
index 00000000000..e5670579252
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphAxis.java
@@ -0,0 +1,201 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.DAM;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.joml.Matrix4f;
+
+import java.text.DecimalFormat;
+import java.util.List;
+
+@ApiStatus.Experimental
+public class GraphAxis {
+
+    private static final TextRenderer textRenderer = new TextRenderer();
+    private static final float TICK_LABEL_SCALE = 0.4f;
+    private static final float AXIS_LABEL_SCALE = 1f;
+    private static final float TICK_LABEL_OFFSET = 2f;
+    private static final float AXIS_LABEL_OFFSET = 3f;
+
+    @Getter
+    public final GuiAxis axis;
+
+    public double[] majorTicks = new double[8];
+    public double[] minorTicks = new double[16];
+    public TextRenderer.Line[] tickLabels = new TextRenderer.Line[8];
+    private float maxLabelWidth = 0;
+    @Getter
+    public MajorTickFinder majorTickFinder = new AutoMajorTickFinder(true);
+    @Getter
+    public MinorTickFinder minorTickFinder = new AutoMinorTickFinder(2);
+    @Getter
+    public String label;
+    @Getter
+    public double min, max;
+    public boolean autoLimits = true;
+    public float[] data;
+
+    public GraphAxis(GuiAxis axis) {
+        this.axis = axis;
+    }
+
+    void compute(List<Plot> plots) {
+        if (this.autoLimits) {
+            if (plots.isEmpty()) {
+                this.min = 0;
+                this.max = 0;
+            } else if (plots.size() == 1) {
+                this.min = DAM.min(plots.get(0).getData(this.axis));
+                this.max = DAM.max(plots.get(0).getData(this.axis));
+            } else {
+                double min = Double.MAX_VALUE, max = Double.MIN_VALUE;
+                for (Plot plot : plots) {
+                    double m = DAM.min(plot.getData(this.axis));
+                    if (m < min) min = m;
+                    m = DAM.max(plot.getData(this.axis));
+                    if (m > max) max = m;
+                }
+                this.min = min;
+                this.max = max;
+            }
+            if (this.axis.isVertical()) {
+                double padding = (this.max - this.min) * 0.05f;
+                this.max += padding;
+                this.min -= padding;
+            }
+        }
+        if (this.majorTickFinder instanceof AutoMajorTickFinder tickFinder && tickFinder.isAutoAdjust()) {
+            tickFinder.calculateAutoTickMultiple(this.min, this.max);
+        }
+        this.majorTicks = this.majorTickFinder.find(this.min, this.max, this.majorTicks);
+        this.minorTicks = this.minorTickFinder.find(this.min, this.max, this.majorTicks, this.minorTicks);
+
+        if (this.tickLabels.length < this.majorTicks.length) {
+            this.tickLabels = new TextRenderer.Line[this.majorTicks.length];
+        }
+        textRenderer.setScale(TICK_LABEL_SCALE);
+        this.maxLabelWidth = 0;
+        double maxDiff = DAM.max(DAM.diff(this.majorTicks));
+        int significantPlaces = (int) Math.abs(Math.log10(maxDiff)) + 2;
+        DecimalFormat format = new DecimalFormat();
+        format.setMaximumFractionDigits(significantPlaces);
+        for (int i = 0; i < this.tickLabels.length; i++) {
+            if (Double.isNaN(this.majorTicks[i])) break;
+            this.tickLabels[i] = textRenderer
+                    .line(Component.literal(format.format(this.majorTicks[i])).getVisualOrderText());
+            if (this.tickLabels[i].getWidth() > this.maxLabelWidth) {
+                this.maxLabelWidth = this.tickLabels[i].getWidth();
+            }
+        }
+    }
+
+    void applyPadding(GraphView graphView) {
+        textRenderer.setScale(TICK_LABEL_SCALE);
+        if (this.axis.isHorizontal()) {
+            graphView.sy1 -= textRenderer.getFontHeight() + TICK_LABEL_OFFSET;
+            if (this.label != null) {
+                textRenderer.setScale(AXIS_LABEL_SCALE);
+                graphView.sy1 -= textRenderer.getFontHeight() + AXIS_LABEL_OFFSET;
+            }
+        } else {
+            float off = this.maxLabelWidth + TICK_LABEL_OFFSET;
+            if (this.label != null) {
+                textRenderer.setScale(AXIS_LABEL_SCALE);
+                off += textRenderer.getFontHeight() + AXIS_LABEL_OFFSET;
+            }
+            graphView.sx0 += off;
+        }
+    }
+
+    void drawGridLines(Matrix4f pose, VertexConsumer buffer, GraphView view, GraphAxis other, boolean major, float d,
+                       int r, int g, int b, int a) {
+        double[] pos = major ? this.majorTicks : this.minorTicks;
+        float dHalf = d / 2;
+        if (axis.isHorizontal()) {
+            float otherMin = view.g2sY(other.max);
+            float otherMax = view.g2sY(other.min);
+            drawLinesOnHorizontal(pose, buffer, view, pos, dHalf, otherMin, otherMax, r, g, b, a);
+        } else {
+            float otherMin = view.g2sX(other.min);
+            float otherMax = view.g2sX(other.max);
+            drawLinesOnVertical(pose, buffer, view, pos, dHalf, otherMin, otherMax, r, g, b, a);
+        }
+    }
+
+    void drawTicks(Matrix4f pose, VertexConsumer buffer, GraphView view, GraphAxis other, boolean major,
+                   float thickness, float length, int r, int g, int b, int a) {
+        double[] pos = major ? this.majorTicks : this.minorTicks;
+        float dHalf = thickness / 2;
+        if (axis.isHorizontal()) {
+            float otherMin = view.g2sY(other.min);
+            drawLinesOnHorizontal(pose, buffer, view, pos, dHalf, otherMin - length, otherMin, r, g, b, a);
+        } else {
+            float otherMin = view.g2sX(other.min);
+            drawLinesOnVertical(pose, buffer, view, pos, dHalf, otherMin, otherMin + length, r, g, b, a);
+        }
+    }
+
+    private void drawLinesOnHorizontal(Matrix4f pose, VertexConsumer buffer, GraphView view, double[] pos, float dHalf,
+                                       float crossLow, float crossHigh, int r, int g, int b, int a) {
+        for (double p : pos) {
+            if (Double.isNaN(p)) break;
+            if (p < min || p > max) continue;
+
+            float fp = view.g2sX(p);
+
+            float x0 = fp - dHalf;
+            float x1 = fp + dHalf;
+            GuiDraw.drawRectRaw(buffer, pose, x0, crossLow, x1, crossHigh, r, g, b, a);
+        }
+    }
+
+    private void drawLinesOnVertical(Matrix4f pose, VertexConsumer buffer, GraphView view, double[] pos, float dHalf,
+                                     float crossLow, float crossHigh, int r, int g, int b, int a) {
+        for (double p : pos) {
+            if (Double.isNaN(p)) break;
+            if (p < min || p > max) continue;
+
+            float fp = view.g2sY(p);
+
+            float y0 = fp - dHalf;
+            float y1 = fp + dHalf;
+            GuiDraw.drawRectRaw(buffer, pose, crossLow, y0, crossHigh, y1, r, g, b, a);
+        }
+    }
+
+    void drawLabels(GraphView view, GraphAxis other, GuiGraphics graphics) {
+        textRenderer.setHardWrapOnBorder(false);
+        if (axis.isHorizontal()) {
+            textRenderer.setScale(TICK_LABEL_SCALE);
+            textRenderer.setAlignment(Alignment.TopCenter, 100);
+            float y = view.g2sY(other.min) + TICK_LABEL_OFFSET;
+            for (int i = 0; i < this.majorTicks.length; i++) {
+                double pos = this.majorTicks[i];
+                if (Double.isNaN(pos)) break;
+                if (pos < min || pos > max) continue;
+                textRenderer.setPos((int) (view.g2sX(pos) - 50), (int) y);
+                textRenderer.drawSimple(graphics, this.tickLabels[i].getText());
+            }
+        } else {
+            textRenderer.setScale(TICK_LABEL_SCALE);
+            textRenderer.setAlignment(Alignment.CenterRight, this.maxLabelWidth, 20);
+            float x = view.g2sX(other.min) - TICK_LABEL_OFFSET - this.maxLabelWidth;
+            for (int i = 0; i < this.majorTicks.length; i++) {
+                double pos = this.majorTicks[i];
+                if (Double.isNaN(pos)) break;
+                if (pos < min || pos > max) continue;
+                textRenderer.setPos((int) x, (int) (view.g2sY(pos) - 10));
+                textRenderer.drawSimple(graphics, this.tickLabels[i].getText());
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphDrawable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphDrawable.java
new file mode 100644
index 00000000000..3d0bcdeb1c5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphDrawable.java
@@ -0,0 +1,283 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.RenderType;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GraphDrawable implements IDrawable {
+
+    private final GraphView view = new GraphView();
+    // private IDrawable background;
+    private int backgroundColor = Color.WHITE.main;
+
+    private float majorTickThickness = 1f, majorTickLength = 3f, minorTickThickness = 0.5f, minorTickLength = 1.5f;
+    private float gridLineWidth = 0.5f;
+    private int gridLineColor = Color.withAlpha(Color.BLACK.main, 0.4f);
+    private float minorGridLineWidth = 0f;
+    private int minorGridLineColor = Color.withAlpha(Color.BLACK.main, 0.15f);
+
+    @Getter
+    private final GraphAxis x = new GraphAxis(GuiAxis.X), y = new GraphAxis(GuiAxis.Y);
+    private final List<Plot> plots = new ArrayList<>();
+
+    private boolean dirty = true;
+
+    public void redraw() {
+        this.dirty = true;
+        for (Plot plot : this.plots) plot.redraw();
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        if (this.view.setScreen(x, y, x + width, y + height) | compute()) {
+            this.x.applyPadding(this.view);
+            this.y.applyPadding(this.view);
+            this.view.setGraph(this.x.min, this.y.min, this.x.max, this.y.max);
+            this.view.postResize();
+        }
+
+        var graphics = context.getGraphics();
+        // background
+        if (this.backgroundColor != 0) {
+            GuiDraw.drawRect(graphics, this.view.sx0, this.view.sy0, this.view.getScreenWidth(),
+                    this.view.getScreenHeight(), this.backgroundColor);
+        }
+
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        var buffer = graphics.bufferSource().getBuffer(RenderType.guiOverlay());
+        // grid lines
+        drawGrid(graphics, buffer);
+
+        var stencil = context.getStencil();
+        stencil.push((int) this.view.sx0, (int) this.view.sy0, (int) (this.view.getScreenWidth() + 1),
+                (int) (this.view.getScreenHeight() + 1));
+        // plots
+        for (Plot plot : this.plots) {
+            plot.draw(graphics, this.view);
+        }
+        stencil.pop();
+        // axis ticks
+        buffer = graphics.bufferSource().getBuffer(RenderType.guiOverlay());
+        drawTicks(graphics, buffer);
+
+        // GuiDraw.drawBorderOutsideLTRB(graphics, this.view.sx0, this.view.sy0, this.view.sx1, this.view.sy1, 0.5f,
+        // Color.BLACK.main);
+        this.x.drawLabels(this.view, this.y, graphics);
+        this.y.drawLabels(this.view, this.x, graphics);
+    }
+
+    public void drawGrid(GuiGraphics graphics, VertexConsumer buffer) {
+        if (this.minorGridLineWidth > 0) {
+            int r = Color.getRed(this.minorGridLineColor);
+            int g = Color.getGreen(this.minorGridLineColor);
+            int b = Color.getBlue(this.minorGridLineColor);
+            int a = Color.getAlpha(this.minorGridLineColor);
+            this.x.drawGridLines(graphics.pose().last().pose(), buffer, this.view, this.y, false,
+                    this.minorGridLineWidth, r, g, b, a);
+        }
+        if (this.gridLineWidth > 0) {
+            int r = Color.getRed(this.gridLineColor);
+            int g = Color.getGreen(this.gridLineColor);
+            int b = Color.getBlue(this.gridLineColor);
+            int a = Color.getAlpha(this.gridLineColor);
+            var pose = graphics.pose().last().pose();
+            this.x.drawGridLines(pose, buffer, this.view, this.y, true, this.gridLineWidth, r, g, b, a);
+            this.y.drawGridLines(pose, buffer, this.view, this.x, true, this.gridLineWidth, r, g, b, a);
+        }
+    }
+
+    public void drawTicks(GuiGraphics graphics, VertexConsumer buffer) {
+        var pose = graphics.pose().last().pose();
+        this.x.drawTicks(pose, buffer, this.view, this.y, false, this.minorTickThickness, this.minorTickLength, 0, 0, 0,
+                0xFF);
+        this.y.drawTicks(pose, buffer, this.view, this.x, false, this.minorTickThickness, this.minorTickLength, 0, 0, 0,
+                0xFF);
+        this.x.drawTicks(pose, buffer, this.view, this.y, true, this.majorTickThickness, this.majorTickLength, 0, 0, 0,
+                0xFF);
+        this.y.drawTicks(pose, buffer, this.view, this.x, true, this.majorTickThickness, this.majorTickLength, 0, 0, 0,
+                0xFF);
+    }
+
+    private boolean compute() {
+        if (!this.dirty) return false;
+        this.dirty = false;
+        this.x.compute(this.plots);
+        this.y.compute(this.plots);
+        int colorIndex = 0;
+        for (Plot plot : this.plots) {
+            if (plot.defaultColor) {
+                plot.color = Plot.DEFAULT_PLOT_COLORS[colorIndex];
+                if (++colorIndex == Plot.DEFAULT_PLOT_COLORS.length) {
+                    colorIndex = 0;
+                }
+            }
+        }
+        return true;
+    }
+
+    public GraphDrawable autoXLim() {
+        this.x.autoLimits = true;
+        redraw();
+        return this;
+    }
+
+    public GraphDrawable autoYLim() {
+        this.y.autoLimits = true;
+        redraw();
+        return this;
+    }
+
+    public GraphDrawable xLim(float min, float max) {
+        this.x.min = min;
+        this.x.max = max;
+        this.x.autoLimits = false;
+        redraw();
+        return this;
+    }
+
+    public GraphDrawable yLim(float min, float max) {
+        this.y.min = min;
+        this.y.max = max;
+        this.y.autoLimits = false;
+        redraw();
+        return this;
+    }
+
+    public GraphDrawable majorTickStyle(float thickness, float length) {
+        this.majorTickThickness = thickness;
+        this.majorTickLength = length;
+        return this;
+    }
+
+    public GraphDrawable minorTickStyle(float thickness, float length) {
+        this.minorTickThickness = thickness;
+        this.minorTickLength = length;
+        return this;
+    }
+
+    public GraphDrawable xTickFinder(MajorTickFinder majorTickFinder, MinorTickFinder minorTickFinder) {
+        this.x.majorTickFinder = majorTickFinder;
+        this.x.minorTickFinder = minorTickFinder;
+        redraw();
+        return this;
+    }
+
+    public GraphDrawable yTickFinder(MajorTickFinder majorTickFinder, MinorTickFinder minorTickFinder) {
+        this.y.majorTickFinder = majorTickFinder;
+        this.y.minorTickFinder = minorTickFinder;
+        redraw();
+        return this;
+    }
+
+    public GraphDrawable xTickFinder(float majorMultiples, int minorTicksBetweenMajors) {
+        return xTickFinder(new AutoMajorTickFinder(majorMultiples), new AutoMinorTickFinder(minorTicksBetweenMajors));
+    }
+
+    public GraphDrawable yTickFinder(float majorMultiples, int minorTicksBetweenMajors) {
+        return yTickFinder(new AutoMajorTickFinder(majorMultiples), new AutoMinorTickFinder(minorTicksBetweenMajors));
+    }
+
+    public GraphDrawable backgroundColor(int color) {
+        if (color != 0 && Color.getAlpha(color) == 0) {
+            color = Color.withAlpha(color, 0xFF);
+        }
+        this.backgroundColor = color;
+        return this;
+    }
+
+    public GraphDrawable plot(double[] x, double[] y) {
+        return plot(new Plot().data(x, y));
+    }
+
+    public GraphDrawable plot(double[] x, double[] y, int color) {
+        return plot(new Plot()
+                .data(x, y)
+                .color(color));
+    }
+
+    public GraphDrawable plot(double[] x, double[] y, float thickness) {
+        return plot(new Plot()
+                .data(x, y)
+                .thickness(thickness));
+    }
+
+    public GraphDrawable plot(double[] x, double[] y, float thickness, int color) {
+        return plot(new Plot()
+                .data(x, y)
+                .thickness(thickness)
+                .color(color));
+    }
+
+    public GraphDrawable plot(Plot plot) {
+        this.plots.add(plot);
+        plot.redraw();
+        return this;
+    }
+
+    public GraphDrawable majorGridStyle(float thickness, int color) {
+        this.gridLineWidth = thickness;
+        this.gridLineColor = color;
+        return this;
+    }
+
+    public GraphDrawable minorGridStyle(float thickness, int color) {
+        this.minorGridLineWidth = thickness;
+        this.minorGridLineColor = color;
+        return this;
+    }
+
+    public GraphDrawable disableMajorGrid() {
+        return majorGridLineThickness(0);
+    }
+
+    public GraphDrawable disableMinorGrid() {
+        return minorGridLineThickness(0);
+    }
+
+    public GraphDrawable enableMajorGrid() {
+        return majorGridLineThickness(0.5f);
+    }
+
+    public GraphDrawable enableMinorGrid() {
+        return majorGridLineThickness(0.25f);
+    }
+
+    public GraphDrawable majorGridLineThickness(float thickness) {
+        this.gridLineWidth = thickness;
+        return this;
+    }
+
+    public GraphDrawable minorGridLineThickness(float thickness) {
+        this.minorGridLineWidth = thickness;
+        return this;
+    }
+
+    public GraphDrawable majorGridLineColor(int color) {
+        this.gridLineColor = color;
+        return this;
+    }
+
+    public GraphDrawable minorGridLineColor(int color) {
+        this.minorGridLineColor = color;
+        return this;
+    }
+
+    public GraphDrawable graphAspectRatio(float aspectRatio) {
+        this.view.setAspectRatio(aspectRatio);
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphView.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphView.java
new file mode 100644
index 00000000000..5ec4b5de883
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/GraphView.java
@@ -0,0 +1,141 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class GraphView {
+
+    @Setter
+    @Getter
+    float aspectRatio = 0;
+    // screen rectangle
+    float sx0, sy0, sx1, sy1;
+    // graph rectangle
+    double gx0, gy0, gx1, gy1;
+
+    float zeroX, zeroY;
+
+    void postResize() {
+        if (this.aspectRatio > 0) {
+            float w = sx1 - sx0, h = sy1 - sy0;
+            float properW = this.aspectRatio * h;
+            if (w > properW) {
+                float d = w - properW;
+                sx0 += d / 2;
+                sx1 -= d / 2;
+            } else if (properW > w) {
+                float properH = w / this.aspectRatio;
+                float d = h - properH;
+                sy0 += d / 2;
+                sy1 -= d / 2;
+            }
+        }
+        this.zeroX = g2sX(0);
+        this.zeroY = g2sY(0);
+    }
+
+    boolean setScreen(float x0, float y0, float x1, float y1) {
+        if (x0 != this.sx0 || y0 != this.sy0 || x1 != this.sx1 || y1 != this.sy1) {
+            this.sx0 = x0;
+            this.sy0 = y0;
+            this.sx1 = x1;
+            this.sy1 = y1;
+            return true;
+        }
+        return false;
+    }
+
+    void setGraph(double x0, double y0, double x1, double y1) {
+        this.gx0 = x0;
+        this.gy0 = y0;
+        this.gx1 = x1;
+        this.gy1 = y1;
+        this.zeroX = g2sX(0);
+        this.zeroY = g2sY(0);
+    }
+
+    public float g2sX(double v) {
+        return (float) transform(v, gx0, gx1, sx0, sx1);
+    }
+
+    public float g2sY(double v) {
+        // gy0 and gy1 inverted on purpose
+        // screen y0 is top, graph y0 is bottom
+        return (float) transform(v, gy1, gy0, sy0, sy1);
+    }
+
+    public double g2sScaleX() {
+        return scale(gx0, gx1, sx0, sx1);
+    }
+
+    public double g2sScaleY() {
+        return scale(gy1, gy0, sy0, sy1);
+    }
+
+    public double s2gX(float v) {
+        return transform(v, sx0, sx1, gx0, gx1);
+    }
+
+    public double s2gY(float v) {
+        // gy0 and gy1 inverted on purpose
+        // screen y0 is top, graph y0 is bottom
+        return transform(v, sy0, sy1, gy1, gy0);
+    }
+
+    private double transform(double v, double fromMin, double fromMax, double toMin, double toMax) {
+        v = (v - fromMin) / (fromMax - fromMin); // reverse lerp
+        return toMin + (toMax - toMin) * v;
+    }
+
+    private double scale(double fromMin, double fromMax, double toMin, double toMax) {
+        return (toMax - toMin) / (fromMax - fromMin);
+    }
+
+    public double getGraphX0() {
+        return gx0;
+    }
+
+    public double getGraphX1() {
+        return gx1;
+    }
+
+    public double getGraphY0() {
+        return gy0;
+    }
+
+    public double getGraphY1() {
+        return gy1;
+    }
+
+    public float getScreenX0() {
+        return sx0;
+    }
+
+    public float getScreenX1() {
+        return sx1;
+    }
+
+    public float getScreenY0() {
+        return sy0;
+    }
+
+    public float getScreenY1() {
+        return sy1;
+    }
+
+    public float getScreenWidth() {
+        return sx1 - sx0;
+    }
+
+    public float getScreenHeight() {
+        return sy1 - sy0;
+    }
+
+    public double getGraphWidth() {
+        return gx1 - gx0;
+    }
+
+    public double getGraphHeight() {
+        return gy1 - gy0;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/MajorTickFinder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/MajorTickFinder.java
new file mode 100644
index 00000000000..8eaf332fc2c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/MajorTickFinder.java
@@ -0,0 +1,9 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Experimental
+public interface MajorTickFinder {
+
+    double[] find(double min, double max, double[] ticks);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/MinorTickFinder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/MinorTickFinder.java
new file mode 100644
index 00000000000..325b9a1ac0a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/MinorTickFinder.java
@@ -0,0 +1,9 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Experimental
+public interface MinorTickFinder {
+
+    double[] find(double min, double max, double[] majorTicks, double[] ticks);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/Plot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/Plot.java
new file mode 100644
index 00000000000..e929ae98619
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/graph/Plot.java
@@ -0,0 +1,212 @@
+package com.gregtechceu.gtceu.api.mui.drawable.graph;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.DAM;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.client.renderer.GTRenderTypes;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.util.Mth;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import lombok.Getter;
+
+public class Plot {
+
+    public static final int[] DEFAULT_PLOT_COLORS = {
+            Color.BLUE_ACCENT.main,
+            Color.ORANGE_ACCENT.darker(0),
+            Color.GREEN.main,
+            Color.RED.main,
+            Color.DEEP_PURPLE_ACCENT.main,
+            Color.BROWN.main,
+            Color.TEAL.main,
+            Color.LIME.main
+    };
+
+    double[] xs = DAM.EMPTY;
+    double[] ys = DAM.EMPTY;
+    @Getter
+    float thickness = 1f;
+    boolean defaultColor = true;
+    @Getter
+    int color;
+
+    private float[] vertexBuffer; // screen coords need to be way less accurate than graph coords, so float is fine
+    private boolean dirty = true;
+
+    public void redraw() {
+        this.dirty = true;
+    }
+
+    private void redraw(GraphView view) {
+        float dHalf = thickness * 0.5f;
+
+        int n = xs.length * 4;
+        this.vertexBuffer = new float[n];
+        int vertexIndex = 0;
+
+        // first only calculate the start point vertices
+        // they are dependent on the first and second point
+        float x0 = view.g2sX(xs[0]);
+        float y0 = view.g2sY(ys[0]);
+        float x1 = view.g2sX(xs[1]);
+        float y1 = view.g2sY(ys[1]);
+        // last pos
+        float lx = x0;
+        float ly = y0;
+
+        float dx = x1 - x0;
+        float dy = y1 - y0;
+        float len = Mth.sqrt(dx * dx + dy * dy);
+        if (len == 0) throw new IllegalArgumentException("Graph can't handle the same point back to back!");
+        dx /= len;
+        dy /= len;
+        // perpendicular
+        float px = -dy;
+        float py = dx;
+        // last perpendicular thickness offset
+        float lpox = px * dHalf;
+        float lpoy = py * dHalf;
+
+        vertexIndex = storePoints(vertexIndex, view, lx, ly, lpox, lpoy);
+
+        // calculate all points except start and endpoint
+        // these depend on both their neighbors
+        for (int i = 1; i < xs.length - 1; i++) {
+            x0 = view.g2sX(xs[i]);
+            y0 = view.g2sY(ys[i]);
+            x1 = view.g2sX(xs[i + 1]);
+            y1 = view.g2sY(ys[i + 1]);
+
+            dx = x1 - x0;
+            dy = y1 - y0;
+            len = Mth.sqrt(dx * dx + dy * dy);
+            if (len == 0) continue;
+            dx /= len;
+            dy /= len;
+            // perpendicular
+            px = -dy;
+            py = dx;
+            // perpendicular thickness offset
+            float pox = px * dHalf;
+            float poy = py * dHalf;
+            float ox, oy;
+            if (pox == lpox && poy == lpoy) { // linear
+                ox = pox;
+                oy = poy;
+            } else {
+                // get the average offset of this and the last point and of this and the next point
+                ox = Interpolations.lerp(lpox, pox, 0.5f);
+                oy = Interpolations.lerp(lpoy, poy, 0.5f);
+                // normalize it
+                len = Mth.sqrt(ox * ox + oy * oy);
+                ox /= len;
+                oy /= len;
+                // angle between now offset vector and last perpendicular offset vector
+                float cosAngle = (ox * lpox + oy * lpoy) / (1 * dHalf);
+                // calc hypotenuse and use it to calculate the actual length of the offset vector
+                float hypotenuse = this.thickness / cosAngle;
+                ox *= hypotenuse * 0.5f;
+                oy *= hypotenuse * 0.5f;
+            }
+
+            vertexIndex = storePoints(vertexIndex, view, x0, y0, ox, oy);
+
+            lx = x0;
+            ly = y0;
+            lpox = pox;
+            lpoy = poy;
+        }
+
+        // finally calculate endpoint
+        // this depends on itself and the point before
+        int last = this.xs.length - 1;
+        x0 = lx;
+        y0 = ly;
+        x1 = view.g2sX(xs[last]);
+        y1 = view.g2sY(ys[last]);
+
+        dx = x1 - x0;
+        dy = y1 - y0;
+        len = Mth.sqrt(dx * dx + dy * dy);
+        if (len == 0) throw new IllegalArgumentException("Graph can't handle the same point back to back!");
+        dx /= len;
+        dy /= len;
+        // perpendicular
+        px = -dy;
+        py = dx;
+        // last perpendicular thickness offset
+        lpox = px * dHalf;
+        lpoy = py * dHalf;
+
+        storePoints(vertexIndex, view, x1, y1, lpox, lpoy);
+    }
+
+    private int storePoints(int index, GraphView view, float sx, float sy, float ox, float oy) {
+        this.vertexBuffer[index++] = sx - ox;
+        this.vertexBuffer[index++] = sy - oy;
+        this.vertexBuffer[index++] = sx + ox;
+        this.vertexBuffer[index++] = sy + oy;
+        return index;
+    }
+
+    public void draw(GuiGraphics graphics, GraphView view) {
+        if (xs.length == 0) return;
+        if (xs.length == 1) {
+            GuiDraw.drawRect(graphics, view.g2sX(xs[0]) - thickness / 2, view.g2sY(ys[0]) - thickness / 2, thickness,
+                    thickness, color);
+            return;
+        }
+        if (this.dirty) {
+            redraw(view);
+            this.dirty = false;
+        }
+        int r = Color.getRed(color);
+        int g = Color.getGreen(color);
+        int b = Color.getBlue(color);
+        int a = Color.getAlpha(color);
+
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        var pose = graphics.pose().last().pose();
+        var buffer = graphics.bufferSource().getBuffer(GTRenderTypes.guiTriangleStrip());
+        for (int i = 0; i < this.vertexBuffer.length; i += 2) {
+            buffer.vertex(pose, this.vertexBuffer[i], this.vertexBuffer[i + 1], 0).color(r, g, b, a).endVertex();
+        }
+    }
+
+    public double[] getX() {
+        return xs;
+    }
+
+    public double[] getY() {
+        return ys;
+    }
+
+    public double[] getData(GuiAxis axis) {
+        return axis.isHorizontal() ? this.xs : this.ys;
+    }
+
+    public Plot data(double[] x, double[] y) {
+        if (x.length != y.length) throw new IllegalArgumentException("X and Y must have the same length!");
+        this.xs = x;
+        this.ys = y;
+        redraw();
+        return this;
+    }
+
+    public Plot thickness(float thickness) {
+        this.thickness = thickness;
+        redraw();
+        return this;
+    }
+
+    public Plot color(int color) {
+        this.color = color;
+        this.defaultColor = color == 0;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/AnimatedText.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/AnimatedText.java
new file mode 100644
index 00000000000..0e2cca03ede
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/AnimatedText.java
@@ -0,0 +1,145 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.Util;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+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 org.jetbrains.annotations.Nullable;
+
+import java.util.function.IntSupplier;
+
+@Accessors(fluent = true, chain = true)
+public class AnimatedText extends StyledText {
+
+    private MutableComponent full;
+    private String fullString;
+    private String currentString = "";
+    private int currentIndex;
+    /**
+     * How fast the characters appear
+     */
+    @Setter
+    private int speed = 40; // ms per char
+    private long timeLastDraw;
+    @Setter
+    private boolean forward = true;
+
+    private boolean isAnimating = false;
+
+    public AnimatedText(IKey key) {
+        super(key);
+    }
+
+    @Override
+    public MutableComponent get() {
+        return Component.literal(this.currentString);
+    }
+
+    public void reset() {
+        this.full = null;
+    }
+
+    private void advance() {
+        if (!this.isAnimating || (this.forward && this.currentIndex >= this.fullString.length()) ||
+                (!this.forward && this.currentIndex < 0))
+            return;
+        long time = Util.getMillis();
+        int amount = (int) ((time - this.timeLastDraw) / this.speed);
+        if (amount == 0) return;
+        if (this.forward) {
+            int max = Math.min(this.fullString.length() - 1, this.currentIndex + amount);
+            this.currentIndex = Math.max(this.currentIndex, 0);
+            for (int i = this.currentIndex; i < max; i++) {
+                char c = this.fullString.charAt(i);
+                if (c == ' ') {
+                    max = Math.min(this.fullString.length() - 1, max + 1);
+                }
+                // noinspection StringConcatenationInLoop
+                this.currentString += c;
+            }
+            this.currentIndex = max;
+        } else {
+            int min = Math.max(0, this.currentIndex - amount);
+            this.currentIndex = Math.min(this.currentIndex, this.currentString.length() - 1);
+            for (int i = this.currentIndex; i >= min; i--) {
+                char c = this.fullString.charAt(i);
+                if (c == ' ') {
+                    min = Math.max(0, min - 1);
+                }
+                this.currentString = this.currentString.substring(0, i);
+            }
+            this.currentIndex = min;
+        }
+        this.timeLastDraw += (long) amount * this.speed;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        if (this.full == null || !this.full.equals(super.get())) {
+            if (this.isAnimating) {
+                this.full = super.get();
+                this.fullString = this.full.getString();
+                this.currentString = this.forward ? "" : this.fullString;
+                this.currentIndex = this.forward ? 0 : this.fullString.length() - 1;
+                this.timeLastDraw = Util.getMillis();
+            } else {
+                this.currentString = this.forward ? "" : this.fullString;
+            }
+        }
+        advance();
+        if (this.currentString.isEmpty()) return;
+        super.draw(context, x, y, width, height, widgetTheme);
+    }
+
+    public AnimatedText startAnimation() {
+        this.isAnimating = true;
+        return this;
+    }
+
+    public AnimatedText stopAnimation() {
+        this.isAnimating = false;
+        return this;
+    }
+
+    @Override
+    public @NotNull AnimatedText style(ChatFormatting formatting) {
+        return (AnimatedText) super.style(formatting);
+    }
+
+    @Override
+    public @NotNull AnimatedText alignment(Alignment alignment) {
+        return (AnimatedText) super.alignment(alignment);
+    }
+
+    @Override
+    public @NotNull AnimatedText color(int color) {
+        return color(() -> color);
+    }
+
+    @Override
+    public @NotNull AnimatedText color(@Nullable IntSupplier color) {
+        return (AnimatedText) super.color(color);
+    }
+
+    @Override
+    public @NotNull AnimatedText scale(float scale) {
+        return (AnimatedText) super.scale(scale);
+    }
+
+    @Override
+    public @NotNull AnimatedText shadow(@Nullable Boolean shadow) {
+        return (AnimatedText) super.shadow(shadow);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/BaseKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/BaseKey.java
new file mode 100644
index 00000000000..6029ace8eeb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/BaseKey.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.MutableComponent;
+
+import lombok.Getter;
+import org.apache.commons.lang3.NotImplementedException;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class BaseKey implements IKey {
+
+    @Getter
+    private @Nullable FormattingState formatting;
+
+    @Override
+    public MutableComponent getFormatted(@Nullable FormattingState parentFormatting) {
+        return FontRenderHelper.format(this.formatting, parentFormatting, get());
+    }
+
+    @Override
+    public BaseKey style(@Nullable ChatFormatting formatting) {
+        if (this.formatting == null) {
+            this.formatting = new FormattingState();
+        }
+        if (formatting == null) this.formatting.forceDefaultColor();
+        else this.formatting.add(formatting, false);
+        return this;
+    }
+
+    @Override
+    public IKey removeStyle() {
+        if (this.formatting != null) {
+            this.formatting.reset();
+        }
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return getFormatted().getString();
+    }
+
+    @Override
+    public int hashCode() {
+        throw new NotImplementedException("Implement hashCode() in subclasses");
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/ComposedLine.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/ComposedLine.java
new file mode 100644
index 00000000000..43153a27c78
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/ComposedLine.java
@@ -0,0 +1,109 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IHoverable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.locale.Language;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.util.FormattedCharSequence;
+
+import lombok.Getter;
+
+import java.util.List;
+
+public class ComposedLine implements ITextLine {
+
+    private final List<Object> elements;
+    @Getter
+    private final int width;
+    private final int height;
+
+    private float lastX, lastY;
+
+    public ComposedLine(List<Object> elements, int width, int height) {
+        this.elements = elements;
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public int getHeight(Font font) {
+        return height == font.lineHeight ? height : height + 1;
+    }
+
+    @Override
+    public void draw(GuiContext context, Font font, float x, float y, int color, boolean shadow,
+                     int availableWidth, int availableHeight) {
+        this.lastX = x;
+        this.lastY = y;
+        for (Object o : this.elements) {
+            if (o instanceof String s) {
+                float drawY = getHeight(font) / 2f - font.lineHeight / 2f;
+                context.getGraphics().drawString(font, s, x, y + drawY, color, shadow);
+                x += font.width(s);
+            } else if (o instanceof FormattedText text) {
+                float drawY = getHeight(font) / 2f - font.lineHeight / 2f;
+                FormattedCharSequence charSequence = text instanceof Component component ?
+                        component.getVisualOrderText() : Language.getInstance().getVisualOrder(text);
+                context.getGraphics().drawString(font, charSequence, x, y + drawY, color, shadow);
+                x += font.width(text);
+            } else if (o instanceof FormattedCharSequence s) {
+                float drawY = getHeight(font) / 2f - font.lineHeight / 2f;
+                context.getGraphics().drawString(font, s, x, y + drawY, color, shadow);
+                x += font.width(s);
+            } else if (o instanceof IIcon icon) {
+                float drawY = getHeight(font) / 2f - icon.getHeight() / 2f;
+                int w = icon.getWidth() > 0 ? icon.getWidth() : availableWidth;
+                icon.draw(context, (int) x, (int) (y + drawY), w, icon.getHeight(),
+                        IThemeApi.get().getDefaultTheme().getFallback().getTheme());
+                if (icon instanceof IHoverable hoverable) {
+                    hoverable.setRenderedAt((int) x, (int) (y + drawY));
+                }
+                x += w;
+            }
+        }
+    }
+
+    @Override
+    public Object getHoveringElement(Font font, int x, int y) {
+        int h0 = getHeight(font);
+        if (y < lastY || y > lastY + h0) return null; // is not hovering vertically
+        if (x < lastX || x > lastX + getWidth()) return Boolean.FALSE; // is not hovering horizontally
+        float x0 = x - this.lastX; // origin to 0
+        float x1 = 0;
+        float y0 = y - this.lastY; // origin to 0
+        for (Object o : this.elements) {
+            float w, h;
+            if (o instanceof String s) {
+                w = font.width(s);
+                h = font.lineHeight;
+            } else if (o instanceof Component c) {
+                w = font.width(c);
+                h = font.lineHeight;
+            } else if (o instanceof FormattedCharSequence s) {
+                w = font.width(s);
+                h = font.lineHeight;
+            } else if (o instanceof IIcon icon) {
+                w = icon.getWidth();
+                h = icon.getWidth();
+            } else continue;
+            if (x0 > x1 && x0 < x1 + w) {
+                // is inside horizontally
+                if (h < h0) {
+                    // is smaller than line height
+                    int lower = (int) (h0 / 2f - h / 2);
+                    int upper = (int) (h0 / 2f + h / 2 - 1f);
+                    if (y0 < lower || y0 > upper) return Boolean.FALSE; // is outside vertically
+                }
+                return o; // found hovering
+            }
+            x1 += w; // move to next element
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/CompoundKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/CompoundKey.java
new file mode 100644
index 00000000000..3b023a7f02c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/CompoundKey.java
@@ -0,0 +1,45 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class CompoundKey extends BaseKey {
+
+    private static final IKey[] EMPTY = new IKey[0];
+
+    @Getter
+    private final IKey[] keys;
+
+    public CompoundKey(IKey... keys) {
+        this.keys = keys == null || keys.length == 0 ? EMPTY : keys;
+    }
+
+    @Override
+    public MutableComponent get() {
+        return toComponent(false, null);
+    }
+
+    @Override
+    public MutableComponent getFormatted(@Nullable FormattingState parentFormatting) {
+        // formatting is prepended to each key
+        return toComponent(true, parentFormatting);
+    }
+
+    private MutableComponent toComponent(boolean formatted, @Nullable FormattingState parentFormatting) {
+        MutableComponent builder = Component.empty();
+        for (IKey key : this.keys) {
+            if (formatted) {
+                // merge parent formatting and this formatting to not lose info
+                builder.append(key.getFormatted(FormattingState.merge(parentFormatting, getFormatting())));
+            } else {
+                builder.append(key.get());
+            }
+        }
+        return builder;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/DynamicKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/DynamicKey.java
new file mode 100644
index 00000000000..abb02fb4648
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/DynamicKey.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+
+import net.minecraft.network.chat.MutableComponent;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Supplier;
+
+public class DynamicKey extends BaseKey {
+
+    private final Supplier<IKey> supplier;
+
+    public DynamicKey(Supplier<IKey> supplier) {
+        // Objects.requireNonNull(supplier.get(), "IKey returns a null string!");
+        this.supplier = supplier;
+    }
+
+    @Override
+    public MutableComponent get() {
+        return toString(false, null);
+    }
+
+    @Override
+    public MutableComponent getFormatted(@Nullable FormattingState parentFormatting) {
+        // formatting is prepended to each key
+        return toString(true, parentFormatting);
+    }
+
+    private MutableComponent toString(boolean formatted, @Nullable FormattingState parentFormatting) {
+        IKey key = this.supplier.get();
+        if (key == null) key = IKey.EMPTY;
+        if (formatted) {
+            // merge parent formatting and this formatting to no lose info
+            return key.getFormatted(FormattingState.merge(parentFormatting, getFormatting()));
+        } else {
+            return key.get();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/FontRenderHelper.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/FontRenderHelper.java
new file mode 100644
index 00000000000..07ad8d8e084
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/FontRenderHelper.java
@@ -0,0 +1,238 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.Font;
+import net.minecraft.network.chat.*;
+import net.minecraft.util.FormattedCharSequence;
+
+import org.apache.commons.lang3.mutable.MutableBoolean;
+import org.apache.commons.lang3.mutable.MutableFloat;
+import org.apache.commons.lang3.mutable.MutableInt;
+import org.apache.commons.lang3.mutable.MutableObject;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class FontRenderHelper {
+
+    private static final int min = '0', max = 'r'; // min = 48, max = 114
+    // array to access text formatting by character fast
+    private static final ChatFormatting[] formattingMap = new ChatFormatting[max - min + 1];
+
+    static {
+        for (ChatFormatting formatting : ChatFormatting.values()) {
+            char c = formatting.getChar();
+            formattingMap[c - min] = formatting;
+            if (Character.isLetter(c)) {
+                formattingMap[Character.toUpperCase(c) - min] = formatting;
+            }
+        }
+    }
+
+    /**
+     * Returns the formatting for a character with a fast array lookup.
+     *
+     * @param c formatting character
+     * @return formatting for character or null
+     */
+    @Nullable
+    public static ChatFormatting getForCharacter(char c) {
+        if (c < min || c > max) return null;
+        return formattingMap[c - min];
+    }
+
+    public static void addAfter(ChatFormatting[] state, ChatFormatting formatting, boolean removeAllOnReset) {
+        if (formatting == ChatFormatting.RESET) {
+            if (removeAllOnReset) Arrays.fill(state, null);
+            state[0] = formatting;
+            return;
+        }
+        // remove reset
+        if (removeAllOnReset) state[6] = null;
+        if (formatting.isFormat()) {
+            state[formatting.ordinal() - 15] = formatting;
+            return;
+        }
+        // color
+        state[0] = formatting;
+    }
+
+    public static MutableComponent format(@Nullable FormattingState state, @Nullable FormattingState parentState,
+                                          Component text) {
+        if (state == null) {
+            if (parentState == null) return text.copy();
+            return parentState.prependText(ChatFormatting.RESET, null).append(text);
+        }
+        return state.prependText(ChatFormatting.RESET, parentState).append(text);
+    }
+
+    public static MutableComponent formatArgs(Object[] args, @Nullable FormattingState parentState, String text,
+                                              boolean translate) {
+        if (args == null || args.length == 0) return translate ? Component.translatable(text) : Component.literal(text);
+        args = Arrays.copyOf(args, args.length);
+        for (int i = 0; i < args.length; i++) {
+            if (args[i] instanceof IKey key) {
+                // parent format + key format + key text + parent format
+                args[i] = FormattingState.appendFormat(key.getFormatted(parentState)
+                        .withStyle(ChatFormatting.RESET), parentState);
+            }
+        }
+        return translate ? Component.translatable(text, args) : Component.literal(String.format(text, args));
+    }
+
+    public static int getDefaultTextHeight() {
+        Font fr = MCHelper.getFont();
+        return fr != null ? fr.lineHeight : 9;
+    }
+
+    /**
+     * Calculates how many formatting characters there are at the given position of the string.
+     *
+     * @param s     string
+     * @param start starting index
+     * @return amount of formatting characters at index
+     */
+    public static int getFormatLength(String s, int start) {
+        int i = Math.max(0, start);
+        int l = 0;
+        for (; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == 167) {
+                if (i + 1 >= s.length()) return l;
+                if (getForCharacter(c) == null) return l;
+                l += 2;
+                i++;
+            } else {
+                return l;
+            }
+        }
+        return l;
+    }
+
+    public static FormattedCharSequence splitAtMax(FormattedCharSequence input, float maxWidth) {
+        MutableFloat cur = new MutableFloat();
+        // split the string at max width.
+        List<TextRenderer.FormattedChar> output = new ArrayList<>();
+        input.accept((pos, style, codePoint) -> {
+            if (cur.addAndGet(TextRenderer.getWidthProvider().getWidth(codePoint, style)) > maxWidth) {
+                return false;
+            }
+            output.add(new TextRenderer.FormattedChar(codePoint, style));
+            return true;
+        });
+        return fromChars(output);
+    }
+
+    public static boolean isEmpty(FormattedCharSequence input) {
+        if (input == FormattedCharSequence.EMPTY) {
+            return true;
+        }
+        MutableBoolean value = new MutableBoolean(true);
+        input.accept((pos, style, codePoint) -> {
+            value.setFalse();
+            return false;
+        });
+        return value.isTrue();
+    }
+
+    public static Component getComponentFromCharSequence(FormattedCharSequence input) {
+        List<MutableComponent> parts = new ArrayList<>();
+        StringBuilder value = new StringBuilder();
+        MutableObject<Style> lastStyle = new MutableObject<>(Style.EMPTY);
+        input.accept((pos, style, codePoint) -> {
+            // if the style changed, add the built part and reset the string builder
+            if (!style.equals(lastStyle.getValue())) {
+                lastStyle.setValue(style);
+                parts.add(Component.literal(value.toString()).setStyle(style));
+                value.setLength(0);
+            } else {
+                value.append(codePoint);
+            }
+            return true;
+        });
+        // add the last component that will be left behind
+        if (!value.isEmpty()) {
+            parts.add(Component.literal(value.toString()).setStyle(lastStyle.getValue()));
+        }
+        // remove completely empty components
+        parts.removeIf(FontRenderHelper::isEmpty);
+        // no need to join completely empty or single components
+        if (parts.isEmpty()) return Component.empty();
+        else if (parts.size() == 1) return parts.get(0);
+
+        MutableComponent composite = parts.remove(0);
+        for (Component c : parts) {
+            composite.append(c);
+        }
+        return composite;
+    }
+
+    public static boolean isEmpty(FormattedText text) {
+        if (text == FormattedText.EMPTY) return true;
+        // if the text has ANY content, this will return false.
+        return text.visit(content -> Optional.of(false)).orElse(true);
+    }
+
+    public static FormattedCharSequence fromChars(List<TextRenderer.FormattedChar> chars) {
+        int size = chars.size();
+        return switch (size) {
+            case 0 -> FormattedCharSequence.EMPTY;
+            case 1 -> chars.get(0).asSequence();
+            default -> (sink) -> {
+                for (int i = 0; i < size; i++) {
+                    TextRenderer.FormattedChar ch = chars.get(i);
+                    if (!sink.accept(i, ch.style(), ch.codePoint())) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+        };
+    }
+
+    public static FormattedCharSequence substring(FormattedCharSequence str, int start) {
+        return (sink) -> {
+            MutableInt globalPos = new MutableInt();
+            return str.accept((pos, style, codePoint) -> {
+                if (globalPos.addAndGet(1) >= start) {
+                    return sink.accept(pos, style, codePoint);
+                }
+                return true;
+            });
+        };
+    }
+
+    public static FormattedCharSequence substring(FormattedCharSequence str, int start, int end) {
+        return (sink) -> {
+            MutableInt globalPos = new MutableInt();
+            return str.accept((pos, style, codePoint) -> {
+                int current = globalPos.addAndGet(1);
+                if (current >= end) {
+                    return false;
+                } else if (current >= start) {
+                    return sink.accept(pos, style, codePoint);
+                }
+                return true;
+            });
+        };
+    }
+
+    public static int length(FormattedCharSequence str) {
+        MutableInt length = new MutableInt();
+        str.accept((positionInCurrentSequence, style, codePoint) -> {
+            length.increment();
+            return true;
+        });
+        return length.intValue();
+    }
+
+    public static List<Component> asComponents(List<String> lines) {
+        return lines.stream().<Component>map(Component::literal).toList();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/FormattingState.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/FormattingState.java
new file mode 100644
index 00000000000..57c1912d837
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/FormattingState.java
@@ -0,0 +1,219 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.Style;
+import net.minecraft.network.chat.TextColor;
+import net.minecraft.util.Unit;
+
+import org.apache.commons.lang3.builder.ToStringBuilder;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+public class FormattingState {
+
+    private @Nullable Unit reset;
+    private @Nullable TextColor color;
+    private @Nullable Boolean underline;
+    private @Nullable Boolean italic;
+    private @Nullable Boolean bold;
+    private @Nullable Boolean strikethrough;
+    private @Nullable Boolean obfuscated;
+    private boolean forceDefaultColor;
+
+    public void reset() {
+        this.reset = null;
+        this.color = null;
+        this.underline = null;
+        this.italic = null;
+        this.bold = null;
+        this.strikethrough = null;
+        this.obfuscated = null;
+        this.forceDefaultColor = false;
+    }
+
+    public void add(ChatFormatting formatting, boolean removeAllOnReset) {
+        if (formatting == ChatFormatting.RESET) {
+            if (removeAllOnReset) reset();
+            this.reset = Unit.INSTANCE;
+            return;
+        }
+        if (formatting.isFormat()) {
+            switch (formatting) {
+                case UNDERLINE -> this.underline = true;
+                case ITALIC -> this.italic = true;
+                case BOLD -> this.bold = true;
+                case STRIKETHROUGH -> this.strikethrough = true;
+                case OBFUSCATED -> this.obfuscated = true;
+            }
+            return;
+        }
+        this.color = TextColor.fromLegacyFormat(formatting);
+    }
+
+    public void forceDefaultColor() {
+        this.forceDefaultColor = true;
+        this.color = null;
+    }
+
+    public Style getFormatting(Style style) {
+        if (this.reset != null) style = Style.EMPTY;
+        if (this.color != null) style.withColor(this.color);
+        if (this.underline != null) style.withUnderlined(this.underline);
+        if (this.italic != null) style.withItalic(this.italic);
+        if (this.bold != null) style.withBold(this.bold);
+        if (this.strikethrough != null) style.withStrikethrough(this.strikethrough);
+        if (this.obfuscated != null) style.withObfuscated(this.obfuscated);
+        return style;
+    }
+
+    public MutableComponent prependText(MutableComponent builder) {
+        return prependText(builder, null);
+    }
+
+    public MutableComponent prependText(MutableComponent builder, @Nullable FormattingState fallback) {
+        prependText(this, fallback, fs -> fs.reset != null ? ChatFormatting.RESET : null, builder);
+        if (!this.forceDefaultColor) {
+            if (this.color != null) {
+                builder.withStyle(style -> style.withColor(color));
+            } else if (fallback != null && !fallback.forceDefaultColor && fallback.color != null) {
+                builder.withStyle(style -> style.withColor(fallback.color));
+            }
+        }
+        prependText(fallback, ChatFormatting.UNDERLINE, fs -> fs.underline, builder);
+        prependText(fallback, ChatFormatting.ITALIC, fs -> fs.italic, builder);
+        prependText(fallback, ChatFormatting.BOLD, fs -> fs.bold, builder);
+        prependText(fallback, ChatFormatting.STRIKETHROUGH, fs -> fs.strikethrough, builder);
+        prependText(fallback, ChatFormatting.OBFUSCATED, fs -> fs.obfuscated, builder);
+        return builder;
+    }
+
+    public MutableComponent prependText(ChatFormatting style, @Nullable FormattingState fallback) {
+        return prependText(Component.empty().withStyle(style), fallback);
+    }
+
+    public void setFrom(FormattingState state) {
+        this.reset = state.reset;
+        this.color = state.color;
+        this.underline = state.underline;
+        this.italic = state.italic;
+        this.bold = state.bold;
+        this.strikethrough = state.strikethrough;
+        this.obfuscated = state.obfuscated;
+        this.forceDefaultColor = state.forceDefaultColor;
+    }
+
+    public void parseFrom(String text) {
+        int i = -2;
+        while ((i = text.indexOf(167, i + 2)) >= 0 && i < text.length() - 1) {
+            ChatFormatting formatting = FontRenderHelper.getForCharacter(text.charAt(i + 1));
+            if (formatting != null) add(formatting, true);
+        }
+    }
+
+    public FormattingState copy() {
+        FormattingState state = new FormattingState();
+        state.setFrom(this);
+        return state;
+    }
+
+    public FormattingState merge(FormattingState state) {
+        if (state.hasReset()) {
+            setFrom(state);
+            return this;
+        }
+        if (state.color != null) this.color = state.color;
+        if (state.underline != null) this.underline = state.underline;
+        if (state.italic != null) this.italic = state.italic;
+        if (state.bold != null) this.bold = state.bold;
+        if (state.strikethrough != null) this.strikethrough = state.strikethrough;
+        if (state.obfuscated != null) this.obfuscated = state.obfuscated;
+        if (state.forceDefaultColor) forceDefaultColor();
+        return this;
+    }
+
+    public boolean hasReset() {
+        return this.reset != null;
+    }
+
+    private void prependText(@Nullable FormattingState fallback,
+                             ChatFormatting format,
+                             Function<FormattingState, @Nullable Boolean> getter,
+                             MutableComponent builder) {
+        if (getter.apply(this) == Boolean.TRUE) builder.withStyle(format);
+        else if (fallback != null && getter.apply(fallback) == Boolean.TRUE) builder.withStyle(format);
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("reset", reset)
+                .append("color", color)
+                .append("underline", underline)
+                .append("italic", italic)
+                .append("bold", bold)
+                .append("strikethrough", strikethrough)
+                .append("obfuscated", obfuscated)
+                .append("forceDefaultColor", forceDefaultColor)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        FormattingState that = (FormattingState) o;
+        return forceDefaultColor == that.forceDefaultColor && reset == that.reset && color == that.color &&
+                underline == that.underline && italic == that.italic && bold == that.bold &&
+                strikethrough == that.strikethrough && obfuscated == that.obfuscated;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reset, color, underline, italic, bold, strikethrough, obfuscated, forceDefaultColor);
+    }
+
+    private static void prependText(FormattingState state,
+                                    @Nullable FormattingState fallback,
+                                    Function<FormattingState, ChatFormatting> getter,
+                                    MutableComponent builder) {
+        if (getter.apply(state) != null) builder.withStyle(getter.apply(state));
+        else if (fallback != null && getter.apply(fallback) != null) builder.withStyle(getter.apply(fallback));
+    }
+
+    public static FormattingState merge(@Nullable FormattingState state1,
+                                        @Nullable FormattingState state2) {
+        return merge(state1, state2, null);
+    }
+
+    public static FormattingState merge(@Nullable FormattingState state1,
+                                        @Nullable FormattingState state2,
+                                        @Nullable FormattingState result) {
+        if (state1 == null) {
+            if (state2 == null) {
+                if (result == null) result = new FormattingState();
+                result.reset();
+                return result;
+            }
+            return state2;
+        } else if (state2 == null) {
+            return state1;
+        }
+        if (result == null) result = new FormattingState();
+        if (result != state1) result.setFrom(state1);
+        return result.merge(state2);
+    }
+
+    public static MutableComponent appendFormat(MutableComponent builder, @Nullable FormattingState state) {
+        return appendFormat(builder, state, null);
+    }
+
+    public static MutableComponent appendFormat(MutableComponent builder, @Nullable FormattingState state,
+                                                @Nullable FormattingState fallback) {
+        if (state == null) return builder;
+        return state.prependText(builder, fallback);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/KeyIcon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/KeyIcon.java
new file mode 100644
index 00000000000..93e19f7a5e9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/KeyIcon.java
@@ -0,0 +1,134 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+
+import lombok.Getter;
+
+/**
+ * An icon which represents a {@link IKey} object.
+ * Note: This class assumes the string will be a single line!
+ */
+public class KeyIcon implements IIcon {
+
+    @Getter
+    private final IKey key;
+    private Font overrideFont;
+    private final Box margin = new Box();
+    private boolean expandWidth, expandHeight;
+
+    public KeyIcon(IKey key) {
+        this.key = key;
+    }
+
+    public Font getFont() {
+        return this.overrideFont != null ? this.overrideFont : MCHelper.getFont();
+    }
+
+    @Override
+    public int getWidth() {
+        return expandWidth ? 0 : getActualWidth();
+    }
+
+    @Override
+    public int getHeight() {
+        return expandHeight ? 0 : getActualHeight();
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return this.key.getDefaultWidth();
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return this.key.getDefaultHeight();
+    }
+
+    public int getActualWidth() {
+        return getFont().width(key.get()) + this.margin.horizontal();
+    }
+
+    public int getActualHeight() {
+        return getFont().lineHeight + this.margin.vertical();
+    }
+
+    @Override
+    public Box getMargin() {
+        return null;
+    }
+
+    @Override
+    public IKey getWrappedDrawable() {
+        return key;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        int w = getActualWidth(), h = getActualHeight();
+        x += (int) (width / 2f - w / 2f);
+        y += (int) (height / 2f - h / 2f);
+        this.key.draw(context, x, y, width, height, widgetTheme);
+    }
+
+    public KeyIcon expandWidth() {
+        this.expandWidth = true;
+        return this;
+    }
+
+    public KeyIcon expandHeight() {
+        this.expandHeight = true;
+        return this;
+    }
+
+    public KeyIcon margin(int left, int right, int top, int bottom) {
+        this.margin.all(left, right, top, bottom);
+        return this;
+    }
+
+    public KeyIcon margin(int horizontal, int vertical) {
+        this.margin.all(horizontal, vertical);
+        return this;
+    }
+
+    public KeyIcon margin(int all) {
+        this.margin.all(all);
+        return this;
+    }
+
+    public KeyIcon marginLeft(int val) {
+        this.margin.left(val);
+        return this;
+    }
+
+    public KeyIcon marginRight(int val) {
+        this.margin.right(val);
+        return this;
+    }
+
+    public KeyIcon marginTop(int val) {
+        this.margin.top(val);
+        return this;
+    }
+
+    public KeyIcon marginBottom(int val) {
+        this.margin.bottom(val);
+        return this;
+    }
+
+    public KeyIcon font(Font fr) {
+        this.overrideFont = fr;
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return "KeyIcon(" + this.key.get() + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/LangKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/LangKey.java
new file mode 100644
index 00000000000..cd1741ec781
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/LangKey.java
@@ -0,0 +1,85 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Supplier;
+
+public class LangKey extends BaseKey {
+
+    @Getter
+    private final @Nullable Supplier<@NotNull String> keySupplier;
+    @Getter
+    private final @Nullable Supplier<@NotNull Object @Nullable []> argsSupplier;
+    private MutableComponent component;
+    private long time = -1;
+
+    public LangKey(@NotNull String key) {
+        this(key, () -> null);
+    }
+
+    public LangKey(@NotNull Component component) {
+        this.component = component.copy();
+
+        this.keySupplier = null;
+        this.argsSupplier = null;
+    }
+
+    public LangKey(@NotNull String key, @Nullable Object[] args) {
+        this(() -> Objects.requireNonNull(key), () -> args == null || args.length == 0 ? null : args);
+    }
+
+    public LangKey(@NotNull String key, @NotNull Supplier<Object[]> argsSupplier) {
+        this(() -> Objects.requireNonNull(key), argsSupplier);
+    }
+
+    public LangKey(@NotNull Supplier<String> keySupplier) {
+        this(keySupplier, () -> null);
+    }
+
+    public LangKey(@Nullable Supplier<String> keySupplier, @Nullable Supplier<Object[]> argsSupplier) {
+        this.keySupplier = Objects.requireNonNull(keySupplier);
+        this.argsSupplier = Objects.requireNonNull(argsSupplier);
+    }
+
+    @Override
+    public MutableComponent get() {
+        if (keySupplier == null || argsSupplier == null) {
+            return component;
+        }
+        if (this.time == ClientScreenHandler.getTicks()) {
+            return this.component;
+        }
+        this.time = ClientScreenHandler.getTicks();
+
+        String key = Objects.requireNonNull(this.keySupplier.get());
+        Object[] args = this.argsSupplier.get();
+        if (args != null) {
+            this.component = Component.translatable(key, args);
+        } else {
+            this.component = Component.translatable(key);
+        }
+        return component;
+    }
+
+    @Override
+    public MutableComponent getFormatted(@Nullable FormattingState parentFormatting) {
+        if (keySupplier == null || argsSupplier == null) {
+            return component;
+        }
+
+        Object[] args = this.argsSupplier.get();
+        if (args == null || args.length == 0) return super.getFormatted(parentFormatting);
+        String text = Objects.requireNonNull(this.keySupplier.get());
+        Component formatted = FontRenderHelper.formatArgs(args,
+                FormattingState.merge(parentFormatting, getFormatting()), text, true);
+        return FontRenderHelper.format(getFormatting(), parentFormatting, formatted);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/RichText.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/RichText.java
new file mode 100644
index 00000000000..3df10a864f8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/RichText.java
@@ -0,0 +1,372 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.*;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.TooltipLines;
+import com.gregtechceu.gtceu.client.mui.component.DrawableTooltipComponent;
+import com.gregtechceu.gtceu.client.mui.component.TooltipComponentIcon;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.world.inventory.tooltip.TooltipComponent;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+import java.util.regex.Pattern;
+
+public class RichText implements IDrawable, IRichTextBuilder<RichText> {
+
+    private static final TextRenderer renderer = new TextRenderer();
+
+    private final List<Object> elements = new ArrayList<>();
+    private TooltipLines componentList;
+    @Getter
+    private Alignment alignment = Alignment.CenterLeft;
+    @Getter
+    private float scale = 1f;
+    @Getter
+    private Integer color = null;
+    @Getter
+    private Boolean shadow = null;
+
+    private int cursor = 0;
+    private boolean cursorLocked = false;
+    private List<ITextLine> cachedText;
+
+    public boolean isEmpty() {
+        return this.elements.isEmpty();
+    }
+
+    public List<FormattedText> getAsText() {
+        if (this.componentList == null) {
+            this.componentList = new TooltipLines(this.elements);
+        }
+        return this.componentList;
+    }
+
+    private void clearComponents() {
+        if (this.componentList != null) {
+            this.componentList.clearCache();
+        }
+    }
+
+    public int getMinWidth() {
+        int minWidth = 12;
+        for (Object o : this.elements) {
+            if (o instanceof IIcon icon) {
+                minWidth = Math.max(minWidth, icon.getWidth());
+            }
+        }
+        return minWidth;
+    }
+
+    private void addElement(Object o) {
+        this.elements.add(this.cursor, o);
+        if (!this.cursorLocked) {
+            this.cursor++;
+        }
+    }
+
+    @Override
+    public RichText getThis() {
+        return this;
+    }
+
+    @Override
+    public IRichTextBuilder<?> getRichText() {
+        return this;
+    }
+
+    @Override
+    public RichText reset() {
+        this.elements.clear();
+        this.componentList = null;
+        this.alignment = Alignment.CenterLeft;
+        this.scale = 1f;
+        this.color = null;
+        this.shadow = null;
+        this.cursor = 0;
+        this.cursorLocked = false;
+        this.cachedText = null;
+        return this;
+    }
+
+    @Override
+    public RichText add(FormattedText c) {
+        addElement(c);
+        clearComponents();
+        return this;
+    }
+
+    @Override
+    public RichText add(String s) {
+        addElement(s);
+        clearComponents();
+        return this;
+    }
+
+    @Override
+    public RichText add(IDrawable drawable) {
+        Object o = drawable;
+        if (!(o instanceof IKey) && !(o instanceof IIcon)) o = drawable.asIcon();
+        addElement(o);
+        clearComponents();
+        return this;
+    }
+
+    @Override
+    public RichText add(TooltipComponent tooltipComponent) {
+        if (tooltipComponent instanceof DrawableTooltipComponent drawable) {
+            return add(drawable.getDrawable());
+        } else {
+            TooltipComponentIcon tci = new TooltipComponentIcon(tooltipComponent);
+            return add(tci);
+        }
+    }
+
+    @Override
+    public RichText addLine(ITextLine line) {
+        addElement(line);
+        clearComponents();
+        return this;
+    }
+
+    @Override
+    public RichText clearText() {
+        this.elements.clear();
+        this.cursor = 0;
+        clearComponents();
+        return this;
+    }
+
+    public RichText addAll(RichText other) {
+        newLine();
+        this.elements.addAll(this.cursor, other.elements);
+        if (!this.cursorLocked) {
+            this.cursor += other.elements.size();
+        }
+        clearComponents();
+        return this;
+    }
+
+    @Override
+    public RichText alignment(Alignment alignment) {
+        this.alignment = alignment;
+        return this;
+    }
+
+    @Override
+    public RichText textColor(int color) {
+        this.color = color;
+        return this;
+    }
+
+    @Override
+    public RichText scale(float scale) {
+        this.scale = scale;
+        return this;
+    }
+
+    @Override
+    public RichText textShadow(boolean shadow) {
+        this.shadow = shadow;
+        return this;
+    }
+
+    @Override
+    public RichText moveCursorAfterElement(Pattern regex) {
+        int i = findNextText(this.cursor, true, s -> regex.matcher(s).find());
+        if (i < 0) i = this.elements.size();
+        this.cursor = i;
+        return this;
+    }
+
+    @Override
+    public RichText replace(Pattern regex, UnaryOperator<IKey> function) {
+        int i = findNextText(this.cursor, true, s -> regex.matcher(s).find());
+        if (i >= 0) {
+            this.cursor = i;
+            Object o = this.elements.get(i);
+            IKey key = o instanceof IKey key1 ? key1 : IKey.str((String) o);
+            key = function.apply(key);
+            if (key == null) {
+                this.elements.remove(i);
+                this.cursor--;
+            } else {
+                this.elements.set(i, key);
+            }
+        }
+        return this;
+    }
+
+    @Override
+    public RichText moveCursorToStart() {
+        this.cursor = 0;
+        return this;
+    }
+
+    @Override
+    public RichText moveCursorToEnd() {
+        this.cursor = this.elements.size() - 1;
+        return this;
+    }
+
+    @Override
+    public RichText moveCursorForward(int by) {
+        this.cursor = Math.min(this.cursor + by, this.elements.size() - 1);
+        return this;
+    }
+
+    @Override
+    public RichText moveCursorBackward(int by) {
+        this.cursor = Math.max(0, this.cursor - by);
+        return this;
+    }
+
+    @Override
+    public RichText lockCursor() {
+        this.cursorLocked = true;
+        return this;
+    }
+
+    @Override
+    public RichText unlockCursor() {
+        this.cursorLocked = false;
+        return this;
+    }
+
+    @Override
+    public RichText moveCursorToNextLine() {
+        if (this.cursor < this.elements.size() - 1) {
+            this.cursor = findNextLine(this.cursor) + 1;
+        }
+        return this;
+    }
+
+    private int findNextLine(int current) {
+        for (int i = current; i < this.elements.size(); i++) {
+            Object o = this.elements.get(i);
+            if (o == IKey.LINE_FEED) return i;
+            if (o instanceof IKey key && key.get().getString().trim().endsWith("\n")) return i;
+            if (o instanceof String string && string.trim().endsWith("\n")) return i;
+            if (o instanceof ITextLine) return i;
+        }
+        return this.elements.size() - 1;
+    }
+
+    private int findNextText(int current, boolean wrapAround, Predicate<String> test) {
+        int i = current;
+        int lim = this.elements.size();
+        while (i < lim) {
+            Object o = this.elements.get(i);
+            if (o instanceof IKey key && test.test(key.get().getString())) return i;
+            if (o instanceof String string && test.test(string)) return i;
+            if (++i == lim && wrapAround) {
+                i = 0;
+                lim = current;
+                wrapAround = false;
+            }
+        }
+        return -1;
+    }
+
+    public RichText insertTitleMargin(int margin) {
+        List<Object> objects = this.elements;
+        for (int i = 0; i < objects.size(); i++) {
+            Object o = objects.get(i);
+            if (o == IKey.LINE_FEED) {
+                if (i == objects.size() - 1) return this;
+                if (objects.get(i + 1) instanceof Spacer spacer) {
+                    if (spacer.getSpace() == margin) return this;
+                    objects.set(i + 1, Spacer.of(margin));
+                } else {
+                    objects.add(i + 1, Spacer.of(margin));
+                }
+                clearComponents();
+                return this;
+            }
+        }
+        return this;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        draw(context, x, y, width, height, widgetTheme.getTextColor(), widgetTheme.isTextShadow());
+    }
+
+    public void draw(GuiContext context, int x, int y, int width, int height, int color, boolean shadow) {
+        draw(renderer, context, x, y, width, height, color, shadow);
+    }
+
+    public void draw(TextRenderer renderer, GuiContext context, int x, int y, int width, int height, int color,
+                     boolean shadow) {
+        renderer.setSimulate(false);
+        setupRenderer(renderer, x, y, width, height, color, shadow);
+        this.cachedText = renderer.compileAndDraw(context, this.elements);
+    }
+
+    public int getLastWidth() {
+        return (int) renderer.getLastWidth();
+    }
+
+    public int getLastHeight() {
+        return (int) renderer.getLastHeight();
+    }
+
+    public void setupRenderer(TextRenderer renderer, int x, int y, float width, float height, int color,
+                              boolean shadow) {
+        renderer.setPos(x, y);
+        renderer.setScale(this.scale);
+        renderer.setColor(this.color != null ? this.color : color);
+        renderer.setShadow(this.shadow != null ? this.shadow : shadow);
+        renderer.setAlignment(this.alignment, width, height);
+    }
+
+    public List<ITextLine> compileAndDraw(TextRenderer renderer, GuiContext context, boolean simulate) {
+        renderer.setSimulate(simulate);
+        this.cachedText = renderer.compileAndDraw(context, this.elements);
+        renderer.setSimulate(false);
+        return this.cachedText;
+    }
+
+    /**
+     * Returns the currently hovered element of this rich text or {@code null} if none is hovered.
+     * Note that this method assumes, that the {@link com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack
+     * IViewportStack}
+     * is transformed to 0,0 of this {@link IDrawable}.
+     *
+     * @param context the viewport stack with transformation to this widget
+     * @return hovered element or null
+     */
+    public Object getHoveringElement(GuiContext context) {
+        return getHoveringElement(context.getFont(), context.getMouseX(), context.getMouseY());
+    }
+
+    public Object getHoveringElement(Font fr, int x, int y) {
+        if (this.cachedText == null) return null;
+
+        for (ITextLine line : this.cachedText) {
+            Object o = line.getHoveringElement(fr, x, y);
+            if (o == null) continue;
+            if (o == Boolean.FALSE) return null;
+            return o;
+        }
+        return null;
+    }
+
+    public RichText copy() {
+        RichText copy = new RichText();
+        copy.elements.addAll(this.elements);
+        copy.alignment = this.alignment;
+        copy.scale = this.scale;
+        copy.color = this.color;
+        copy.shadow = this.shadow;
+        return copy;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/RichTextCompiler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/RichTextCompiler.java
new file mode 100644
index 00000000000..4228dd5dee1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/RichTextCompiler.java
@@ -0,0 +1,300 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.api.mui.drawable.DelegateIcon;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.Style;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class compiles a list of objects into renderable text. The objects can be strings or any drawable.
+ * The compiler will try to inline the drawables into the text according to the given maximum width.
+ * Recommended usage is via {@link TextRenderer#compileAndDraw(GuiContext, List)}.
+ */
+public class RichTextCompiler {
+
+    public static final RichTextCompiler INSTANCE = new RichTextCompiler();
+
+    private Font fr;
+    private int maxWidth;
+
+    private List<ITextLine> lines;
+    private List<Object> currentLine;
+    private int x, h;
+    private final FormattingState formatting = new FormattingState();
+
+    public List<ITextLine> compileLines(Font fr, List<Object> raw, int maxWidth, float scale) {
+        reset(fr, (int) (maxWidth / scale));
+        compile(raw);
+        return lines;
+    }
+
+    public void reset(Font fr, int maxWidth) {
+        this.fr = fr != null ? fr : Minecraft.getInstance().font;
+        this.maxWidth = maxWidth > 0 ? maxWidth : Integer.MAX_VALUE;
+        this.lines = new ArrayList<>();
+        this.currentLine = new ArrayList<>();
+        this.x = 0;
+        this.h = 0;
+        this.formatting.reset();
+    }
+
+    private void compile(List<Object> raw) {
+        for (Object o : raw) {
+            if (o instanceof ITextLine line) {
+                newLine();
+                this.lines.add(line);
+                continue;
+            }
+            MutableComponent text = null;
+            if (o instanceof IKey key) {
+                if (key == IKey.EMPTY) continue;
+                if (key == IKey.SPACE) {
+                    MutableComponent mc = key.get();
+                    addLineElement(mc);
+                    this.x += this.fr.width(mc);
+                    continue;
+                }
+                if (key == IKey.LINE_FEED) {
+                    newLine();
+                    this.formatting.reset();
+                    continue;
+                }
+                text = key.getFormatted();
+            }
+            if (o instanceof MutableComponent component) {
+                text = component.copy();
+            } else if (!(o instanceof IDrawable)) {
+                text = Component.literal(o.toString());
+            }
+            if (text != null) {
+                if (text.getStyle() != Style.EMPTY) {
+                    addLineElement(text);
+                } else {
+                    compileString(text.getString());
+                }
+                continue;
+            }
+            if (!(o instanceof IIcon)) {
+                o = ((IDrawable) o).asIcon();// .size(fr.lineHeight);
+            }
+            IIcon icon = (IIcon) o;
+            IIcon delegate = icon;
+            if (icon instanceof DelegateIcon di) {
+                delegate = di.findRootDelegate();
+            }
+            if (delegate instanceof Icon icon1) {
+                int defaultSize = this.fr.lineHeight;
+                // if (icon1.getWidth() <= 0) icon1.width(defaultSize);
+                if (icon1.getHeight() <= 0) icon1.height(defaultSize);
+            }
+            if (icon.getWidth() > this.maxWidth) {
+                GTCEu.LOGGER.warn("Icon is wider than max width");
+            }
+            checkNewLine(icon.getWidth());
+            addLineElement(icon);
+            h = Math.max(h, icon.getHeight());
+            x += icon.getWidth();
+        }
+        newLine();
+    }
+
+    private void compileString(String text) {
+        int l = text.indexOf('\n');
+        int k = 0;
+        do {
+            // essentially splits text at \n and compiles it
+            if (l < 0) l = text.length(); // no line feed, use rest of string
+            String subText = text.substring(k, l);
+            k = l + 1; // start next sub string here
+            while (!subText.isEmpty()) {
+                // how many chars fit
+                int i = this.fr.getSplitter().plainIndexAtWidth(subText, this.maxWidth - this.x, Style.EMPTY);
+                if (i == 0) {
+                    // doesn't fit at the end of the line, try new line
+                    if (this.x > 0) i = fr.getSplitter().plainIndexAtWidth(subText, this.maxWidth, Style.EMPTY);
+                    if (i <= 0) {
+                        i = 1; // force at least one char
+                        if (subText.charAt(0) == '\u00a7' && subText.length() > 1) {
+                            // include format char if it is one
+                            i++;
+                            if (subText.length() > 2) i++;
+                        }
+                    }
+                    newLine();
+                } else if (i < subText.length()) {
+                    // the whole string doesn't fit
+                    char c = subText.charAt(i);
+                    if (c != ' ' && this.x > 0) {
+                        // line was split in the middle of a word, try new line
+                        int j = fr.getSplitter().plainIndexAtWidth(subText, this.maxWidth, Style.EMPTY);
+                        if (j < subText.length()) {
+                            c = subText.charAt(j);
+                            if (j > i && c == ' ') {
+                                // line was split properly on a new line
+                                newLine();
+                            }
+                        } else {
+                            // the end of the line is reached
+                            newLine();
+                        }
+                    }
+                }
+                // get fitting string
+                String current = subText.length() <= i ? subText : trimRight(subText.substring(0, i));
+                int width = this.fr.width(current);
+                addLineElement(current); // add string
+                this.h = Math.max(this.h, this.fr.lineHeight);
+                this.x += width;
+                if (subText.length() <= i) break; // sub text reached the end
+                newLine(); // string was split -> line is full
+                char c = subText.charAt(i);
+                if (c == ' ') i++; // if was split at space then don't include it in next sub text
+                subText = subText.substring(i); // set sub text to part after split
+            }
+            if (l < text.length() && text.charAt(l) == '\n') {
+                // was split at line feed -> new line
+                newLine();
+            }
+        } while ((l = text.indexOf('\n', k)) >= 0 || k < text.length());
+        // if no line feed found, check if we are at the end of the text
+    }
+
+    private void newLine() {
+        int i = this.currentLine.size() - 1;
+        if (!this.currentLine.isEmpty() && this.currentLine.get(i) instanceof String s) {
+            if (s.equals(" ")) {
+                this.currentLine.remove(i);
+            } else {
+                this.currentLine.set(i, trimRight(s));
+            }
+        }
+        if (this.currentLine.isEmpty()) {
+            // lines.add(null);
+        } else if (this.currentLine.size() == 1 && this.currentLine.get(0) instanceof Component c) {
+            this.lines.add(new TextLine(c, this.x));
+            this.currentLine.clear();
+        } else if (this.currentLine.size() == 1 && this.currentLine.get(0) instanceof String s) {
+            this.lines.add(new TextLine(Component.literal(s), this.x));
+            this.currentLine.clear();
+        } else {
+            this.lines.add(new ComposedLine(this.currentLine, this.x, this.h));
+            this.currentLine = new ArrayList<>();
+        }
+        this.x = 0;
+        this.h = 0;
+    }
+
+    private void addLineElement(Object o) {
+        if (o instanceof Component c2) {
+            int s = this.currentLine.size();
+            if (s > 0 && this.currentLine.get(s - 1) instanceof String s1) {
+                // if the last element in the line is a string, merge them
+                this.currentLine.set(s - 1, s1 + c2);
+                return;
+            }
+            if (this.currentLine.size() == 1 && this.currentLine.get(0) instanceof Component c1) {
+                // if there is already one string in the line, merge them
+                this.currentLine.set(0, c1.copy().append(c2));
+                return;
+            }
+            o = c2.copy().withStyle(this.formatting::getFormatting);
+        } else if (o instanceof String s2) {
+            if (this.currentLine.size() == 1 && this.currentLine.get(0) instanceof String s1) {
+                // if there is already one string in the line, merge them
+                this.currentLine.set(0, s1 + s2);
+                return;
+            }
+            if (this.currentLine.size() == 1 && this.currentLine.get(0) instanceof Component c1) {
+                // if there is already one string in the line, merge them
+                this.currentLine.set(0, c1.copy().append(s2));
+                return;
+            }
+            if (this.currentLine.isEmpty()) {
+                // if there is currently no string, remove all whitespace from the start,
+                // but don't remove any formatting before
+                int l = FontRenderHelper.getFormatLength(s2, 0);
+                if (l + 1 < s2.length()) {
+                    o = trimAt(s2, l);
+                }
+            }
+            Style style = this.formatting.getFormatting(Style.EMPTY);
+            StringBuilder styleBuilder = new StringBuilder();
+            if (style.getColor() != null) {
+                int colorRGB = style.getColor().getValue();
+                for (ChatFormatting legacyColor : ChatFormatting.values()) {
+                    if (!legacyColor.isColor()) continue;
+                    // noinspection DataFlowIssue
+                    if (colorRGB != legacyColor.getColor()) continue;
+                    styleBuilder.append(legacyColor);
+                    break;
+                }
+            }
+            if (style.isBold()) {
+                styleBuilder.append(ChatFormatting.BOLD);
+            }
+            if (style.isItalic()) {
+                styleBuilder.append(ChatFormatting.ITALIC);
+            }
+            if (style.isUnderlined()) {
+                styleBuilder.append(ChatFormatting.UNDERLINE);
+            }
+            if (style.isStrikethrough()) {
+                styleBuilder.append(ChatFormatting.STRIKETHROUGH);
+            }
+            if (style.isObfuscated()) {
+                styleBuilder.append(ChatFormatting.OBFUSCATED);
+            }
+            o = styleBuilder.toString() + o;
+            this.formatting.parseFrom(s2); // parse formatting from current string
+        }
+        if (o instanceof Component c) {
+            x += fr.width(c.getString());
+            h = Math.max(h, fr.lineHeight);
+        }
+
+        this.currentLine.add(o);
+    }
+
+    private void checkNewLine(int width) {
+        if (this.x > 0 && this.x + width > this.maxWidth) {
+            newLine();
+        }
+    }
+
+    public static String trimRight(String s) {
+        int i = s.length() - 1;
+        for (; i >= 0; i--) {
+            if (!Character.isWhitespace(s.charAt(i))) break;
+        }
+        if (i < s.length() - 1) s = s.substring(0, i + 1);
+        return s;
+    }
+
+    public static String trimAt(String s, int start) {
+        int l = 0;
+        for (int i = Math.max(0, start), n = s.length(); i < n; i++) {
+            if (Character.isWhitespace(s.charAt(i))) {
+                l++;
+            } else {
+                break;
+            }
+        }
+        if (l == 0) return s;
+        if (start <= 0) return s.substring(l);
+        return s.substring(0, start) + s.substring(start + l);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/Spacer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/Spacer.java
new file mode 100644
index 00000000000..eaa8dc62132
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/Spacer.java
@@ -0,0 +1,46 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+
+import lombok.Getter;
+
+public class Spacer implements ITextLine {
+
+    public static final Spacer SPACER_2PX = new Spacer(2);
+    public static final Spacer LINE_SPACER = new Spacer(FontRenderHelper.getDefaultTextHeight());
+
+    public static Spacer of(int space) {
+        if (space == 2) return SPACER_2PX;
+        if (space == LINE_SPACER.space) return LINE_SPACER;
+        return new Spacer(space);
+    }
+
+    @Getter
+    private final int space;
+
+    protected Spacer(int space) {
+        this.space = space;
+    }
+
+    @Override
+    public int getWidth() {
+        return 1;
+    }
+
+    @Override
+    public int getHeight(Font font) {
+        return this.space;
+    }
+
+    @Override
+    public void draw(GuiContext context, Font font, float x, float y, int color, boolean shadow, int availableWidth,
+                     int availableHeight) {}
+
+    @Override
+    public Object getHoveringElement(Font font, int x, int y) {
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/StringKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/StringKey.java
new file mode 100644
index 00000000000..6f1ddb46d38
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/StringKey.java
@@ -0,0 +1,36 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class StringKey extends BaseKey {
+
+    private final String string;
+    private final Object[] args;
+
+    public StringKey(String string) {
+        this(string, null);
+    }
+
+    public StringKey(String string, @Nullable Object[] args) {
+        this.string = Objects.requireNonNull(string);
+        this.args = args == null || args.length == 0 ? null : args;
+    }
+
+    @Override
+    public MutableComponent get() {
+        return this.args == null ? Component.translatable(this.string) : Component.translatable(this.string, this.args);
+    }
+
+    @Override
+    public MutableComponent getFormatted(@Nullable FormattingState parentFormatting) {
+        if (this.args == null || this.args.length == 0) return super.getFormatted(parentFormatting);
+        Component text = FontRenderHelper.formatArgs(this.args,
+                FormattingState.merge(parentFormatting, getFormatting()), this.string, false);
+        return FontRenderHelper.format(getFormatting(), parentFormatting, text);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/StyledText.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/StyledText.java
new file mode 100644
index 00000000000..b76199444d9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/StyledText.java
@@ -0,0 +1,90 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.MutableComponent;
+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 org.jetbrains.annotations.Nullable;
+
+import java.util.function.IntSupplier;
+
+@Accessors(fluent = true, chain = true)
+public class StyledText extends BaseKey {
+
+    private final IKey key;
+    @Getter
+    @Setter
+    private Alignment alignment = Alignment.Center;
+    @Getter
+    @Setter
+    private IntSupplier color = null;
+    @Setter
+    private @Nullable Boolean shadow = null;
+    @Getter
+    @Setter
+    private float scale = 1f;
+
+    public StyledText(IKey key) {
+        this.key = key;
+    }
+
+    @Override
+    public MutableComponent get() {
+        return this.key.get();
+    }
+
+    @Override
+    public MutableComponent getFormatted() {
+        return this.key.getFormatted();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        renderer.setAlignment(this.alignment, width, height);
+        renderer.setColor(this.color != null ? this.color.getAsInt() : widgetTheme.getTextColor());
+        renderer.setScale(this.scale);
+        renderer.setPos(x, y);
+        renderer.setShadow(this.shadow != null ? this.shadow : widgetTheme.isTextShadow());
+        renderer.draw(context.getGraphics(), getFormatted());
+    }
+
+    public @Nullable Boolean isShadow() {
+        return this.shadow;
+    }
+
+    @Override
+    public @NotNull BaseKey style(ChatFormatting formatting) {
+        this.key.style(formatting);
+        return this;
+    }
+
+    @Override
+    public TextWidget<?> asWidget() {
+        return new TextWidget<>(this.key)
+                .alignment(this.alignment)
+                .color(this.color)
+                .scale(this.scale)
+                .shadow(this.shadow);
+    }
+
+    @Override
+    public AnimatedText withAnimation() {
+        return new AnimatedText(this.key)
+                .alignment(this.alignment)
+                .color(this.color)
+                .scale(this.scale)
+                .shadow(this.shadow);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextIcon.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextIcon.java
new file mode 100644
index 00000000000..35e9c193d60
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextIcon.java
@@ -0,0 +1,53 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.network.chat.Component;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class TextIcon implements IIcon {
+
+    @Getter
+    private final Component text;
+    @Getter
+    private final int width, height;
+    private final float scale;
+    private final Alignment alignment;
+    private static final Box margin = new Box();
+
+    public TextIcon(Component text, int width, int height, float scale, Alignment alignment) {
+        this.text = text;
+        this.width = width;
+        this.height = height;
+        this.scale = scale;
+        this.alignment = alignment;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        TextRenderer.SHARED.setPos(x, y);
+        TextRenderer.SHARED.setAlignment(this.alignment, width);
+        TextRenderer.SHARED.setScale(this.scale);
+        TextRenderer.SHARED.drawSimple(context.getGraphics(), this.text);
+    }
+
+    @Override
+    @Nullable
+    public IIcon getWrappedDrawable() {
+        return null;
+    }
+
+    @Override
+    public Box getMargin() {
+        return margin;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextLine.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextLine.java
new file mode 100644
index 00000000000..b74f17ed054
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextLine.java
@@ -0,0 +1,44 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.network.chat.Component;
+
+import lombok.Getter;
+
+public class TextLine implements ITextLine {
+
+    private final Component text;
+    @Getter
+    private final int width;
+
+    private float lastX, lastY;
+
+    public TextLine(Component text, int width) {
+        this.text = text;
+        this.width = width;
+    }
+
+    @Override
+    public int getHeight(Font font) {
+        return font.lineHeight + 1;
+    }
+
+    @Override
+    public void draw(GuiContext context, Font font, float x, float y, int color, boolean shadow,
+                     int availableWidth, int availableHeight) {
+        context.getGraphics().drawString(font, this.text.getVisualOrderText(), x, y, color, shadow);
+        this.lastX = x;
+        this.lastY = y;
+    }
+
+    @Override
+    public Object getHoveringElement(Font font, int x, int y) {
+        if (y < lastY || y > lastY + getHeight(font)) return null;
+        // not hovering, but we know that nothing else is hovered either
+        if (x < lastX || x > lastX + getWidth()) return Boolean.FALSE;
+        return this.text;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextRenderer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextRenderer.java
new file mode 100644
index 00000000000..f78b6e61196
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/drawable/text/TextRenderer.java
@@ -0,0 +1,306 @@
+package com.gregtechceu.gtceu.api.mui.drawable.text;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.core.mixins.client.StringSplitterAccessor;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.StringSplitter;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.Style;
+import net.minecraft.util.FormattedCharSequence;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class TextRenderer {
+
+    public static final TextRenderer SHARED = new TextRenderer();
+
+    protected float maxWidth = -1, maxHeight = -1;
+    @Getter
+    protected int x = 0, y = 0;
+    @Getter
+    protected Alignment alignment = Alignment.TopLeft;
+    @Getter
+    @Setter
+    protected float scale = 1f;
+    @Getter
+    @Setter
+    protected boolean shadow = false;
+    @Getter
+    @Setter
+    protected int color = 0;// Theme.INSTANCE.getText();
+    @Setter
+    protected boolean simulate;
+    @Getter
+    protected float lastWidth = 0, lastHeight = 0;
+    protected float lastX = 0, lastY = 0;
+    @Setter
+    protected boolean hardWrapOnBorder = true;
+    protected boolean scrollOnOverflow = false;
+
+    public void setAlignment(Alignment alignment, float maxWidth) {
+        setAlignment(alignment, maxWidth, -1);
+    }
+
+    public void setAlignment(Alignment alignment, float maxWidth, float maxHeight) {
+        this.alignment = alignment;
+        this.maxWidth = maxWidth;
+        this.maxHeight = maxHeight;
+    }
+
+    public void setPos(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void draw(GuiGraphics graphics, String text) {
+        this.draw(graphics, Component.literal(text));
+    }
+
+    public void draw(GuiGraphics graphics, Component text) {
+        if ((this.maxWidth <= 0 || !this.hardWrapOnBorder) && !text.getString().contains("\n'")) {
+            drawSimple(graphics, text);
+        } else {
+            draw(graphics, Collections.singletonList(text));
+        }
+    }
+
+    public void draw(GuiGraphics graphics, List<Component> lines) {
+        drawMeasuredLines(graphics, measureLines(lines));
+    }
+
+    protected void drawMeasuredLines(GuiGraphics graphics, List<Line> measuredLines) {
+        float maxW = 0;
+        int y0 = getStartYOfLines(measuredLines.size());
+        for (Line measuredLine : measuredLines) {
+            int x0 = getStartX(measuredLine.width);
+            maxW = Math.max(maxW, measuredLine.width);
+            draw(graphics, measuredLine.text, x0, y0);
+            y0 += (int) getFontHeight();
+        }
+        this.lastWidth = maxW;
+        this.lastHeight = measuredLines.size() * getFontHeight();
+        this.lastWidth = Math.max(0, this.lastWidth - this.scale);
+        this.lastHeight = Math.max(0, this.lastHeight - this.scale);
+    }
+
+    public void drawSimple(GuiGraphics graphics, Component text) {
+        this.drawSimple(graphics, text.getVisualOrderText());
+    }
+
+    public void drawSimple(GuiGraphics graphics, FormattedCharSequence text) {
+        if (getFont() == null) return;
+        float w = getFont().width(text) * this.scale;
+        int y = getStartYOfLines(1), x = getStartX(w);
+        draw(graphics, text, x, y);
+        this.lastWidth = w;
+        this.lastHeight = getFontHeight();
+        this.lastWidth = Math.max(0, this.lastWidth - this.scale);
+        this.lastHeight = Math.max(0, this.lastHeight - this.scale);
+    }
+
+    public List<Line> measureStringLines(List<String> lines) {
+        return measureLines(FontRenderHelper.asComponents(lines));
+    }
+
+    public List<Line> measureLines(List<Component> lines) {
+        List<Line> measuredLines = new ArrayList<>();
+        for (Component line : lines) {
+            if (this.hardWrapOnBorder) {
+                for (FormattedCharSequence subLine : wrapLine(line)) {
+                    measuredLines.add(line(subLine));
+                }
+            } else {
+                measuredLines.add(line(line.getVisualOrderText()));
+            }
+        }
+        return measuredLines;
+    }
+
+    public List<ITextLine> compile(List<Object> rawText) {
+        return RichTextCompiler.INSTANCE.compileLines(getFont(), rawText, (int) this.maxWidth, this.scale);
+    }
+
+    public List<ITextLine> compileAndDraw(GuiContext context, List<Object> raw) {
+        List<ITextLine> lines = compile(raw);
+        drawCompiled(context, lines);
+        return lines;
+    }
+
+    public void drawCompiled(GuiContext context, List<ITextLine> lines) {
+        int height = 0, width = 0;
+        for (ITextLine line : lines) {
+            height += line.getHeight(context.getFont());
+            width = Math.max(width, line.getWidth());
+        }
+        if (!this.simulate) {
+            context.graphicsPose().pushPose();
+            context.graphicsPose().translate(this.x, this.y, 10);
+            context.graphicsPose().scale(this.scale, this.scale, 1f);
+            context.graphicsPose().translate(-this.x, -this.y, 0);
+        }
+        int y0 = getStartY(height, height);
+        this.lastY = y0;
+        for (ITextLine line : lines) {
+            int x0 = getStartX(width, line.getWidth());
+            if (!simulate) line.draw(context, context.getFont(), x0, y0, this.color, this.shadow, width, height);
+            y0 += line.getHeight(context.getFont());
+        }
+        if (!this.simulate) {
+            context.graphicsPose().popPose();
+        }
+        this.lastWidth = this.maxWidth > 0 ? Math.min(width * this.scale, this.maxWidth) : width * this.scale;
+        this.lastHeight = height * this.scale;
+        this.lastWidth = Math.max(0, this.lastWidth - this.scale);
+        this.lastHeight = Math.max(0, this.lastHeight - this.scale);
+    }
+
+    public void drawCut(GuiGraphics graphics, String text) {
+        if (text.contains("\n")) {
+            throw new IllegalArgumentException("Scrolling text can't wrap!");
+        }
+        drawCut(graphics, line(Component.literal(text).getVisualOrderText()));
+    }
+
+    public void drawCut(GuiGraphics graphics, Line line) {
+        if (line.width > this.maxWidth) {
+            var cutText = FormattedCharSequence.composite(
+                    FontRenderHelper.splitAtMax(line.text(), this.maxWidth - 6),
+                    FormattedCharSequence.forward("...", Style.EMPTY));
+            drawMeasuredLines(graphics, Collections.singletonList(line(cutText)));
+        } else {
+            drawMeasuredLines(graphics, Collections.singletonList(line));
+        }
+    }
+
+    public void drawScrolling(GuiGraphics graphics, Line line, float progress, Area area, GuiContext context) {
+        if (line.width() <= this.maxWidth) {
+            drawMeasuredLines(graphics, Collections.singletonList(line));
+            return;
+        }
+        float scroll = (line.getWidth() - this.maxWidth) * progress;
+        context.getStencil().push(this.x, -500, (int) this.maxWidth, 1000);
+        context.graphicsPose().pushPose();
+        context.graphicsPose().translate(-scroll, 0, 0);
+        drawMeasuredLines(graphics, Collections.singletonList(line));
+        context.graphicsPose().popPose();
+        context.getStencil().pop();
+    }
+
+    public List<FormattedCharSequence> wrapLine(Component line) {
+        if (this.maxWidth > 0) {
+            int wrapWidth = Math.max(10, (int) (this.maxWidth / this.scale));
+            return getFont().split(line, wrapWidth);
+        }
+        return Collections.singletonList(line.getVisualOrderText());
+    }
+
+    public boolean wouldFit(List<String> text, boolean shouldCheckWidth) {
+        if (this.maxHeight > 0 && this.maxHeight < text.size() * getFontHeight() - this.scale) {
+            return false;
+        }
+        if (this.maxWidth > 0 && shouldCheckWidth) {
+            for (String line : text) {
+                if (this.maxWidth < getFont().width(line)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public int getMaxWidth(List<Component> lines) {
+        if (lines.isEmpty()) {
+            return 0;
+        }
+        List<Line> measuredLines = measureLines(lines);
+        float w = 0;
+        for (Line measuredLine : measuredLines) {
+            w = Math.max(w, measuredLine.width());
+        }
+        return (int) Math.ceil(w);
+    }
+
+    protected int getStartYOfLines(int lines) {
+        return getStartY(lines * getFontHeight() - this.scale);
+    }
+
+    protected int getStartY(float height) {
+        return getStartY(this.maxHeight, height);
+    }
+
+    protected int getStartY(float maxHeight, float height) {
+        if (this.alignment.y > 0 && maxHeight > 0 && height != maxHeight) {
+            return this.y + Math.round(maxHeight * this.alignment.y) - Math.round(height * this.alignment.y);
+        }
+        return this.y;
+    }
+
+    protected int getStartX(float lineWidth) {
+        return getStartX(this.maxWidth, lineWidth);
+    }
+
+    protected int getStartX(float maxWidth, float lineWidth) {
+        if (this.alignment.x > 0 && maxWidth > 0) {
+            return Math.max(this.x,
+                    this.x + Math.round(maxWidth * this.alignment.x) - Math.round(lineWidth * this.alignment.x));
+        }
+        return this.x;
+    }
+
+    protected void draw(GuiGraphics graphics, FormattedCharSequence text, float x, float y) {
+        if (this.simulate || graphics == null) return;
+        graphics.pose().pushPose();
+        graphics.pose().scale(this.scale, this.scale, 0f);
+        graphics.drawString(getFont(), text, (int) (x / this.scale), (int) (y / this.scale), this.color, this.shadow);
+        graphics.pose().popPose();
+    }
+
+    public float getFontHeight() {
+        return getFont().lineHeight * this.scale;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static Font getFont() {
+        return Minecraft.getInstance().font;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static StringSplitter.WidthProvider getWidthProvider() {
+        return ((StringSplitterAccessor) getFont().getSplitter()).getWidthProvider();
+    }
+
+    public Line line(FormattedCharSequence text) {
+        return new Line(text, getFont().width(text) * this.scale);
+    }
+
+    public record Line(@Getter FormattedCharSequence text, @Getter float width) {
+
+        public int upperWidth() {
+            return (int) (this.width + 1);
+        }
+
+        public int lowerWidth() {
+            return (int) this.width;
+        }
+    }
+
+    public record FormattedChar(int codePoint, Style style) {
+
+        public FormattedCharSequence asSequence() {
+            return FormattedCharSequence.codepoint(codePoint, style);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/AbstractUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/AbstractUIFactory.java
new file mode 100644
index 00000000000..1cc48dd2fd0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/AbstractUIFactory.java
@@ -0,0 +1,68 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.UIFactory;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public abstract class AbstractUIFactory<T extends GuiData> implements UIFactory<T> {
+
+    protected static ServerPlayer verifyServerSide(Player player) {
+        if (player == null) throw new NullPointerException("Can't open UI for null player!");
+        if (player instanceof ServerPlayer serverPlayer) return serverPlayer;
+        throw new IllegalArgumentException("Expected server player to open UI on server!");
+    }
+
+    protected static LocalPlayer verifyClientSide(Player player) {
+        if (player == null) throw new NullPointerException("Can't open UI for null player!");
+        if (player instanceof LocalPlayer localPlayer) return localPlayer;
+        throw new IllegalArgumentException("Expected client player to open UI on client side!");
+    }
+
+    private final ResourceLocation name;
+
+    protected AbstractUIFactory(ResourceLocation name) {
+        this.name = Objects.requireNonNull(name);
+    }
+
+    @Override
+    public final @NotNull ResourceLocation getFactoryName() {
+        return this.name;
+    }
+
+    @NotNull
+    public abstract IUIHolder<T> getGuiHolder(T data);
+
+    @Override
+    public ModularPanel createPanel(T guiData, PanelSyncManager syncManager, UISettings settings) {
+        IUIHolder<T> guiHolder = Objects.requireNonNull(getGuiHolder(guiData), "Gui holder must not be null!");
+        return guiHolder.buildUI(guiData, syncManager, settings);
+    }
+
+    @Override
+    public ModularScreen createScreen(T guiData, ModularPanel mainPanel) {
+        IUIHolder<T> guiHolder = Objects.requireNonNull(getGuiHolder(guiData), "Gui holder must not be null!");
+        return guiHolder.createScreen(guiData, mainPanel);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected IUIHolder<T> castUIHolder(Object o) {
+        if (!(o instanceof IUIHolder)) return null;
+        try {
+            return (IUIHolder<T>) o;
+        } catch (ClassCastException e) {
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/BlockEntityUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/BlockEntityUIFactory.java
new file mode 100644
index 00000000000..2dd5c1ce90c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/BlockEntityUIFactory.java
@@ -0,0 +1,85 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+
+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.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class BlockEntityUIFactory extends AbstractUIFactory<PosGuiData> {
+
+    public static final BlockEntityUIFactory INSTANCE = new BlockEntityUIFactory();
+
+    private BlockEntityUIFactory() {
+        super(GTCEu.id("block_entity"));
+    }
+
+    public <T extends BlockEntity & IUIHolder<PosGuiData>> void open(Player player, T blockEntity) {
+        Objects.requireNonNull(player);
+        verifyBlockEntity(MCHelper.getPlayer(), blockEntity);
+        BlockPos pos = blockEntity.getBlockPos();
+        PosGuiData data = new PosGuiData(player, pos);
+        GuiManager.open(this, data, (ServerPlayer) 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);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public <T extends BlockEntity & IUIHolder<PosGuiData>> void openClient(T blockEntity) {
+        verifyBlockEntity(MCHelper.getPlayer(), blockEntity);
+        BlockPos pos = blockEntity.getBlockPos();
+        GuiManager.openFromClient(this, new PosGuiData(MCHelper.getPlayer(), pos));
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void openClient(BlockPos pos) {
+        Objects.requireNonNull(pos);
+        GuiManager.openFromClient(this, new PosGuiData(MCHelper.getPlayer(), pos));
+    }
+
+    @Override
+    public @NotNull IUIHolder<PosGuiData> getGuiHolder(PosGuiData data) {
+        return Objects.requireNonNull(castUIHolder(data.getBlockEntity()), "Found BlockEntity is not a gui holder!");
+    }
+
+    @Override
+    public boolean canInteractWith(Player player, PosGuiData guiData) {
+        return player == guiData.getPlayer() && guiData.getBlockEntity() != null &&
+                guiData.getSquaredDistance(player) <= 64;
+    }
+
+    @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 void verifyBlockEntity(Player player, BlockEntity blockEntity) {
+        Objects.requireNonNull(blockEntity);
+        if (blockEntity.isRemoved()) {
+            throw new IllegalArgumentException("Can't open invalid BlockEntity GUI!");
+        }
+        if (player.level() != blockEntity.getLevel()) {
+            throw new IllegalArgumentException("BlockEntity must be in same dimension as the player!");
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ClientGUI.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ClientGUI.java
new file mode 100644
index 00000000000..19eb36af969
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ClientGUI.java
@@ -0,0 +1,100 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.RecipeViewerSettingsImpl;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
+import net.minecraft.client.gui.screens.Screen;
+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.IntFunction;
+
+/**
+ * Helper class to open client only GUIs. This class is safe to use inside a Modular GUI.
+ */
+@OnlyIn(Dist.CLIENT)
+public class ClientGUI {
+
+    private ClientGUI() {}
+
+    /**
+     * Opens a modular screen on the next client tick with default jei settings.
+     *
+     * @param screen new modular screen
+     */
+    public static void open(@NotNull ModularScreen screen) {
+        open(screen, new UISettings());
+    }
+
+    /**
+     * Opens a modular screen on the next client tick with custom jei settings.
+     * It needs to be opened in next tick, because we might break the current GUI if we open it now.
+     *
+     * @param screen               new modular screen
+     * @param recipeViewerSettings custom jei settings
+     */
+    public static void open(@NotNull ModularScreen screen, @NotNull RecipeViewerSettingsImpl recipeViewerSettings) {
+        GuiManager.openScreen(screen, new UISettings(recipeViewerSettings));
+    }
+
+    /**
+     * Opens a modular screen on the next client tick with custom jei settings.
+     * It needs to be opened in next tick, because we might break the current GUI if we open it now.
+     *
+     * @param screen    new modular screen
+     * @param container custom container
+     */
+    public static void open(@NotNull ModularScreen screen, @Nullable IntFunction<ModularContainerMenu> container) {
+        UISettings settings = new UISettings();
+        settings.customContainer(container);
+        GuiManager.openScreen(screen, settings);
+    }
+
+    /**
+     * Opens a modular screen on the next client tick with custom recipe viewer settings.
+     * It needs to be opened in next tick, because we might break the current GUI if we open it now.
+     *
+     * @param screen               new modular screen
+     * @param recipeViewerSettings custom recipe viewer settings
+     * @param container            custom container
+     */
+    public static void open(@NotNull ModularScreen screen, @NotNull RecipeViewerSettingsImpl recipeViewerSettings,
+                            @Nullable IntFunction<ModularContainerMenu> container) {
+        UISettings settings = new UISettings(recipeViewerSettings);
+        settings.customContainer(container);
+        GuiManager.openScreen(screen, settings);
+    }
+
+    /**
+     * Opens a modular screen on the next client tick with custom jei settings.
+     * It needs to be opened in next tick, because we might break the current GUI if we open it now.
+     *
+     * @param screen   new modular screen
+     * @param settings ui settings
+     */
+    public static void open(@NotNull ModularScreen screen, @NotNull UISettings settings) {
+        GuiManager.openScreen(screen, settings);
+    }
+
+    /**
+     * Opens a {@link Screen} on the next client tick.
+     *
+     * @param screen screen to open
+     */
+    public static void open(Screen screen) {
+        MCHelper.setScreen(screen);
+    }
+
+    /**
+     * Closes any GUI that is open in this tick.
+     */
+    public static void close() {
+        MCHelper.setScreen(null);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/EntityGuiData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/EntityGuiData.java
new file mode 100644
index 00000000000..21064a5ccea
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/EntityGuiData.java
@@ -0,0 +1,18 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+
+public class EntityGuiData extends GuiData {
+
+    private final Entity guiHolder;
+
+    public EntityGuiData(Player player, Entity guiHolder) {
+        super(player);
+        this.guiHolder = guiHolder;
+    }
+
+    public Entity getGuiHolder() {
+        return guiHolder;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/EntityUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/EntityUIFactory.java
new file mode 100644
index 00000000000..785ffc5b0cb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/EntityUIFactory.java
@@ -0,0 +1,62 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class EntityUIFactory extends AbstractUIFactory<EntityGuiData> {
+
+    public static final EntityUIFactory INSTANCE = new EntityUIFactory();
+
+    protected EntityUIFactory() {
+        super(GTCEu.id("entity"));
+    }
+
+    public <E extends Entity & IUIHolder<EntityGuiData>> void open(Player player, E entity) {
+        Objects.requireNonNull(player);
+        verifyEntity(player, entity);
+        GuiManager.open(this, new EntityGuiData(player, entity), (ServerPlayer) player);
+    }
+
+    private static <E extends Entity & IUIHolder<EntityGuiData>> void verifyEntity(Player player, E entity) {
+        Objects.requireNonNull(entity);
+        if (!entity.isAlive()) {
+            throw new IllegalArgumentException("Can't open dead Entity GUI!");
+        } else if (player.level() != entity.level()) {
+            throw new IllegalArgumentException("Entity must be in same dimension as the player!");
+        }
+    }
+
+    @Override
+    public @NotNull IUIHolder<EntityGuiData> getGuiHolder(EntityGuiData guiData) {
+        return Objects.requireNonNull(castUIHolder(guiData.getGuiHolder()), "Found Entity is not a gui holder!");
+    }
+
+    @Override
+    public void writeGuiData(EntityGuiData guiData, FriendlyByteBuf packetBuffer) {
+        packetBuffer.writeInt(guiData.getGuiHolder().getId());
+    }
+
+    @Override
+    public @NotNull EntityGuiData readGuiData(Player entityPlayer, FriendlyByteBuf packetBuffer) {
+        return new EntityGuiData(entityPlayer, entityPlayer.level().getEntity(packetBuffer.readInt()));
+    }
+
+    @Override
+    public boolean canInteractWith(Player player, EntityGuiData guiData) {
+        Entity guiHolder = guiData.getGuiHolder();
+        return super.canInteractWith(player, guiData) &&
+                guiHolder != null &&
+                player.distanceToSqr(guiHolder.getX(), guiHolder.getY(), guiHolder.getZ()) <= 64 &&
+                player.level() == guiHolder.level() &&
+                guiHolder.isAlive();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/GuiData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/GuiData.java
new file mode 100644
index 00000000000..180e50291a3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/GuiData.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * This class and subclasses are holding necessary data to find the exact same GUI on client and server.
+ * For example, if the GUI was opened by right-clicking a BlockEntity, then this data needs a world and a block pos.
+ * <p>
+ * Also see {@link PosGuiData} (useful for BlockEntities), {@link SidedPosGuiData} (useful for covers from GregTech) and
+ * {@link PlayerInventoryGuiData} (useful for guis opened by interacting with an item in the players inventory) for
+ * default
+ * implementations.
+ * </p>
+ */
+public class GuiData {
+
+    @NotNull
+    @Getter
+    private final Player player;
+
+    public GuiData(@NotNull Player player) {
+        this.player = Objects.requireNonNull(player);
+    }
+
+    public Level getLevel() {
+        return getPlayer().level();
+    }
+
+    public boolean isClient() {
+        return NetworkUtils.isClient(this.player);
+    }
+
+    public ItemStack getMainHandItem() {
+        return this.player.getMainHandItem();
+    }
+
+    public ItemStack getOffHandItem() {
+        return this.player.getOffhandItem();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/GuiManager.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/GuiManager.java
new file mode 100644
index 00000000000..8967352c43c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/GuiManager.java
@@ -0,0 +1,231 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.InWorldMUIOpenEvent;
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.RecipeViewerSettings;
+import com.gregtechceu.gtceu.api.mui.base.UIFactory;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.client.mui.screen.*;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.common.network.InWorldContainerSynchronizer;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+import com.gregtechceu.gtceu.common.network.packets.ui.OpenGuiPacket;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+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 net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.FakePlayer;
+import net.minecraftforge.event.TickEvent;
+import net.minecraftforge.event.entity.player.PlayerContainerEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+
+import io.netty.buffer.Unpooled;
+import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+
+@Mod.EventBusSubscriber(modid = GTCEu.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE)
+public class GuiManager {
+
+    private static final Object2ObjectMap<ResourceLocation, UIFactory<?>> FACTORIES = new Object2ObjectOpenHashMap<>(
+            16);
+
+    private static final List<Player> openedContainers = new ArrayList<>(4);
+    private static final Object2ObjectMap<ServerPlayer, List<ModularContainerMenu>> openedInWorldContainers = new Object2ObjectOpenHashMap<>();
+    private static final List<ModularContainerMenu> clientInWorldContainers = new ArrayList<>();
+
+    public static void registerFactory(UIFactory<?> factory) {
+        Objects.requireNonNull(factory);
+        ResourceLocation name = Objects.requireNonNull(factory.getFactoryName());
+        if (FACTORIES.containsKey(name)) {
+            throw new IllegalArgumentException("Factory with name '" + name + "' is already registered!");
+        }
+        FACTORIES.put(name, factory);
+    }
+
+    public static @NotNull UIFactory<?> getFactory(ResourceLocation name) {
+        UIFactory<?> factory = FACTORIES.get(name);
+        if (factory == null) throw new NoSuchElementException("No UI factory for name '" + name + "' found!");
+        return factory;
+    }
+
+    public static boolean hasFactory(ResourceLocation name) {
+        return FACTORIES.containsKey(name);
+    }
+
+    public static <T extends GuiData> void open(@NotNull UIFactory<T> factory, @NotNull T guiData,
+                                                ServerPlayer player) {
+        open(factory, false, guiData, player);
+    }
+
+    public static <T extends GuiData> void open(@NotNull UIFactory<T> factory, boolean inWorldUI, @NotNull T guiData,
+                                                ServerPlayer player) {
+        if (player instanceof FakePlayer || openedContainers.contains(player)) return;
+        if (!inWorldUI) openedContainers.add(player);
+        // create panel, collect sync handlers and create menu
+        UISettings settings = new UISettings(RecipeViewerSettings.DUMMY);
+        settings.defaultCanInteractWith(factory, guiData);
+        ModularSyncManager msm = new ModularSyncManager(false);
+        PanelSyncManager syncManager = new PanelSyncManager(msm, true);
+        ModularPanel panel = factory.createPanel(guiData, syncManager, settings);
+        WidgetTree.collectSyncValues(syncManager, panel);
+
+        // create the menu
+        player.nextContainerCounter();
+        if (player.containerMenu != player.inventoryMenu && !inWorldUI) {
+            player.closeContainer();
+        }
+        int windowId = player.containerCounter;
+        ModularContainerMenu menu = settings.hasCustomContainer() ? settings.createContainer(windowId) :
+                factory.createContainer(windowId);
+        menu.construct(player, msm, settings, panel.getName(), guiData);
+
+        // sync to client
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        factory.writeGuiData(guiData, buffer);
+        int nid = ModularNetwork.SERVER.activate(msm);
+        GTNetwork.sendToPlayer(player, new OpenGuiPacket<>(windowId, nid, factory, buffer, inWorldUI));
+        // open the menu // this mimics forge behaviour
+        if (!inWorldUI) {
+            player.initMenu(menu);
+            player.containerMenu = menu;
+        } else {
+            List<ModularContainerMenu> tmp = openedInWorldContainers.computeIfAbsent(player, p -> new ArrayList<>());
+            menu.inWorldID = tmp.size();
+            tmp.add(menu);
+            menu.setSynchronizer(new InWorldContainerSynchronizer(player));
+        }
+        msm.onOpen();
+        // finally invoke event
+        MinecraftForge.EVENT_BUS.post(new PlayerContainerEvent.Open(player, menu));
+    }
+
+    @ApiStatus.Internal
+    @OnlyIn(Dist.CLIENT)
+    public static <T extends GuiData> void openFromClient(int windowId, int networkId, boolean inWorldUI,
+                                                          @NotNull UIFactory<T> factory,
+                                                          @NotNull FriendlyByteBuf data, @NotNull LocalPlayer player) {
+        T guiData = factory.readGuiData(player, data);
+        UISettings settings = new UISettings();
+        if (inWorldUI) settings.getRecipeViewerSettings().disable();
+        settings.defaultCanInteractWith(factory, guiData);
+        ModularSyncManager msm = new ModularSyncManager(true);
+        PanelSyncManager syncManager = new PanelSyncManager(msm, true);
+        ModularPanel panel = factory.createPanel(guiData, syncManager, settings);
+        WidgetTree.collectSyncValues(syncManager, panel);
+        ModularScreen screen = factory.createScreen(guiData, panel);
+        screen.getContext().setSettings(settings);
+        ModularContainerMenu container = settings.hasCustomContainer() ? settings.createContainer(windowId) :
+                factory.createContainer(windowId);
+        container.construct(player, msm, settings, panel.getName(), guiData);
+        IMuiScreen wrapper = settings.hasCustomGui() ? settings.createGui(container, screen) :
+                factory.createScreenWrapper(container, screen);
+        if (!(wrapper.getWrappedScreen() instanceof AbstractContainerScreen<?> guiContainer)) {
+            throw new IllegalStateException("The wrapping screen must be a GuiContainer for synced GUIs!");
+        }
+        if (guiContainer.getMenu() != container)
+            throw new IllegalStateException("Custom Containers are not yet allowed!");
+        ModularNetwork.CLIENT.activate(networkId, msm);
+        if (inWorldUI) {
+            container.inWorldID = clientInWorldContainers.size();
+            clientInWorldContainers.add(container);
+            MinecraftForge.EVENT_BUS
+                    .post(new InWorldMUIOpenEvent(guiData, wrapper.getWrappedScreen(), screen, container));
+        } else {
+            MCHelper.setScreen(wrapper.getWrappedScreen());
+            player.containerMenu = guiContainer.getMenu();
+        }
+        msm.onOpen();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static <T extends GuiData> void openFromClient(@NotNull UIFactory<T> factory, @NotNull T guiData) {
+        openFromClient(factory, guiData, false);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static <T extends GuiData> void openFromClient(@NotNull UIFactory<T> factory, @NotNull T guiData,
+                                                          boolean inWorldUI) {
+        // notify server to open the gui
+        // server will send packet back to actually open the gui
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        factory.writeGuiData(guiData, buffer);
+        GTNetwork.sendToServer(new OpenGuiPacket<>(0, 0, factory, buffer, inWorldUI));
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    static void openScreen(ModularScreen screen, UISettings settings) {
+        if (screen.getScreenWrapper() != null &&
+                MCHelper.getCurrentScreen() == screen.getScreenWrapper().getWrappedScreen()) {
+            // already open
+            return;
+        }
+        screen.getContext().setSettings(settings);
+        Screen guiScreen;
+        if (settings.hasCustomContainer()) {
+            ModularContainerMenu container = settings.createContainer(0);
+            container.constructClientOnly();
+            guiScreen = new ContainerScreenWrapper(container, screen);
+        } else {
+            guiScreen = new ScreenWrapper(screen);
+        }
+        MCHelper.setScreen(guiScreen);
+    }
+
+    @SubscribeEvent
+    public static void onTick(TickEvent.ServerTickEvent event) {
+        if (event.phase == TickEvent.Phase.END) {
+            openedContainers.clear();
+            openedInWorldContainers.values().forEach(arr -> arr.forEach(ModularContainerMenu::onUpdate));
+            openedInWorldContainers.values().forEach(arr -> arr.forEach(ModularContainerMenu::broadcastChanges));
+        }
+    }
+
+    @SubscribeEvent
+    public static void onClientTick(TickEvent.ClientTickEvent event) {
+        if (event.phase == TickEvent.Phase.END) {
+            clientInWorldContainers.forEach(ModularContainerMenu::onUpdate);
+            clientInWorldContainers.forEach(ModularContainerMenu::broadcastChanges);
+        }
+    }
+
+    @SubscribeEvent
+    public static void onOpenContainer(PlayerContainerEvent.Open event) {
+        if (event.getContainer() instanceof ModularContainerMenu modularContainer) {
+            modularContainer.opened();
+        }
+    }
+
+    @SubscribeEvent
+    public static void onCloseContainer(PlayerContainerEvent.Close event) {
+        if (event.getContainer() instanceof ModularContainerMenu modularContainer) {
+            modularContainer.removed(event.getEntity());
+        }
+    }
+
+    public static ModularContainerMenu getClientInWorldMenu(int inWorldID) {
+        return clientInWorldContainers.get(inWorldID);
+    }
+
+    public static ModularContainerMenu getServerInWorldMenu(ServerPlayer player, int inWorldID) {
+        return openedInWorldContainers.get(player).get(inWorldID);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/HandGuiData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/HandGuiData.java
new file mode 100644
index 00000000000..e2e273988b7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/HandGuiData.java
@@ -0,0 +1,38 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+
+import lombok.Getter;
+
+/**
+ * See {@link GuiData} for an explanation for what this is for.
+ */
+@Deprecated
+public class HandGuiData extends GuiData {
+
+    @Getter
+    private final InteractionHand hand;
+
+    public HandGuiData(Player player, InteractionHand hand) {
+        super(player);
+        this.hand = hand;
+    }
+
+    public ItemStack getUsedItem() {
+        return getPlayer().getItemInHand(this.hand);
+    }
+
+    public void setItemInMainHand(ItemStack item) {
+        getPlayer().setItemInHand(InteractionHand.MAIN_HAND, item);
+    }
+
+    public void setItemInOffHand(ItemStack item) {
+        getPlayer().setItemInHand(InteractionHand.OFF_HAND, item);
+    }
+
+    public void setItemInUsedHand(ItemStack item) {
+        getPlayer().setItemInHand(this.hand, item);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ItemUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ItemUIFactory.java
new file mode 100644
index 00000000000..f6a41d25c33
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ItemUIFactory.java
@@ -0,0 +1,56 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.player.Player;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * @deprecated use {@link PlayerInventoryUIFactory}
+ */
+@Deprecated
+public class ItemUIFactory extends AbstractUIFactory<HandGuiData> {
+
+    public static final ItemUIFactory INSTANCE = new ItemUIFactory();
+
+    private ItemUIFactory() {
+        super(GTCEu.id("item"));
+    }
+
+    public void open(Player player, InteractionHand hand) {
+        if (player instanceof ServerPlayer entityServerPlayer) {
+            open(entityServerPlayer, hand);
+            return;
+        }
+        throw new IllegalStateException("Synced GUIs must be opened from server side");
+    }
+
+    public void open(ServerPlayer player, InteractionHand hand) {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(hand);
+        HandGuiData guiData = new HandGuiData(player, hand);
+        GuiManager.open(this, guiData, player);
+    }
+
+    @Override
+    public @NotNull IUIHolder<HandGuiData> getGuiHolder(HandGuiData data) {
+        return Objects.requireNonNull(castUIHolder(data.getUsedItem().getItem()), "Item was not a gui holder!");
+    }
+
+    @Override
+    public void writeGuiData(HandGuiData guiData, FriendlyByteBuf buffer) {
+        buffer.writeByte(guiData.getHand().ordinal());
+    }
+
+    @Override
+    public @NotNull HandGuiData readGuiData(Player player, FriendlyByteBuf buffer) {
+        return new HandGuiData(player, InteractionHand.values()[buffer.readByte()]);
+    }
+}
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..491c3c8604b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelEditor.java
@@ -0,0 +1,13 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
+@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..6f4eae5ee8d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelFactory.java
@@ -0,0 +1,52 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.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;
+
+@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);
+    };
+
+    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/mui/factory/PlayerInventoryGuiData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PlayerInventoryGuiData.java
new file mode 100644
index 00000000000..a7e96bc257b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PlayerInventoryGuiData.java
@@ -0,0 +1,56 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.mui.factory.inventory.InventoryType;
+
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * GuiData that finds an item in a player bound inventory. This can be the hotbar, main inventory, armor slots, offhand
+ * slot or curios slots
+ * if curios is loaded.
+ *
+ * @param <T> Type of the context. Usually {@link Void}. User will usually use <?>.
+ */
+@Getter
+public class PlayerInventoryGuiData<T> extends GuiData {
+
+    public static <T> PlayerInventoryGuiData<T> of(@NotNull Player player, @NotNull InventoryType<T> inventoryType,
+                                                   T context,
+                                                   int slotIndex) {
+        return new PlayerInventoryGuiData<>(player, inventoryType, context, slotIndex);
+    }
+
+    /**
+     * Inventory type where the item can be found (player or curios for example).
+     */
+    @NotNull
+    private final InventoryType<T> inventoryType;
+    /**
+     * Additional context to find the item. Usually this is null, but for curios it is a string (slot identifier).
+     */
+    private final T context;
+    /**
+     * Slot index where the item can be found.
+     */
+    private final int slotIndex;
+
+    private PlayerInventoryGuiData(@NotNull Player player, @NotNull InventoryType<T> inventoryType, T context,
+                                   int slotIndex) {
+        super(player);
+        this.inventoryType = inventoryType;
+        this.context = context;
+        this.slotIndex = slotIndex;
+    }
+
+    public ItemStack getUsedItemStack() {
+        return getInventoryType().getStackInSlot(getPlayer(), context, this.slotIndex);
+    }
+
+    public void setUsedItemStack(ItemStack stack) {
+        getInventoryType().setStackInSlot(getPlayer(), context, this.slotIndex, stack);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PlayerInventoryUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PlayerInventoryUIFactory.java
new file mode 100644
index 00000000000..0fb895f32ad
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PlayerInventoryUIFactory.java
@@ -0,0 +1,102 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.factory.inventory.InventoryType;
+import com.gregtechceu.gtceu.api.mui.factory.inventory.InventoryTypes;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class PlayerInventoryUIFactory extends AbstractUIFactory<PlayerInventoryGuiData<?>> {
+
+    public static final PlayerInventoryUIFactory INSTANCE = new PlayerInventoryUIFactory();
+
+    public void openFromPlayerInventory(Player player, int index) {
+        GuiManager.open(
+                this, PlayerInventoryGuiData.of(player, InventoryTypes.PLAYER, null, index), verifyServerSide(player));
+    }
+
+    public void openFromHand(Player player, InteractionHand hand) {
+        openFromPlayerInventory(player,
+                hand == InteractionHand.OFF_HAND ? Inventory.SLOT_OFFHAND : player.getInventory().selected);
+    }
+
+    public void openFromCurios(Player player, String type, int index) {
+        if (!GTCEu.Mods.isCuriosLoaded()) {
+            throw new IllegalArgumentException("Can't open UI for curio item when curios is not loaded!");
+        }
+        GuiManager.open(
+                this, PlayerInventoryGuiData.of(player, InventoryTypes.CURIOS, type, index), verifyServerSide(player));
+    }
+
+    public <T> void open(Player player, InventoryType<T> type, T context, int index) {
+        GuiManager.open(this, PlayerInventoryGuiData.of(player, type, context, index), verifyServerSide(player));
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void openFromPlayerInventoryClient(int index) {
+        GuiManager.openFromClient(this,
+                PlayerInventoryGuiData.of(MCHelper.getPlayer(), InventoryTypes.PLAYER, null, index));
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void openFromHandClient(InteractionHand hand) {
+        openFromPlayerInventoryClient(
+                hand == InteractionHand.OFF_HAND ? Inventory.SLOT_OFFHAND :
+                        MCHelper.getPlayer().getInventory().selected);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void openFromCuriosClient(String type, int index) {
+        if (!GTCEu.Mods.isCuriosLoaded()) {
+            throw new IllegalArgumentException("Can't open UI for curio item when curios is not loaded!");
+        }
+        GuiManager.openFromClient(
+                this, PlayerInventoryGuiData.of(MCHelper.getPlayer(), InventoryTypes.CURIOS, type, index));
+    }
+
+    @SideOnly(Side.CLIENT)
+    public <T> void openClient(InventoryType<T> type, T context, int index) {
+        GuiManager.openFromClient(this, PlayerInventoryGuiData.of(MCHelper.getPlayer(), type, context, index));
+    }
+
+    private PlayerInventoryUIFactory() {
+        super(GTCEu.id("player_inventory"));
+    }
+
+    @Override
+    public @NotNull IUIHolder<PlayerInventoryGuiData<?>> getGuiHolder(PlayerInventoryGuiData<?> data) {
+        return Objects.requireNonNull(castUIHolder(data.getUsedItemStack().getItem()), "Item was not a gui holder!");
+    }
+
+    @Override
+    public void writeGuiData(PlayerInventoryGuiData<?> guiData, FriendlyByteBuf buffer) {
+        guiData.getInventoryType().write(buffer);
+        writeContext(buffer, guiData.getInventoryType(), guiData.getContext());
+        buffer.writeVarInt(guiData.getSlotIndex());
+    }
+
+    private static <T> void writeContext(FriendlyByteBuf buffer, InventoryType<T> type, Object context) {
+        type.writeContext(buffer, type.castContext(context));
+    }
+
+    @Override
+    public @NotNull PlayerInventoryGuiData<?> readGuiData(Player player, FriendlyByteBuf buffer) {
+        return readContext(player, buffer, InventoryType.read(buffer));
+    }
+
+    private static <T> PlayerInventoryGuiData<?> readContext(Player player, FriendlyByteBuf buffer,
+                                                             InventoryType<T> inventoryType) {
+        return PlayerInventoryGuiData.of(player, inventoryType, inventoryType.readContext(buffer), buffer.readVarInt());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PosGuiData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PosGuiData.java
new file mode 100644
index 00000000000..c9611fba243
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PosGuiData.java
@@ -0,0 +1,52 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Position;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BlockEntity;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * See {@link GuiData} for an explanation for what this is for.
+ */
+@Getter
+public class PosGuiData extends GuiData {
+
+    private final BlockPos blockPos;
+
+    public PosGuiData(@NotNull Player player, BlockPos blockPos) {
+        super(player);
+        this.blockPos = blockPos;
+    }
+
+    public double getSquaredDistance(double x, double y, double z) {
+        return this.blockPos.distToCenterSqr(x, y, z);
+    }
+
+    public double getSquaredDistance(Position pos) {
+        return getSquaredDistance(pos.x(), pos.y(), pos.z());
+    }
+
+    public double getDistance(double x, double y, double z) {
+        return Math.sqrt(getSquaredDistance(x, y, z));
+    }
+
+    public double getDistance(Position pos) {
+        return Math.sqrt(getSquaredDistance(pos));
+    }
+
+    public double getSquaredDistance(Entity entity) {
+        return getSquaredDistance(entity.position());
+    }
+
+    public double getDistance(Entity entity) {
+        return Math.sqrt(getSquaredDistance(entity));
+    }
+
+    public BlockEntity getBlockEntity() {
+        return getLevel().getBlockEntity(this.blockPos);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SidedBlockEntityUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SidedBlockEntityUIFactory.java
new file mode 100644
index 00000000000..d6a183736e9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SidedBlockEntityUIFactory.java
@@ -0,0 +1,84 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+
+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 net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class SidedBlockEntityUIFactory extends AbstractUIFactory<SidedPosGuiData> {
+
+    public static final SidedBlockEntityUIFactory INSTANCE = new SidedBlockEntityUIFactory();
+
+    public <T extends BlockEntity & IUIHolder<SidedPosGuiData>> void open(Player player, T blockEntity,
+                                                                          Direction facing) {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(facing);
+        BlockEntityUIFactory.verifyBlockEntity(MCHelper.getPlayer(), blockEntity);
+        BlockPos pos = blockEntity.getBlockPos();
+        SidedPosGuiData data = new SidedPosGuiData(player, pos, facing);
+        GuiManager.open(this, data, (ServerPlayer) player);
+    }
+
+    public void open(Player player, BlockPos pos, Direction facing) {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(pos);
+        Objects.requireNonNull(facing);
+        SidedPosGuiData data = new SidedPosGuiData(player, pos, facing);
+        GuiManager.open(this, data, (ServerPlayer) player);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public <T extends BlockEntity & IUIHolder<SidedPosGuiData>> void openClient(T blockEntity, Direction facing) {
+        Objects.requireNonNull(facing);
+        BlockEntityUIFactory.verifyBlockEntity(MCHelper.getPlayer(), blockEntity);
+        BlockPos pos = blockEntity.getBlockPos();
+        SidedPosGuiData data = new SidedPosGuiData(MCHelper.getPlayer(), pos, facing);
+        GuiManager.openFromClient(this, data);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void openClient(BlockPos pos, Direction facing) {
+        Objects.requireNonNull(pos);
+        Objects.requireNonNull(facing);
+        SidedPosGuiData data = new SidedPosGuiData(MCHelper.getPlayer(), pos, facing);
+        GuiManager.openFromClient(this, data);
+    }
+
+    private SidedBlockEntityUIFactory() {
+        super(GTCEu.id("sided_block_entity"));
+    }
+
+    @Override
+    public @NotNull IUIHolder<SidedPosGuiData> getGuiHolder(SidedPosGuiData data) {
+        return Objects.requireNonNull(castUIHolder(data.getBlockEntity()), "Found BlockEntity is not a gui holder!");
+    }
+
+    @Override
+    public boolean canInteractWith(Player player, SidedPosGuiData guiData) {
+        return player == guiData.getPlayer() && guiData.getBlockEntity() != null &&
+                guiData.getSquaredDistance(player) <= 64;
+    }
+
+    @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/SidedPosGuiData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SidedPosGuiData.java
new file mode 100644
index 00000000000..9d74510ca1a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SidedPosGuiData.java
@@ -0,0 +1,23 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.entity.player.Player;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * See {@link GuiData} for an explanation for what this is for.
+ */
+@Getter
+public class SidedPosGuiData extends PosGuiData {
+
+    @NotNull
+    private final Direction side;
+
+    public SidedPosGuiData(@NotNull Player player, BlockPos pos, @NotNull Direction side) {
+        super(player, pos);
+        this.side = side;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SimpleUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SimpleUIFactory.java
new file mode 100644
index 00000000000..0320b91dba3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/SimpleUIFactory.java
@@ -0,0 +1,78 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+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 org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.function.Supplier;
+
+/**
+ * Sometimes you don't want to open guis which are bound to a BlockEntity or an Item.
+ * For example by a command. You are supposed to create one simple factory per GUI to make sure they are same
+ * on client and server.
+ * These factories are registered automatically.
+ */
+public class SimpleUIFactory extends AbstractUIFactory<GuiData> {
+
+    private final Supplier<IUIHolder<GuiData>> guiHolderSupplier;
+    private IUIHolder<GuiData> guiHolder;
+
+    /**
+     * Creates a simple gui factory.
+     *
+     * @param name      name of the factory
+     * @param guiHolder gui holder
+     */
+    public SimpleUIFactory(ResourceLocation name, IUIHolder<GuiData> guiHolder) {
+        this(name, () -> guiHolder);
+    }
+
+    /**
+     * Creates a simple gui factory.
+     *
+     * @param name              name of the factory
+     * @param guiHolderSupplier a function which retrieves a gui holder. This is only called once and then cached.
+     */
+    public SimpleUIFactory(ResourceLocation name, Supplier<IUIHolder<GuiData>> guiHolderSupplier) {
+        super(name);
+        this.guiHolderSupplier = guiHolderSupplier;
+        GuiManager.registerFactory(this);
+    }
+
+    public void init() {}
+
+    public void open(ServerPlayer player) {
+        GuiManager.open(this, new GuiData(player), player);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void openClient() {
+        GuiManager.openFromClient(this, new GuiData(MCHelper.getPlayer()));
+    }
+
+    @Override
+    public void writeGuiData(GuiData guiData, FriendlyByteBuf buffer) {}
+
+    @Override
+    public @NotNull GuiData readGuiData(Player player, FriendlyByteBuf buffer) {
+        return new GuiData(player);
+    }
+
+    @Override
+    public @NotNull IUIHolder<GuiData> getGuiHolder(GuiData data) {
+        if (this.guiHolder == null) {
+            this.guiHolder = this.guiHolderSupplier.get();
+            Objects.requireNonNull(this.guiHolder, "IUIHolder must not be null");
+        }
+        return this.guiHolder;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/UIFactories.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/UIFactories.java
new file mode 100644
index 00000000000..cf6b0d3c2b2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/UIFactories.java
@@ -0,0 +1,64 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.common.mui.factory.CoverUIFactory;
+import com.gregtechceu.gtceu.common.mui.factory.MachineUIFactory;
+
+import net.minecraft.resources.ResourceLocation;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.Supplier;
+
+public class UIFactories {
+
+    public static BlockEntityUIFactory blockEntity() {
+        return BlockEntityUIFactory.INSTANCE;
+    }
+
+    public static SidedBlockEntityUIFactory sidedBlockEntity() {
+        return SidedBlockEntityUIFactory.INSTANCE;
+    }
+
+    public static EntityUIFactory entity() {
+        return EntityUIFactory.INSTANCE;
+    }
+
+    @Deprecated
+    public static ItemUIFactory item() {
+        return ItemUIFactory.INSTANCE;
+    }
+
+    public static PlayerInventoryUIFactory playerInventory() {
+        return PlayerInventoryUIFactory.INSTANCE;
+    }
+
+    public static MachineUIFactory machine() {
+        return MachineUIFactory.INSTANCE;
+    }
+
+    public static CoverUIFactory cover() {
+        return CoverUIFactory.INSTANCE;
+    }
+
+    public static SimpleUIFactory createSimple(ResourceLocation name, IUIHolder<GuiData> holder) {
+        return new SimpleUIFactory(name, holder);
+    }
+
+    public static SimpleUIFactory createSimple(ResourceLocation name, Supplier<IUIHolder<GuiData>> holder) {
+        return new SimpleUIFactory(name, holder);
+    }
+
+    @ApiStatus.Internal
+    public static void init() {
+        GuiManager.registerFactory(blockEntity());
+        GuiManager.registerFactory(sidedBlockEntity());
+        GuiManager.registerFactory(entity());
+        GuiManager.registerFactory(item());
+        GuiManager.registerFactory(playerInventory());
+        GuiManager.registerFactory(machine());
+        GuiManager.registerFactory(cover());
+    }
+
+    private UIFactories() {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/Container.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/Container.java
new file mode 100644
index 00000000000..e2bbcbf740f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/Container.java
@@ -0,0 +1,57 @@
+package com.gregtechceu.gtceu.api.mui.factory.inventory;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+
+/**
+ * A {@link InventoryType} implementation for {@link net.minecraft.world.Container Container}.
+ */
+public abstract class Container extends InventoryType<Void> {
+
+    public Container(String id) {
+        super(id);
+    }
+
+    public abstract net.minecraft.world.Container getInventory(Player player);
+
+    @Override
+    public ItemStack getStackInSlot(Player player, Void context, int index) {
+        return getInventory(player).getItem(index);
+    }
+
+    @Override
+    public void setStackInSlot(Player player, Void context, int index, ItemStack stack) {
+        getInventory(player).setItem(index, stack);
+    }
+
+    public int getSlotCount(Player player) {
+        return getInventory(player).getContainerSize();
+    }
+
+    /**
+     * Visits all slots in the inventory with the given visitor function.
+     *
+     * @param player  player of which inventory to visit
+     * @param visitor visit function
+     * @return if the visitor function returned true on a slot
+     */
+    @Override
+    public boolean visitAll(Player player, InventoryVisitor<Void> visitor) {
+        for (int i = 0, n = getSlotCount(player); i < n; ++i) {
+            ItemStack stackInSlot = getStackInSlot(player, null, i);
+            if (visitor.visit(this, null, i, stackInSlot)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void writeContext(FriendlyByteBuf byteBuf, Void context) {}
+
+    @Override
+    public Void readContext(FriendlyByteBuf byteBuf) {
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/CuriosHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/CuriosHandler.java
new file mode 100644
index 00000000000..51539022831
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/CuriosHandler.java
@@ -0,0 +1,71 @@
+package com.gregtechceu.gtceu.api.mui.factory.inventory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.IItemHandlerModifiable;
+
+import top.theillusivec4.curios.api.CuriosApi;
+import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
+import top.theillusivec4.curios.api.type.inventory.ICurioStacksHandler;
+
+import java.util.Map;
+
+public class CuriosHandler extends InventoryType<String> {
+
+    public static final CuriosHandler INSTANCE = new CuriosHandler();
+
+    private CuriosHandler() {
+        super("curios");
+    }
+
+    public static ICuriosItemHandler getCuriosHandler(Player player) {
+        return CuriosApi.getCuriosInventory(player)
+                .orElseThrow(() -> new IllegalStateException("Curios handler for player not found"));
+    }
+
+    @Override
+    public boolean isActive() {
+        return GTCEu.Mods.isCuriosLoaded();
+    }
+
+    @Override
+    public ItemStack getStackInSlot(Player player, String context, int index) {
+        return getCuriosHandler(player).getStacksHandler(context)
+                .map(stacksHandler -> stacksHandler.getStacks().getStackInSlot(index))
+                .orElse(ItemStack.EMPTY);
+    }
+
+    @Override
+    public void setStackInSlot(Player player, String context, int index, ItemStack stack) {
+        getCuriosHandler(player).getStacksHandler(context)
+                .ifPresent(stacksHandler -> stacksHandler.getStacks().setStackInSlot(index, stack));
+    }
+
+    @Override
+    public boolean visitAll(Player player, InventoryVisitor<String> visitor) {
+        Map<String, ICurioStacksHandler> handlers = getCuriosHandler(player).getCurios();
+        for (ICurioStacksHandler handler : handlers.values()) {
+            IItemHandlerModifiable itemHandler = handler.getStacks();
+            for (int i = 0; i < itemHandler.getSlots(); i++) {
+                if (visitor.visit(this, handler.getIdentifier(), i, itemHandler.getStackInSlot(i))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void writeContext(FriendlyByteBuf byteBuf, String context) {
+        NetworkUtils.writeStringSafe(byteBuf, context);
+    }
+
+    @Override
+    public String readContext(FriendlyByteBuf byteBuf) {
+        return NetworkUtils.readStringSafe(byteBuf);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryType.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryType.java
new file mode 100644
index 00000000000..f3bf79a86da
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryType.java
@@ -0,0 +1,147 @@
+package com.gregtechceu.gtceu.api.mui.factory.inventory;
+
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.ItemHandlerHelper;
+
+import lombok.Getter;
+
+/**
+ * A way of finding and setting an item in an inventory, that is owned by a player. This includes the normal player
+ * inventory with all its
+ * slots including main hand, off-hand and armor slots. It can also be used for curios inventory if it is loaded. An
+ * inventory type has an
+ * id assigned used for syncing. An item stack can be found with a context object and an index. Usually the context is
+ * null with type
+ * {@link Void}. For curios, it is a string, since slots are not just indexed, but first mapped to an identifier.
+ *
+ * @param <T> The type of the context. Usually it is {@link Void}, but can be anything needed to find the same item
+ *            stack in client and
+ *            server.
+ * @see InventoryTypes InventoryTypes for default implementations
+ */
+public abstract class InventoryType<T> {
+
+    @Getter
+    private final String id;
+
+    public InventoryType(String id) {
+        this.id = id;
+        if (isActive()) {
+            InventoryTypes.inventoryTypes.put(id, this);
+        }
+    }
+
+    public boolean isActive() {
+        return true;
+    }
+
+    /**
+     * Obtains a stack from a slot in this inventory type.
+     *
+     * @param player  player of inventory
+     * @param context extra context to find the slot (needed for curios)
+     * @param index   index of the slot
+     * @return a stack
+     */
+    public abstract ItemStack getStackInSlot(Player player, T context, int index);
+
+    /**
+     * Sets a stack in a slot in this inventory type.
+     *
+     * @param player  player of inventory
+     * @param context extra context to find the slot (needed for curios)
+     * @param index   index of the slot
+     * @param stack   stack to set
+     */
+    public abstract void setStackInSlot(Player player, T context, int index, ItemStack stack);
+
+    /**
+     * Returns the first stackable slot index for the given item
+     *
+     * @param player player of which inventory to visit
+     * @param stack  stack which should be checked stackability with
+     * @return index of slot with stackable item or -1 if none found
+     */
+    public int findFirstStackable(Player player, ItemStack stack, boolean ignoreEmpty) {
+        int[] holder = { -1 };
+        visitAllStackable(player, stack, (type, context, index, stackInSlot) -> {
+            if (stackInSlot.isEmpty() && ignoreEmpty) return false;
+            holder[0] = index;
+            return true;
+        });
+        return holder[0];
+    }
+
+    /**
+     * Visits all slots which item is stackable with the given item in the inventory with the given visitor function.
+     * Two empty items also
+     * count as stackable.
+     *
+     * @param player  player of which inventory to visit
+     * @param stack   stack which should be checked stackability with
+     * @param visitor visit function
+     * @return if the visitor function returned true on a slot
+     */
+    public boolean visitAllStackable(Player player, ItemStack stack, InventoryVisitor<T> visitor) {
+        visitAll(player, (type, context, index, stackInSlot) -> {
+            if ((stackInSlot.isEmpty() && stack.isEmpty()) ||
+                    ItemHandlerHelper.canItemStacksStack(stackInSlot, stack)) {
+                return visitor.visit(type, context, index, stack);
+            }
+            return false;
+        });
+        return false;
+    }
+
+    /**
+     * Casts a context to the right type. Note that this is unchecked.
+     *
+     * @param o untyped context
+     * @return typed context
+     */
+    @SuppressWarnings("unchecked")
+    public T castContext(Object o) {
+        return (T) o;
+    }
+
+    /**
+     * Visits all slots in the inventory with the given visitor function.
+     *
+     * @param player  player of which inventory to visit
+     * @param visitor visit function
+     * @return if the visitor function returned true on a slot
+     */
+    public abstract boolean visitAll(Player player, InventoryVisitor<T> visitor);
+
+    /**
+     * Writes a context to a buffer.
+     *
+     * @param byteBuf byte buffer
+     * @param context context
+     */
+    public abstract void writeContext(FriendlyByteBuf byteBuf, T context);
+
+    /**
+     * Reads a context from a buffer.
+     *
+     * @param byteBuf byte buffer
+     * @return context
+     */
+    public abstract T readContext(FriendlyByteBuf byteBuf);
+
+    public void write(FriendlyByteBuf buf) {
+        NetworkUtils.writeStringSafe(buf, id);
+    }
+
+    public static InventoryType<?> read(FriendlyByteBuf buf) {
+        return getFromId(NetworkUtils.readStringSafe(buf));
+    }
+
+    public static InventoryType<?> getFromId(String id) {
+        return InventoryTypes.inventoryTypes.get(id);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryTypes.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryTypes.java
new file mode 100644
index 00000000000..05417c711cf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryTypes.java
@@ -0,0 +1,119 @@
+package com.gregtechceu.gtceu.api.mui.factory.inventory;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.factory.UIFactories;
+import com.gregtechceu.gtceu.api.mui.test.TestItem;
+import com.gregtechceu.gtceu.common.data.GTCreativeModeTabs;
+
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.client.event.InputEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import com.tterrag.registrate.providers.ProviderType;
+import com.tterrag.registrate.util.entry.ItemEntry;
+import com.tterrag.registrate.util.nullness.NonNullBiConsumer;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+import static com.gregtechceu.gtceu.common.registry.GTRegistration.REGISTRATE;
+
+public final class InventoryTypes {
+
+    public static final ItemEntry<TestItem> TEST_ITEM = REGISTRATE.item("mui_test_item", TestItem::new)
+            .tab(GTCreativeModeTabs.ITEM.getKey())
+            .setData(ProviderType.LANG, NonNullBiConsumer.noop())
+            .setData(ProviderType.ITEM_MODEL, NonNullBiConsumer.noop())
+            .register();
+
+    @ApiStatus.Internal
+    public static void init() {
+        MinecraftForge.EVENT_BUS.addListener(InventoryTypes::onKeyInput);
+    }
+
+    @SubscribeEvent
+    public static void onKeyInput(InputEvent.Key event) {
+        if (event.getAction() == InputConstants.PRESS && event.getKey() == InputConstants.KEY_NUMPAD2) {
+            InventoryTypes.visitAll(MCHelper.getPlayer(), (type, context, index, stackInSlot) -> {
+                if (!stackInSlot.isEmpty() && stackInSlot.getItem() instanceof TestItem) {
+                    UIFactories.playerInventory().openClient(type, context, index);
+                    return true;
+                }
+                return false;
+            });
+        }
+    }
+
+    static final Map<String, InventoryType<?>> inventoryTypes = new Object2ObjectOpenHashMap<>();
+
+    public static final Container PLAYER = new Container("player") {
+
+        @Override
+        public net.minecraft.world.Container getInventory(Player player) {
+            return player.getInventory();
+        }
+    };
+
+    public static final CuriosHandler CURIOS = CuriosHandler.INSTANCE;
+
+    public static Collection<InventoryType<?>> getAll() {
+        return getAllRegistered();
+    }
+
+    public static @Nullable SlotFindResult<?> findFirstStackable(Player player, ItemStack stack, boolean ignoreEmpty) {
+        for (InventoryType<?> type : getAll()) {
+            if (type instanceof CuriosHandler) continue;
+            int i = type.findFirstStackable(player, stack, ignoreEmpty);
+            if (i >= 0) return new SlotFindResult<>(type, null, i);
+        }
+        return null;
+    }
+
+    /**
+     * Visits all slots where the item can be stacked with the given item of all inventory types, this includes the
+     * player inventory, with
+     * hotbar, main inventory, armor slots, offhand slot and curios slots if curios is loaded.
+     *
+     * @param player  the player to visit inventory in
+     * @param stack   item stack to check stackability for
+     * @param visitor visitor function
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static void visitAllStackable(Player player, ItemStack stack, InventoryVisitor<?> visitor) {
+        for (InventoryType type : getAll()) {
+            if (type.visitAllStackable(player, stack, visitor)) {
+                return;
+            }
+        }
+    }
+
+    /**
+     * Visits all slots of all inventory types, this includes the player inventory, with hotbar, main inventory, armor
+     * slots, offhand slot
+     * and curios slots if curios is loaded.
+     *
+     * @param player  the player to visit inventory in
+     * @param visitor visitor function
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static void visitAll(Player player, InventoryVisitor<?> visitor) {
+        for (InventoryType type : getAll()) {
+            if (type.visitAll(player, visitor)) {
+                return;
+            }
+        }
+    }
+
+    public static Collection<InventoryType<?>> getAllRegistered() {
+        return Collections.unmodifiableCollection(inventoryTypes.values());
+    }
+
+    public record SlotFindResult<T>(InventoryType<T> type, T context, int slot) {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryVisitor.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryVisitor.java
new file mode 100644
index 00000000000..0295cd11514
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/InventoryVisitor.java
@@ -0,0 +1,20 @@
+package com.gregtechceu.gtceu.api.mui.factory.inventory;
+
+import net.minecraft.world.item.ItemStack;
+
+/**
+ * A function to visit a slot in a player bound inventory.
+ */
+public interface InventoryVisitor<T> {
+
+    /**
+     * Called on visiting a slot in a player bound inventory.
+     *
+     * @param type        type of the current inventory
+     * @param context     additional context of the slot location (usually null, but is a string for curios)
+     * @param index       index of the slot
+     * @param stackInSlot content of the slot
+     * @return true if no further slots should be visited
+     */
+    boolean visit(InventoryType<T> type, T context, int index, ItemStack stackInSlot);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/ItemHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/ItemHandler.java
new file mode 100644
index 00000000000..e12395d161b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/inventory/ItemHandler.java
@@ -0,0 +1,58 @@
+package com.gregtechceu.gtceu.api.mui.factory.inventory;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.IItemHandlerModifiable;
+
+/**
+ * A {@link InventoryType} implementation for {@link IItemHandlerModifiable}.
+ */
+public abstract class ItemHandler extends InventoryType<Void> {
+
+    public ItemHandler(String id) {
+        super(id);
+    }
+
+    public abstract IItemHandlerModifiable getInventory(Player player);
+
+    @Override
+    public ItemStack getStackInSlot(Player player, Void context, int index) {
+        return getInventory(player).getStackInSlot(index);
+    }
+
+    @Override
+    public void setStackInSlot(Player player, Void context, int index, ItemStack stack) {
+        getInventory(player).setStackInSlot(index, stack);
+    }
+
+    public int getSlotCount(Player player) {
+        return getInventory(player).getSlots();
+    }
+
+    /**
+     * Visits all slots in the inventory with the given visitor function.
+     *
+     * @param player  player of which inventory to visit
+     * @param visitor visit function
+     * @return if the visitor function returned true on a slot
+     */
+    @Override
+    public boolean visitAll(Player player, InventoryVisitor<Void> visitor) {
+        for (int i = 0, n = getSlotCount(player); i < n; ++i) {
+            ItemStack stackInSlot = getStackInSlot(player, null, i);
+            if (visitor.visit(this, null, i, stackInSlot)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void writeContext(FriendlyByteBuf byteBuf, Void context) {}
+
+    @Override
+    public Void readContext(FriendlyByteBuf byteBuf) {
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/DebugOverlay.java b/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/DebugOverlay.java
new file mode 100644
index 00000000000..c1fc2ccd812
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/DebugOverlay.java
@@ -0,0 +1,159 @@
+package com.gregtechceu.gtceu.api.mui.overlay;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.value.IBoolValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.NamedDrawableRow;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.TreeUtil;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.menu.ContextMenuButton;
+import com.gregtechceu.gtceu.api.mui.widgets.menu.Menu;
+import com.gregtechceu.gtceu.client.mui.screen.CustomModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+
+public class DebugOverlay extends CustomModularScreen {
+
+    private static final IIcon CHECKMARK = GTGuiTextures.CHECK_BOX.asIcon().size(8);
+
+    private final IMuiScreen parent;
+
+    public DebugOverlay(IMuiScreen screen) {
+        super(GTCEu.MOD_ID);
+        this.parent = screen;
+    }
+
+    @Override
+    public @NotNull ModularPanel buildUI(ModularGuiContext context) {
+        return new ModularPanel("debug")
+                .fullScreenInvisible()
+                .child(new ContextMenuButton<>("menu_debug_options")
+                        .horizontalCenter()
+                        .bottom(0)
+                        .height(12)
+                        .width(160)
+                        .background(
+                                new Rectangle()
+                                        .color(Color.withAlpha(
+                                                Color.parseString(ConfigHolder.INSTANCE.dev.mui.outlineColor),
+                                                0.4f))
+                                        .cornerRadius(4))
+                        .disableHoverBackground()
+                        .overlay(IKey.str("Debug Options"))
+                        .openUp()
+                        .menuList(l1 -> l1
+                                .name("menu_list")
+                                .maxSize(100)
+                                .widthRel(1f)
+                                .child(new ButtonWidget<>().name("print_widget_tree_button")
+                                        .height(12)
+                                        .widthRel(1f)
+                                        .invisible()
+                                        .overlay(IKey.str("Print widget trees"))
+                                        .onMousePressed((x, y, b) -> this.logWidgetTrees(b)))
+                                .child(new ButtonWidget<>().name("print_resizer_tree_button")
+                                        .height(12)
+                                        .widthRel(1f)
+                                        .invisible()
+                                        .overlay(IKey.str("Print resizer tree"))
+                                        .onMousePressed((x, y, b) -> {
+                                            TreeUtil.print(parent.getScreen().getResizeNode());
+                                            return true;
+                                        }))
+                                .child(new ContextMenuButton<>("menu_hover_info")
+                                        .height(10)
+                                        .widthRel(1f)
+                                        .overlay(IKey.str("Widget hover info"))
+                                        .openRightUp()
+                                        .menu(new Menu<>()
+                                                .width(100)
+                                                .coverChildrenHeight()
+                                                .padding(2)
+                                                .child(new ListWidget<>()
+                                                        .maxSize(100)
+                                                        .widthRel(1f)
+                                                        .child(toggleOption(0, "Any", "showHovered"))
+                                                        .child(toggleOption(1, "Pos", "showPos"))
+                                                        .child(toggleOption(2, "Size", "showSize"))
+                                                        .child(toggleOption(3, "Widget Theme", "showWidgetTheme"))
+                                                        .child(toggleOption(4, "Extra info", "showExtra"))
+                                                        .child(toggleOption(5, "Outline", "showOutline")))))
+                                .child(new ContextMenuButton<>("menu_parent_hover_info")
+                                        .name("menu_button_parent_hover_info")
+                                        .height(10)
+                                        .widthRel(1f)
+                                        .overlay(IKey.str("Parent widget hover info"))
+                                        .openRightUp()
+                                        .menu(new Menu<>()
+                                                .width(100)
+                                                .coverChildrenHeight()
+                                                .padding(2)
+                                                .child(new ListWidget<>()
+                                                        .maxSize(100)
+                                                        .widthRel(1f)
+                                                        .child(toggleOption(10, "Any", "showParent"))
+                                                        .child(toggleOption(11, "Pos", "showParentPos"))
+                                                        .child(toggleOption(12, "Size", "showParentSize"))
+                                                        .child(toggleOption(13, "Widget Theme",
+                                                                "showParentWidgetTheme"))
+                                                        .child(toggleOption(14, "Outline", "showParentOutline")))))));
+    }
+
+    public static IWidget toggleOption(int i, String name, String field) {
+        ConfigHolder.DeveloperConfigs.MuiConfigs c = ConfigHolder.INSTANCE.dev.mui;
+        Field f;
+        try {
+            f = c.getClass().getField(field);
+        } catch (NoSuchFieldException e) {
+            throw new RuntimeException(e);
+        }
+
+        IBoolValue<?> val = new BoolValue.Dynamic(() -> {
+            try {
+                return (boolean) f.get(c);
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }, v -> {
+            try {
+                f.set(c, v);
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        return new ToggleButton()
+                .name("hover_info_toggle" + i)
+                .invisible()
+                .widthRel(1f)
+                .height(12)
+                .value(val)
+                .overlay(true, new NamedDrawableRow()
+                        .name(IKey.str(name))
+                        .drawable(CHECKMARK))
+                .overlay(false, new NamedDrawableRow()
+                        .name(IKey.str(name)));
+    }
+
+    private boolean logWidgetTrees(int b) {
+        for (ModularPanel panel : parent.getScreen().getPanelManager().getOpenPanels()) {
+            WidgetTree.print(panel);
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/OverlayScreenWrapper.java b/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/OverlayScreenWrapper.java
new file mode 100644
index 00000000000..153f4912332
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/OverlayScreenWrapper.java
@@ -0,0 +1,32 @@
+package com.gregtechceu.gtceu.api.mui.overlay;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+import net.minecraft.client.gui.screens.Screen;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Wraps the current gui screen and uses it for overlays.
+ */
+@ApiStatus.Experimental
+public class OverlayScreenWrapper implements IMuiScreen {
+
+    @Getter
+    private final Screen wrappedScreen;
+    @Getter
+    private final ModularScreen screen;
+
+    public OverlayScreenWrapper(Screen wrappedScreen, ModularScreen screen) {
+        this.wrappedScreen = wrappedScreen;
+        this.screen = screen;
+    }
+
+    @Override
+    public void updateGuiArea(Rectangle area) {
+        // overlay should not modify screen
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/OverlayStack.java b/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/OverlayStack.java
new file mode 100644
index 00000000000..1a8fe2c3325
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/overlay/OverlayStack.java
@@ -0,0 +1,140 @@
+package com.gregtechceu.gtceu.api.mui.overlay;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.OpenScreenEvent;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraftforge.common.MinecraftForge;
+
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+@ApiStatus.Internal
+public class OverlayStack {
+
+    private static final List<ModularScreen> overlay = new ArrayList<>();
+
+    public static void foreach(Consumer<ModularScreen> function, boolean topToBottom) {
+        if (topToBottom) {
+            for (int i = overlay.size() - 1; i >= 0; i--) {
+                function.accept(overlay.get(i));
+            }
+        } else {
+            for (ModularScreen screen : overlay) {
+                function.accept(screen);
+            }
+        }
+    }
+
+    public static boolean interact(Predicate<ModularScreen> function, boolean topToBottom) {
+        if (topToBottom) {
+            for (int i = overlay.size() - 1; i >= 0; i--) {
+                // overlay.get(i).getContext().updateEventState();
+                if (function.test(overlay.get(i))) {
+                    return true;
+                }
+            }
+        } else {
+            for (ModularScreen screen : overlay) {
+                // screen.getContext().updateEventState();
+                if (function.test(screen)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static void draw(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
+        ModularScreen hovered = null;
+        ModularScreen fallback = null;
+        for (ModularScreen screen : overlay) {
+            screen.getContext().setGraphics(graphics);
+            screen.getContext().updateState(mouseX, mouseY, partialTicks);
+            RenderSystem.enableBlend();
+            RenderSystem.setShaderColor(1f, 1f, 1f, 1f);
+            screen.render(graphics, mouseX, mouseY, partialTicks);
+            RenderSystem.setShaderColor(1f, 1f, 1f, 1f);
+            screen.drawForeground(graphics, partialTicks);
+            if (screen.getContext().isHovered()) hovered = screen;
+            fallback = screen;
+        }
+        ClientScreenHandler.drawDebugScreen(graphics, hovered, fallback);
+        RenderSystem.enableDepthTest();
+        Lighting.setupFor3DItems();
+    }
+
+    public static void open(ModularScreen screen) {
+        int i = overlay.indexOf(screen);
+        if (i >= 0 && i < overlay.size() - 1) {
+            overlay.remove(i);
+        }
+        overlay.add(screen);
+        screen.onOpen();
+    }
+
+    public static void close(ModularScreen screen) {
+        if (overlay.remove(screen)) {
+            // TODO: Maybe not always dispose similar to normal screens
+            screen.getPanelManager().closeAll();
+            screen.getPanelManager().dispose();
+        }
+    }
+
+    static void closeAll() {
+        for (int i = overlay.size() - 1; i >= 0; i--) {
+            ModularScreen screen = overlay.remove(i);
+            screen.getPanelManager().closeAll();
+            screen.getPanelManager().dispose();
+        }
+    }
+
+    public static void onTick() {
+        foreach(ModularScreen::onUpdate, true);
+    }
+
+    @Nullable
+    public static IWidget getHoveredElement() {
+        for (int i = overlay.size() - 1; i >= 0; i--) {
+            ModularScreen screen = overlay.get(i);
+            IWidget hovered = screen.getContext().getTopHovered();
+            if (hovered == null) continue;
+            return hovered;
+        }
+        return null;
+    }
+
+    public static boolean isHoveringOverlay() {
+        return getHoveredElement() != null;
+    }
+
+    public static void onOpenScreen(Screen newScreen) {
+        closeAll();
+        if (newScreen != null) {
+
+            OpenScreenEvent event = new OpenScreenEvent(newScreen);
+            MinecraftForge.EVENT_BUS.post(event);
+            for (ModularScreen overlay : event.getOverlays()) {
+                overlay.constructOverlay(newScreen);
+                open(overlay);
+            }
+            if (ConfigHolder.INSTANCE.dev.debugUI && newScreen instanceof IMuiScreen muiScreen) {
+                ModularScreen overlay = new DebugOverlay(muiScreen);
+                overlay.constructOverlay(newScreen);
+                open(overlay);
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/schema/ArraySchema.java b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/ArraySchema.java
new file mode 100644
index 00000000000..786fc5af0c0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/ArraySchema.java
@@ -0,0 +1,250 @@
+package com.gregtechceu.gtceu.api.mui.schema;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.utils.BlockPosUtil;
+import com.gregtechceu.gtceu.utils.fakelevel.SchemaLevel;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.BlockPos.MutableBlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec3;
+
+import com.google.common.collect.AbstractIterator;
+import it.unimi.dsi.fastutil.chars.Char2ObjectMap;
+import it.unimi.dsi.fastutil.chars.Char2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.chars.CharArraySet;
+import it.unimi.dsi.fastutil.chars.CharSet;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.commons.lang3.tuple.MutablePair;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+
+import java.util.*;
+import java.util.function.BiPredicate;
+
+public class ArraySchema implements ISchema {
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static ArraySchema of(Entity entity, int radius) {
+        return of(entity.level(), BlockPos.containing(entity.position()), radius);
+    }
+
+    public static ArraySchema of(Level level, BlockPos center, int radius) {
+        int d = 2 * radius + 1;
+        BlockState[][][] blocks = new BlockState[d][d][d];
+
+        BlockPos corner = center.offset(-radius, -radius, -radius);
+        MutableBlockPos pos = corner.mutable();
+        for (int x = 0; x < d; x++) {
+            for (int y = 0; y < d; y++) {
+                for (int z = 0; z < d; z++) {
+                    pos.setWithOffset(corner, x, y, z);
+                    blocks[x][y][z] = level.getBlockState(pos);
+                }
+            }
+        }
+        return new ArraySchema(blocks);
+    }
+
+    public static ArraySchema of(Level level, Vec3 center, Vec3 p1, Vec3 p2) {
+        int x0 = (int) Math.min(p1.x, p2.x) - 1;
+        int y0 = (int) Math.min(p1.y, p2.y) - 1;
+        int z0 = (int) Math.min(p1.z, p2.z) - 1;
+
+        int x1 = (int) Math.max(p1.x, p2.x);
+        int y1 = (int) Math.max(p1.y, p2.y);
+        int z1 = (int) Math.max(p1.z, p2.z);
+
+        BlockState[][][] blocks = new BlockState[x1 - x0][y1 - y0][z1 - z0];
+        for (BlockPos pos : BlockPos.betweenClosed(x0, y0, z0, x1, y1, z1)) {
+            blocks[pos.getX() - x0][pos.getY() - y0][pos.getZ() - z0] = level.getBlockState(pos);
+        }
+        return new ArraySchema(blocks);
+    }
+
+    @Getter
+    private final Level level;
+    private final BlockState[][][] blocks;
+    @Getter
+    @Setter
+    private BiPredicate<BlockPos, BlockState> renderFilter = (pos, block) -> true;
+    private final Vector3f center;
+
+    public ArraySchema(BlockState[][][] blocks) {
+        this.blocks = blocks;
+        this.level = new SchemaLevel();
+        MutableBlockPos current = new MutableBlockPos();
+        MutableBlockPos max = BlockPosUtil.MIN.mutable();
+        for (int x = 0; x < blocks.length; x++) {
+            for (int y = 0; y < blocks[x].length; y++) {
+                for (int z = 0; z < blocks[x][y].length; z++) {
+                    BlockState block = blocks[x][y][z];
+                    if (block == null || block.isAir()) continue;
+                    current.set(x, y, z);
+                    BlockPosUtil.setMax(max, current);
+                    level.setBlockAndUpdate(current, block);
+                }
+            }
+        }
+        this.center = BlockPosUtil.getCenterF(BlockPos.ZERO, max.move(1, 1, 1));
+    }
+
+    @Override
+    public Vector3fc getFocus() {
+        return center;
+    }
+
+    @Override
+    public BlockPos getOrigin() {
+        return BlockPos.ZERO;
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Map.Entry<BlockPos, BlockState>> iterator() {
+        return new AbstractIterator<>() {
+
+            private final MutableBlockPos pos = new MutableBlockPos();
+            private final MutablePair<BlockPos, BlockState> pair = new MutablePair<>(pos, null);
+            private int x = 0, y = 0, z = -1;
+
+            @Override
+            protected Map.Entry<BlockPos, BlockState> computeNext() {
+                BlockState state;
+                while (true) {
+                    if (++z >= blocks[x][y].length) {
+                        z = 0;
+                        if (++y >= blocks[x].length) {
+                            y = 0;
+                            if (++x >= blocks.length) {
+                                return endOfData();
+                            }
+                        }
+                    }
+                    pos.set(x, y, z);
+                    state = blocks[x][y][z];
+                    if (state != null && renderFilter.test(pos, state)) {
+                        pair.setRight(state);
+                        return pair;
+                    }
+                }
+            }
+        };
+    }
+
+    public static class Builder {
+
+        private final List<String[]> tensor = new ArrayList<>();
+        private final Char2ObjectMap<BlockState> blockMap = new Char2ObjectOpenHashMap<>();
+
+        public Builder() {
+            blockMap.put(' ', Blocks.AIR.defaultBlockState());
+            blockMap.put('#', Blocks.AIR.defaultBlockState());
+        }
+
+        public Builder layer(String... layer) {
+            this.tensor.add(layer);
+            return this;
+        }
+
+        public Builder whereAir(char c) {
+            return where(c, Blocks.AIR.defaultBlockState());
+        }
+
+        public Builder where(char c, BlockState state) {
+            this.blockMap.put(c, state);
+            return this;
+        }
+
+        public Builder where(char c, Block block) {
+            return where(c, block.defaultBlockState());
+        }
+
+        public Builder where(char c, String registryName) {
+            return where(c, new ResourceLocation(registryName));
+        }
+
+        public Builder where(char c, ResourceLocation registryName) {
+            return where(c, BuiltInRegistries.BLOCK.getOptional(registryName)
+                    .orElseThrow(() -> new IllegalArgumentException(registryName + " isn't a valid block")));
+        }
+
+        private void validate() {
+            if (this.tensor.isEmpty()) {
+                throw new IllegalArgumentException("no block matrix defined");
+            }
+            List<String> errors = new ArrayList<>();
+            CharSet checkedChars = new CharArraySet();
+            int layerSize = this.tensor.get(0).length;
+            for (int x = 0; x < this.tensor.size(); x++) {
+                String[] xLayer = this.tensor.get(x);
+                if (xLayer.length == 0) {
+                    errors.add(String.format("Layer %s is empty. This is not right", x + 1));
+                } else if (xLayer.length != layerSize) {
+                    errors.add(String.format("Invalid x-layer size. Expected %s, but got %s at layer %s", layerSize,
+                            xLayer.length, x + 1));
+                }
+                int rowSize = xLayer[0].length();
+                for (int y = 0; y < xLayer.length; y++) {
+                    String yRow = xLayer[y];
+                    if (yRow.isEmpty()) {
+                        errors.add(String.format("Row %s in layer %s is empty. This is not right", y + 1, x + 1));
+                    } else if (yRow.length() != rowSize) {
+                        errors.add(String.format("Invalid x-layer size. Expected %s, but got %s at row %s in layer %s",
+                                layerSize, xLayer.length, y + 1, x + 1));
+                    }
+                    for (int z = 0; z < yRow.length(); z++) {
+                        char zChar = yRow.charAt(z);
+                        if (!checkedChars.contains(zChar)) {
+                            if (!this.blockMap.containsKey(zChar)) {
+                                errors.add(String.format(
+                                        "Found char '%s' at char %s in row %s in layer %s, but character was not found in map!",
+                                        zChar, z + 1, y + 1, x + 1));
+                            }
+                            checkedChars.add(zChar);
+                        }
+                    }
+                }
+            }
+            if (!errors.isEmpty()) {
+                GTCEu.LOGGER.error("Error validating ArrayScheme BlockArray:");
+                for (String e : errors) {
+                    GTCEu.LOGGER.error("  - {}", e);
+                }
+                throw new IllegalArgumentException("The ArraySchema builder was misconfigured. See message above.");
+            }
+        }
+
+        public ArraySchema build() {
+            validate();
+            BlockState[][][] blocks = new BlockState[this.tensor
+                    .size()][this.tensor.get(0).length][this.tensor.get(0)[0]
+                            .length()];
+            for (int x = 0; x < this.tensor.size(); x++) {
+                String[] xLayer = this.tensor.get(x);
+                for (int y = 0; y < xLayer.length; y++) {
+                    String yRow = xLayer[y];
+                    for (int z = 0; z < yRow.length(); z++) {
+                        char zChar = yRow.charAt(z);
+                        BlockState state = this.blockMap.get(zChar);
+                        // null -> any allowed -> don't need to check
+                        if (state == null || state.isAir()) continue;
+                        blocks[x][y][z] = state;
+                    }
+                }
+            }
+            return new ArraySchema(blocks);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/schema/BoxSchema.java b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/BoxSchema.java
new file mode 100644
index 00000000000..280f0f9c558
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/BoxSchema.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.api.mui.schema;
+
+import com.gregtechceu.gtceu.utils.BlockPosUtil;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+
+import lombok.Getter;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+
+import java.util.function.BiPredicate;
+
+public class BoxSchema extends PosListSchema {
+
+    public static BoxSchema of(Level level, BlockPos center, int r) {
+        return new BoxSchema(level, center.offset(-r, -r, -r), center.offset(r, r, r), (pos, state) -> true);
+    }
+
+    public static BoxSchema of(Level level, BlockPos center, int r, BiPredicate<BlockPos, BlockState> renderFilter) {
+        return new BoxSchema(level, center.offset(-r, -r, -r), center.offset(r, r, r), renderFilter);
+    }
+
+    @Getter
+    private final Level level;
+    @Getter
+    private final BlockPos min, max;
+    private final Vector3f center;
+
+    public BoxSchema(Level level, BlockPos min, BlockPos max, BiPredicate<BlockPos, BlockState> renderFilter) {
+        super(level, BlockPosUtil.getAllInside(min, max, false), renderFilter);
+        this.level = level;
+        this.min = BlockPosUtil.getMin(min, max);
+        this.max = BlockPosUtil.getMax(min, max);
+        this.center = BlockPosUtil.getCenterF(min, max);
+    }
+
+    @Override
+    public Vector3fc getFocus() {
+        return center;
+    }
+
+    @Override
+    public BlockPos getOrigin() {
+        return min;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/schema/ISchema.java b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/ISchema.java
new file mode 100644
index 00000000000..c13520eb4ac
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/ISchema.java
@@ -0,0 +1,32 @@
+package com.gregtechceu.gtceu.api.mui.schema;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+
+import org.jetbrains.annotations.NotNull;
+import org.joml.Vector3fc;
+
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+
+public interface ISchema extends Iterable<Map.Entry<BlockPos, BlockState>> {
+
+    Level getLevel();
+
+    Vector3fc getFocus();
+
+    BlockPos getOrigin();
+
+    void setRenderFilter(@NotNull BiPredicate<BlockPos, BlockState> renderFilter);
+
+    @NotNull
+    BiPredicate<BlockPos, BlockState> getRenderFilter();
+
+    default void forEach(@NotNull BiConsumer<BlockPos, BlockState> action) {
+        for (var entry : this) {
+            action.accept(entry.getKey(), entry.getValue());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/schema/PosListSchema.java b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/PosListSchema.java
new file mode 100644
index 00000000000..5aa98041f40
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/schema/PosListSchema.java
@@ -0,0 +1,63 @@
+package com.gregtechceu.gtceu.api.mui.schema;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.commons.lang3.tuple.MutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.function.BiPredicate;
+
+public abstract class PosListSchema implements ISchema {
+
+    @Getter
+    private final Level level;
+    private final Iterable<? extends BlockPos> posList;
+    @Getter
+    @Setter
+    private BiPredicate<BlockPos, BlockState> renderFilter = (pos, state) -> true;
+
+    public PosListSchema(Level level, Iterable<? extends BlockPos> posList,
+                         BiPredicate<BlockPos, BlockState> renderFilter) {
+        this.level = level;
+        this.posList = posList;
+        if (renderFilter != null) {
+            this.renderFilter = renderFilter;
+        }
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Map.Entry<BlockPos, BlockState>> iterator() {
+        return new Iterator<>() {
+
+            private final Iterator<? extends BlockPos> posIt = PosListSchema.this.posList.iterator();
+            private final MutablePair<BlockPos, BlockState> pair = new MutablePair<>();
+
+            @Override
+            public boolean hasNext() {
+                return posIt.hasNext();
+            }
+
+            @Override
+            public Pair<BlockPos, BlockState> next() {
+                BlockPos pos = posIt.next();
+                pair.setLeft(pos);
+                BlockState state = PosListSchema.this.level.getBlockState(pos);
+                if (renderFilter == null || renderFilter.test(pos, state)) {
+                    pair.setRight(state);
+                } else {
+                    pair.setRight(Blocks.AIR.defaultBlockState());
+                }
+                return pair;
+            }
+        };
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/test/TestItem.java b/src/main/java/com/gregtechceu/gtceu/api/mui/test/TestItem.java
new file mode 100644
index 00000000000..42fc15c7dca
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/test/TestItem.java
@@ -0,0 +1,209 @@
+package com.gregtechceu.gtceu.api.mui.test;
+
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.factory.inventory.InventoryTypes;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.ColorShade;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ColorPickerDialog;
+import com.gregtechceu.gtceu.api.mui.widgets.CycleButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.core.Direction;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.ICapabilityProvider;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.IItemHandlerModifiable;
+import net.minecraftforge.items.ItemStackHandler;
+
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import top.theillusivec4.curios.api.CuriosApi;
+import top.theillusivec4.curios.api.SlotContext;
+import top.theillusivec4.curios.api.type.capability.ICurioItem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static net.minecraftforge.common.capabilities.ForgeCapabilities.ITEM_HANDLER;
+
+public class TestItem extends Item implements ICurioItem, IUIHolder<PlayerInventoryGuiData<?>> {
+
+    public TestItem(Properties properties) {
+        super(properties);
+        CuriosApi.registerCurio(this, this);
+    }
+
+    @Override
+    public ModularPanel buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        var cap = data.getUsedItemStack().getCapability(ITEM_HANDLER);
+        if (!cap.isPresent() || cap.resolve().isEmpty()) return null;
+        IItemHandler itemHandler = cap.resolve().get();
+        syncManager.registerSlotGroup("mixer_items", 2);
+        if (!(itemHandler instanceof IItemHandlerModifiable ihm)) return null;
+
+        // if the player slot is the slot with this item, then disallow any interaction
+        // if the item is not in the player inventory (bauble for example), then this items slot is not on the screen,
+        // and we don't need to limit accessibility
+        if (data.getInventoryType() == InventoryTypes.PLAYER) {
+            syncManager.bindPlayerInventory(data.getPlayer(), (inv, index) -> index == data.getSlotIndex() ?
+                    new ModularSlot(inv, index).accessibility(false, false) :
+                    new ModularSlot(inv, index));
+        }
+        ModularPanel panel = ModularPanel.defaultPanel("knapping_gui").resizeableOnDrag(true);
+        panel.child(new Column().margin(7)
+                .child(new ParentWidget<>().widthRel(1f).expanded()
+                        .child(SlotGroupWidget.builder()
+                                .row("I I")
+                                .row("  I")
+                                .row("   ")
+                                .row(" I ")
+                                .key('I', index -> new ItemSlot().slot(SyncHandlers.itemSlot(ihm, index)
+                                        .ignoreMaxStackSize(true)
+                                        .slotGroup("mixer_items")
+                                        // do not allow putting items which can hold other items into the item
+                                        // some mods don't do this on their backpacks, so it won't catch those cases
+                                        .filter(stack -> !stack.getCapability(ITEM_HANDLER).isPresent())))
+                                .build()
+                                .align(Alignment.TopLeft)))
+                .child(SlotGroupWidget.playerInventory(false)));
+
+        return panel;
+    }
+
+    public @NotNull ModularPanel buildColorUI(ModularGuiContext context) {
+        List<Pair<Integer, Float>> colors = new ArrayList<>();
+        for (ColorShade shade : ColorShade.getAll()) {
+            for (int c : shade) {
+                colors.add(Pair.of(c, Color.getLuminance(c)));
+            }
+        }
+        colors.sort((a, b) -> Float.compare(a.getRight(), b.getRight()));
+
+        IDrawable luminanceSortedColors = (context1, x, y, width, height, widgetTheme) -> {
+            float w = (float) width / colors.size();
+            float x0 = x;
+            for (Pair<Integer, Float> c : colors) {
+                GuiDraw.drawRect(context.getGraphics(), x0, y, w, height, c.getLeft());
+                x0 += w;
+            }
+        };
+
+        Rectangle color1 = new Rectangle().color(Color.BLACK.main);
+        Rectangle color2 = new Rectangle().color(Color.WHITE.main);
+
+        IDrawable gradient = (context1, x, y, width, height, widgetTheme) -> GuiDraw.drawHorizontalGradientRect(
+                context1.getGraphics(), x, y, width, height, color1.getColor(), color2.getColor());
+        IDrawable correctedGradient = (context1, x, y, width, height, widgetTheme) -> {
+            int points = 500;
+            Tesselator tesselator = Tesselator.getInstance();
+            BufferBuilder buffer = tesselator.getBuilder();
+
+            buffer.begin(VertexFormat.Mode.TRIANGLE_STRIP, DefaultVertexFormat.POSITION_COLOR);
+            float x0 = x;
+            float w = (float) width / points;
+            for (int i = 0; i < points; i++) {
+                int color = Color.lerp(color1.getColor(), color2.getColor(), (float) i / points);
+                int r = Color.getRed(color), g = Color.getGreen(color), b = Color.getBlue(color), a = 0xFF;
+                buffer.vertex(x0, y, 0).color(r, g, b, a).endVertex();
+                buffer.vertex(x0, y + height, 0).color(r, g, b, a).endVertex();
+                x0 += w;
+            }
+            tesselator.end();
+        };
+
+        ModularPanel panel = new ModularPanel("colors").width(300).coverChildrenHeight().padding(7);
+
+        IPanelHandler colorPicker1 = IPanelHandler.simple(panel,
+                (mainPanel, player) -> new ColorPickerDialog("color_picker1", color1::color, color1.getColor(), true)
+                        .setDraggable(true)
+                        .relative(panel)
+                        .top(0)
+                        .rightRel(1f),
+                true);
+        IPanelHandler colorPicker2 = IPanelHandler.simple(panel,
+                (mainPanel, player) -> new ColorPickerDialog("color_picker2", color2::color, color2.getColor(), true)
+                        .setDraggable(true)
+                        .relative(panel)
+                        .top(0)
+                        .leftRel(1f),
+                true);
+
+        return panel
+                .child(Flow.column()
+                        .coverChildrenHeight()
+                        .child(IKey.str("Colors sorted by luminance").asWidget().margin(1))
+                        .child(luminanceSortedColors.asWidget().widthRel(1f).height(10))
+                        .child(IKey.str("Blending color").asWidget().margin(1).marginTop(2))
+                        .child(Flow.row()
+                                .coverChildrenHeight()
+                                .mainAxisAlignment(Alignment.MainAxis.SPACE_BETWEEN)
+                                .child(new ButtonWidget<>()
+                                        .name("color picker button 1")
+                                        .background(color1)
+                                        .disableHoverBackground()
+                                        .onMousePressed((mouseX, mouseY, mouseButton) -> {
+                                            colorPicker1.openPanel();
+                                            return true;
+                                        }))
+                                .child(new CycleButtonWidget())
+                                .child(new ButtonWidget<>()
+                                        .name("color picker button 2")
+                                        .background(color2)
+                                        .disableHoverBackground()
+                                        .onMousePressed((mouseX, mouseY, mouseButton) -> {
+                                            colorPicker2.openPanel();
+                                            return true;
+                                        })))
+                        .child(IKey.str("OpenGL color gradient").asWidget().margin(1))
+                        .child(gradient.asWidget().widthRel(1f).height(10))
+                        .child(IKey.str("Gamma corrected gradient").asWidget().margin(1))
+                        .child(correctedGradient.asWidget().widthRel(1f).height(10)));
+    }
+
+    @Override
+    public @Nullable ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundTag nbt) {
+        return new ICapabilityProvider() {
+
+            @Override
+            public @NotNull <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
+                if (cap == ITEM_HANDLER) {
+                    var handler = new ItemStackHandler(4);
+                    return LazyOptional.of(() -> handler).cast();
+                }
+                return LazyOptional.empty();
+            }
+        };
+    }
+
+    @Override
+    public boolean canEquip(SlotContext slotContext, ItemStack stack) {
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/AbstractTheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/AbstractTheme.java
new file mode 100644
index 00000000000..fe1624a2909
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/AbstractTheme.java
@@ -0,0 +1,92 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+
+import lombok.Getter;
+
+public abstract class AbstractTheme implements ITheme {
+
+    @Getter
+    private final String id;
+    @Getter
+    private final ITheme parentTheme;
+
+    private WidgetThemeEntry<WidgetTheme> fallback;
+    private WidgetThemeEntry<WidgetTheme> panel;
+    private WidgetThemeEntry<WidgetTheme> button;
+    private WidgetThemeEntry<WidgetTheme> scrollbar;
+    private WidgetThemeEntry<SlotTheme> itemSlot;
+    private WidgetThemeEntry<SlotTheme> fluidSlot;
+    private WidgetThemeEntry<TextFieldTheme> textField;
+    private WidgetThemeEntry<SelectableTheme> toggleButtonTheme;
+
+    protected AbstractTheme(String id, ITheme parentTheme) {
+        this.id = id;
+        this.parentTheme = parentTheme;
+    }
+
+    @Override
+    public WidgetThemeEntry<WidgetTheme> getFallback() {
+        if (fallback == null) {
+            fallback = getWidgetTheme(IThemeApi.FALLBACK);
+        }
+        return fallback;
+    }
+
+    @Override
+    public WidgetThemeEntry<WidgetTheme> getPanelTheme() {
+        if (panel == null) {
+            panel = getWidgetTheme(IThemeApi.PANEL);
+        }
+        return panel;
+    }
+
+    @Override
+    public WidgetThemeEntry<WidgetTheme> getButtonTheme() {
+        if (button == null) {
+            button = getWidgetTheme(IThemeApi.BUTTON);
+        }
+        return button;
+    }
+
+    @Override
+    public WidgetThemeEntry<WidgetTheme> getScrollbarTheme() {
+        if (scrollbar == null) {
+            scrollbar = getWidgetTheme(IThemeApi.SCROLLBAR);
+        }
+        return scrollbar;
+    }
+
+    @Override
+    public WidgetThemeEntry<SlotTheme> getItemSlotTheme() {
+        if (itemSlot == null) {
+            itemSlot = getWidgetTheme(IThemeApi.ITEM_SLOT);
+        }
+        return itemSlot;
+    }
+
+    @Override
+    public WidgetThemeEntry<SlotTheme> getFluidSlotTheme() {
+        if (fluidSlot == null) {
+            fluidSlot = getWidgetTheme(IThemeApi.FLUID_SLOT);
+        }
+        return fluidSlot;
+    }
+
+    @Override
+    public WidgetThemeEntry<TextFieldTheme> getTextFieldTheme() {
+        if (textField == null) {
+            textField = getWidgetTheme(IThemeApi.TEXT_FIELD);
+        }
+        return textField;
+    }
+
+    @Override
+    public WidgetThemeEntry<SelectableTheme> getToggleButtonTheme() {
+        if (toggleButtonTheme == null) {
+            toggleButtonTheme = getWidgetTheme(IThemeApi.TOGGLE_BUTTON);
+        }
+        return toggleButtonTheme;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/DefaultTheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/DefaultTheme.java
new file mode 100644
index 00000000000..6bf0b9928ea
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/DefaultTheme.java
@@ -0,0 +1,47 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class DefaultTheme extends AbstractTheme {
+
+    public static final DefaultTheme INSTANCE = new DefaultTheme();
+
+    private final WidgetThemeMap widgetThemes = new WidgetThemeMap();
+    private boolean initialized = false;
+
+    private DefaultTheme() {
+        super(ThemeAPI.DEFAULT_ID, null);
+    }
+
+    private void initialize() {
+        if (!initialized) {
+            initialized = true;
+            for (var key : ThemeAPI.INSTANCE.getWidgetThemeKeys()) {
+                this.widgetThemes.put(key, entryOfKey(key));
+            }
+        }
+    }
+
+    @Override
+    public @UnmodifiableView Collection<WidgetThemeEntry<?>> getWidgetThemes() {
+        initialize();
+        return Collections.unmodifiableCollection(this.widgetThemes.values());
+    }
+
+    @Override
+    public <T extends WidgetTheme> WidgetThemeEntry<T> getWidgetTheme(WidgetThemeKey<T> key) {
+        initialize();
+        WidgetThemeEntry<T> widgetTheme = this.widgetThemes.getTheme(key);
+        while (widgetTheme == null && key.isSubWidgetTheme()) {
+            widgetTheme = this.widgetThemes.getTheme(key.getParent());
+        }
+        return widgetTheme;
+    }
+
+    private static <T extends WidgetTheme> WidgetThemeEntry<T> entryOfKey(WidgetThemeKey<T> key) {
+        return new WidgetThemeEntry<>(key, key.getDefaultValue(), key.getDefaultHoverValue());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ReloadThemeEvent.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ReloadThemeEvent.java
new file mode 100644
index 00000000000..d72980b91d1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ReloadThemeEvent.java
@@ -0,0 +1,10 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import net.minecraftforge.eventbus.api.Event;
+
+public class ReloadThemeEvent extends Event {
+
+    public static class Pre extends ReloadThemeEvent {}
+
+    public static class Post extends ReloadThemeEvent {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/SelectableTheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/SelectableTheme.java
new file mode 100644
index 00000000000..aaeed0127b6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/SelectableTheme.java
@@ -0,0 +1,102 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableSerialization;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.gson.JsonObject;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class SelectableTheme extends WidgetTheme {
+
+    @Getter
+    private final WidgetTheme selected;
+
+    public static SelectableTheme darkTextNoShadow(int defaultWidth, int defaultHeight, @Nullable IDrawable background,
+                                                   @Nullable IDrawable selectedBackground) {
+        return new SelectableTheme(defaultWidth, defaultHeight,
+                background, Color.WHITE.main, Color.TEXT_COLOR_DARK, false, Color.WHITE.main,
+                selectedBackground, Color.WHITE.main, Color.TEXT_COLOR_DARK, false, Color.WHITE.main);
+    }
+
+    public static SelectableTheme whiteTextShadow(int defaultWidth, int defaultHeight, @Nullable IDrawable background,
+                                                  @Nullable IDrawable selectedBackground) {
+        return new SelectableTheme(defaultWidth, defaultHeight,
+                background, Color.WHITE.main, Color.WHITE.main, true, Color.WHITE.main,
+                selectedBackground, Color.WHITE.main, Color.WHITE.main, true, Color.WHITE.main);
+    }
+
+    public SelectableTheme(int defaultWidth, int defaultHeight, @Nullable IDrawable background,
+                           int color, int textColor, boolean textShadow, int iconColor,
+                           @Nullable IDrawable selectedBackground, int selectedColor,
+                           int selectedTextColor, boolean selectedTextShadow, int selectedIconColor) {
+        super(defaultWidth, defaultHeight, background, color, textColor, textShadow, iconColor);
+        this.selected = new WidgetTheme(defaultWidth, defaultHeight, selectedBackground, selectedColor,
+                selectedTextColor, selectedTextShadow, selectedIconColor);
+    }
+
+    public SelectableTheme(SelectableTheme parent, JsonObject json, JsonObject fallback) {
+        super(parent, json, fallback);
+        IDrawable selectedBackground = JsonHelper.deserializeWithFallback(json, fallback, IDrawable.class,
+                parent.getSelected().getBackground(), IThemeApi.SELECTED_BACKGROUND);
+        int selectedColor = JsonHelper.getColorWithFallback(json, fallback,
+                parent.getSelected().getColor(), IThemeApi.SELECTED_COLOR);
+        int selectedTextColor = JsonHelper.getColorWithFallback(json, fallback,
+                parent.getSelected().getTextColor(), IThemeApi.SELECTED_TEXT_COLOR);
+        boolean selectedTextShadow = JsonHelper.getBoolWithFallback(json, fallback,
+                parent.getSelected().isTextShadow(), IThemeApi.SELECTED_TEXT_SHADOW);
+        int selectedIconColor = JsonHelper.getColorWithFallback(json, fallback,
+                parent.getSelected().getIconColor(), IThemeApi.SELECTED_ICON_COLOR);
+        this.selected = new WidgetTheme(getDefaultWidth(), getDefaultHeight(), selectedBackground, selectedColor,
+                selectedTextColor, selectedTextShadow, selectedIconColor);
+    }
+
+    @Override
+    public WidgetTheme withNoHoverBackground() {
+        return new SelectableTheme(getDefaultWidth(), getDefaultHeight(), IDrawable.NONE, getColor(), getTextColor(),
+                isTextShadow(), getIconColor(), IDrawable.NONE, this.selected.getColor(), this.selected.getTextColor(),
+                this.selected.isTextShadow(), this.selected.getIconColor());
+    }
+
+    public static class Builder<T extends SelectableTheme, B extends SelectableTheme.Builder<T, B>>
+                               extends WidgetThemeBuilder<T, B> {
+
+        public B selectedColor(int color) {
+            add(IThemeApi.SELECTED_COLOR, color);
+            return getThis();
+        }
+
+        public B selectedTextColor(int color) {
+            add(IThemeApi.SELECTED_TEXT_COLOR, color);
+            return getThis();
+        }
+
+        public B selectedTextShadow(int shadow) {
+            add(IThemeApi.SELECTED_TEXT_SHADOW, shadow);
+            return getThis();
+        }
+
+        public B selectedIconColor(int color) {
+            add(IThemeApi.SELECTED_ICON_COLOR, color);
+            return getThis();
+        }
+
+        public B selectedBackground(JsonBuilder builder) {
+            add(IThemeApi.SELECTED_BACKGROUND, builder);
+            return getThis();
+        }
+
+        public B selectedBackground(IDrawable drawable) {
+            add(IThemeApi.SELECTED_BACKGROUND, DrawableSerialization.serialize(drawable));
+            return getThis();
+        }
+
+        public B selectedBackground(String textureId) {
+            return background(new JsonBuilder().add("type", "texture").add("id", textureId));
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/SlotTheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/SlotTheme.java
new file mode 100644
index 00000000000..6ad0bc076a5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/SlotTheme.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.gson.JsonObject;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class SlotTheme extends WidgetTheme {
+
+    @Getter
+    private final int slotHoverColor;
+
+    public SlotTheme(IDrawable background) {
+        this(background, Color.withAlpha(Color.WHITE.main, 0x60));
+    }
+
+    public SlotTheme(IDrawable background, int slotHoverColor) {
+        this(18, 18, background, Color.WHITE.main, 0xFF404040, false, Color.WHITE.main, slotHoverColor);
+    }
+
+    public SlotTheme(int defaultWidth, int defaultHeight, @Nullable IDrawable background, int color, int textColor,
+                     boolean textShadow, int iconColor, int slotHoverColor) {
+        super(defaultWidth, defaultHeight, background, color, textColor, textShadow, iconColor);
+        this.slotHoverColor = slotHoverColor;
+    }
+
+    public SlotTheme(SlotTheme parent, JsonObject json, JsonObject fallback) {
+        super(parent, json, fallback);
+        this.slotHoverColor = JsonHelper.getColorWithFallback(json, fallback, parent.getSlotHoverColor(),
+                IThemeApi.SLOT_HOVER_COLOR);
+    }
+
+    @Override
+    public WidgetTheme withNoHoverBackground() {
+        return new SlotTheme(getDefaultWidth(), getDefaultHeight(), IDrawable.NONE, getColor(), getTextColor(),
+                isTextShadow(), getIconColor(), this.slotHoverColor);
+    }
+
+    public static class Builder<T extends SlotTheme, B extends Builder<T, B>> extends WidgetThemeBuilder<T, B> {
+
+        public B hoverColor(int hoverColor) {
+            add(IThemeApi.SLOT_HOVER_COLOR, hoverColor);
+            return getThis();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/TextFieldTheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/TextFieldTheme.java
new file mode 100644
index 00000000000..dae4d288663
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/TextFieldTheme.java
@@ -0,0 +1,58 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.gson.JsonObject;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class TextFieldTheme extends WidgetTheme {
+
+    @Getter
+    private final int markedColor;
+    @Getter
+    private final int hintColor;
+
+    public TextFieldTheme(int markedColor, int hintColor) {
+        this(56, 18, GTGuiTextures.MUI_DISPLAY_SMALL, Color.WHITE.main, Color.WHITE.main,
+                false, Color.WHITE.main, markedColor, hintColor);
+    }
+
+    public TextFieldTheme(int defaultWidth, int defaultHeight, @Nullable IDrawable background,
+                          int color, int textColor, boolean textShadow, int iconColor, int markedColor, int hintColor) {
+        super(defaultWidth, defaultHeight, background, color, textColor, textShadow, iconColor);
+        this.markedColor = markedColor;
+        this.hintColor = hintColor;
+    }
+
+    public TextFieldTheme(TextFieldTheme parent, JsonObject json, JsonObject fallback) {
+        super(parent, json, fallback);
+        this.markedColor = JsonHelper.getColorWithFallback(json, fallback, parent.getMarkedColor(),
+                IThemeApi.MARKED_COLOR);
+        this.hintColor = JsonHelper.getColorWithFallback(json, fallback, parent.getHintColor(), IThemeApi.HINT_COLOR);
+    }
+
+    @Override
+    public WidgetTheme withNoHoverBackground() {
+        return new TextFieldTheme(getDefaultWidth(), getDefaultHeight(), IDrawable.NONE, getColor(), getTextColor(),
+                isTextShadow(), getIconColor(), this.markedColor, this.hintColor);
+    }
+
+    public static class Builder<T extends TextFieldTheme, B extends TextFieldTheme.Builder<T, B>>
+                               extends WidgetThemeBuilder<T, B> {
+
+        public B markedColor(int markedColor) {
+            add(IThemeApi.MARKED_COLOR, markedColor);
+            return getThis();
+        }
+
+        public B hintColor(int hintColor) {
+            add(IThemeApi.HINT_COLOR, hintColor);
+            return getThis();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/Theme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/Theme.java
new file mode 100644
index 00000000000..8444ae608df
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/Theme.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.*;
+
+public class Theme extends AbstractTheme {
+
+    private final WidgetThemeMap widgetThemes = new WidgetThemeMap();
+
+    Theme(String id, ITheme parent, WidgetThemeMap widgetThemes) {
+        super(id, parent);
+        this.widgetThemes.putAll(widgetThemes);
+        if (parent instanceof Theme theme) {
+            for (WidgetThemeEntry<?> entry : theme.widgetThemes.values()) {
+                if (!this.widgetThemes.containsKey(entry.getKey())) {
+                    this.widgetThemes.put(entry.getKey(), entry);
+                }
+            }
+        } else if (parent == DefaultTheme.INSTANCE) {
+            if (!this.widgetThemes.containsKey(IThemeApi.FALLBACK)) {
+                this.widgetThemes.putTheme(IThemeApi.FALLBACK, ThemeManager.defaultFallbackWidgetTheme);
+            }
+            for (WidgetThemeEntry<?> entry : DefaultTheme.INSTANCE.getWidgetThemes()) {
+                if (!this.widgetThemes.containsKey(entry.getKey())) {
+                    this.widgetThemes.put(entry.getKey(), entry);
+                }
+            }
+        }
+    }
+
+    @Override
+    public @UnmodifiableView Collection<WidgetThemeEntry<?>> getWidgetThemes() {
+        return Collections.unmodifiableCollection(this.widgetThemes.values());
+    }
+
+    @Override
+    public <T extends WidgetTheme> WidgetThemeEntry<T> getWidgetTheme(WidgetThemeKey<T> key) {
+        WidgetThemeEntry<T> widgetTheme = this.widgetThemes.getTheme(key);
+        while (widgetTheme == null && key.isSubWidgetTheme()) {
+            widgetTheme = this.widgetThemes.getTheme(key.getParent());
+        }
+        return widgetTheme;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeAPI.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeAPI.java
new file mode 100644
index 00000000000..926bcbc9e7b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeAPI.java
@@ -0,0 +1,142 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+public class ThemeAPI implements IThemeApi {
+
+    public static final ThemeAPI INSTANCE = new ThemeAPI();
+    public static final String DEFAULT_ID = "DEFAULT";
+    public static final ITheme DEFAULT_THEME = DefaultTheme.INSTANCE;
+
+    public static final Pattern widgetThemeNamePattern = Pattern.compile("[a-zA-z0-9$_-]+");
+
+    private final Object2ObjectMap<String, ITheme> themes = new Object2ObjectOpenHashMap<>();
+    protected final Object2ObjectMap<String, List<JsonBuilder>> defaultThemes = new Object2ObjectOpenHashMap<>();
+    private final List<WidgetThemeKey<?>> keys = new ArrayList<>();
+    protected final Object2ObjectOpenHashMap<String, String> jsonScreenThemes = new Object2ObjectOpenHashMap<>();
+    private final Object2ObjectMap<String, String> screenThemes = new Object2ObjectOpenHashMap<>();
+
+    private ThemeAPI() {}
+
+    @Override
+    public ITheme getDefaultTheme() {
+        return DEFAULT_THEME;
+    }
+
+    @Override
+    public @NotNull ITheme getTheme(String id) {
+        return this.themes.getOrDefault(id, getDefaultTheme());
+    }
+
+    @Override
+    public boolean hasTheme(String id) {
+        return this.themes.containsKey(id);
+    }
+
+    @Override
+    public void registerTheme(String id, JsonBuilder json) {
+        List<JsonBuilder> themes = getJavaDefaultThemes(id);
+        if (!themes.contains(json)) {
+            themes.add(json);
+        }
+    }
+
+    @Override
+    public List<JsonBuilder> getJavaDefaultThemes(String id) {
+        return this.defaultThemes.computeIfAbsent(id, key -> new ArrayList<>());
+    }
+
+    @Override
+    public ITheme getThemeForScreen(String owner, String name, @Nullable String panel, @Nullable String defaultTheme,
+                                    @Nullable String fallbackTheme) {
+        String theme = getThemeIdForScreen(owner, name, panel);
+        if (theme != null) return getTheme(theme);
+        if (defaultTheme != null) return getTheme(defaultTheme);
+        if (fallbackTheme != null) return getTheme(fallbackTheme);
+        return getTheme(ConfigHolder.INSTANCE.client.ui.useDarkThemeByDefault ? "vanilla_dark" : "vanilla");
+    }
+
+    private String getThemeIdForScreen(String mod, String name, String panelName) {
+        String fullName = mod + ":" + name;
+        String fullPanelName = null;
+        if (panelName != null) fullPanelName = fullName + ":" + panelName;
+        String theme = null;
+        if (fullPanelName != null) {
+            theme = this.jsonScreenThemes.get(fullPanelName);
+            if (theme != null) return theme;
+        }
+        theme = this.jsonScreenThemes.get(fullName);
+        if (theme != null) return theme;
+        theme = this.jsonScreenThemes.get(mod);
+        if (theme != null) return theme;
+        if (fullPanelName != null) {
+            theme = this.screenThemes.get(fullPanelName);
+            if (theme != null) return theme;
+        }
+        theme = this.screenThemes.get(fullName);
+        return theme != null ? theme : this.screenThemes.get(mod);
+    }
+
+    @Override
+    public void registerThemeForScreen(String screen, String theme) {
+        Objects.requireNonNull(screen);
+        Objects.requireNonNull(theme);
+        this.screenThemes.put(screen, theme);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends WidgetTheme> WidgetThemeKey<T> registerWidgetTheme(String id, T defaultTheme, T defaultHoverTheme,
+                                                                         WidgetThemeParser<T> parser) {
+        Objects.requireNonNull(id, "Id for widget theme must not be null");
+        Objects.requireNonNull(defaultTheme, "Default widget theme must not be null, but is null for id '" + id + "'.");
+        Objects.requireNonNull(parser, "Parser for widget theme must not be null, but is null for id '" + id + "'.");
+        if (WidgetThemeKey.getFromFullName(id) != null) {
+            throw new IllegalStateException("there already is a widget theme for id '" + id + "' registered.");
+        }
+        if (!widgetThemeNamePattern.matcher(id).matches()) {
+            throw new IllegalArgumentException("Widget theme id '" + id +
+                    "' is invalid. Id must only contain letters, numbers, underscores and minus.");
+        }
+        Class<T> type = (Class<T>) defaultTheme.getClass();
+        return new WidgetThemeKey<>(type, id, defaultTheme, defaultHoverTheme, parser);
+    }
+
+    @Override
+    public List<WidgetThemeKey<?>> getWidgetThemeKeys() {
+        return Collections.unmodifiableList(this.keys);
+    }
+
+    // Internals
+
+    void registerTheme(ITheme theme) {
+        if (this.themes.containsKey(theme.getId())) {
+            throw new IllegalArgumentException("Theme with id " + theme.getId() + " already exists!");
+        }
+        this.themes.put(theme.getId(), theme);
+    }
+
+    void registerWidgetThemeKey(WidgetThemeKey<?> key) {
+        this.keys.add(key);
+    }
+
+    void onReload() {
+        this.themes.clear();
+        this.jsonScreenThemes.clear();
+        registerTheme(DEFAULT_THEME);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeBuilder.java
new file mode 100644
index 00000000000..d41f57c6153
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeBuilder.java
@@ -0,0 +1,228 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableSerialization;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+
+import lombok.Getter;
+
+/**
+ * A json builder with helper methods to make building themes in java easier.
+ * This class is meant to be extended for custom helper methods.
+ *
+ * @param <B> type of this builder class
+ */
+public class ThemeBuilder<B extends ThemeBuilder<B>> extends JsonBuilder {
+
+    @Getter
+    private final String id;
+    @Getter
+    private String parent;
+
+    public ThemeBuilder(String id) {
+        this.id = id;
+    }
+
+    protected B getThis() {
+        return (B) this;
+    }
+
+    public B parent(String v) {
+        add(IThemeApi.PARENT, v);
+        this.parent = v;
+        return getThis();
+    }
+
+    public B defaultBackground(IDrawable v) {
+        add(IThemeApi.BACKGROUND, DrawableSerialization.serialize(v));
+        return getThis();
+    }
+
+    public B defaultBackground(String textureId) {
+        add(IThemeApi.BACKGROUND, new JsonBuilder().add("type", "texture").add("id", textureId));
+        return getThis();
+    }
+
+    public B defaultHoverBackground(IDrawable v) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX,
+                new JsonBuilder().add(IThemeApi.BACKGROUND, DrawableSerialization.serialize(v)));
+        return getThis();
+    }
+
+    public B defaultHoverBackground(String textureId) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.BACKGROUND,
+                new JsonBuilder().add("type", "texture").add("id", textureId)));
+        return getThis();
+    }
+
+    public B defaultColor(int v) {
+        add(IThemeApi.COLOR, v);
+        return getThis();
+    }
+
+    public B defaultHoverColor(int v) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.COLOR, v));
+        return getThis();
+    }
+
+    public B defaultTextColor(int v) {
+        add(IThemeApi.TEXT_COLOR, v);
+        return getThis();
+    }
+
+    public B defaultTextHoverColor(int v) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.TEXT_COLOR, v));
+        return getThis();
+    }
+
+    public B defaultTextShadow(boolean v) {
+        add(IThemeApi.TEXT_SHADOW, v);
+        return getThis();
+    }
+
+    public B defaultTextHoverShadow(boolean v) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.TEXT_SHADOW, v));
+        return getThis();
+    }
+
+    public B defaultIconColor(int v) {
+        add(IThemeApi.ICON_COLOR, v);
+        return getThis();
+    }
+
+    public B defaultIconHoverColor(int v) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.ICON_COLOR, v));
+        return getThis();
+    }
+
+    public B defaultWidth(int v) {
+        add(IThemeApi.ICON_COLOR, v);
+        return getThis();
+    }
+
+    public B defaultHeight(int v) {
+        mergeAdd(IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.ICON_COLOR, v));
+        return getThis();
+    }
+
+    public B background(WidgetThemeKey<?> widgetTheme, IDrawable v) {
+        mergeAdd(widgetTheme.getFullName(),
+                new JsonBuilder().add(IThemeApi.BACKGROUND, DrawableSerialization.serialize(v)));
+        return getThis();
+    }
+
+    public B background(WidgetThemeKey<?> widgetTheme, String textureId) {
+        return background(widgetTheme, new JsonBuilder().add("type", "texture").add("id", textureId));
+    }
+
+    public B background(WidgetThemeKey<?> widgetTheme, JsonBuilder builder) {
+        mergeAdd(widgetTheme.getFullName(),
+                new JsonBuilder().add(IThemeApi.BACKGROUND, builder));
+        return getThis();
+    }
+
+    public B hoverBackground(WidgetThemeKey<?> widgetTheme, IDrawable v) {
+        mergeAdd(widgetTheme.getFullName() + IThemeApi.HOVER_SUFFIX,
+                new JsonBuilder().add(IThemeApi.BACKGROUND, DrawableSerialization.serialize(v)));
+        return getThis();
+    }
+
+    public B hoverBackground(WidgetThemeKey<?> widgetTheme, String textureId) {
+        return hoverBackground(widgetTheme, new JsonBuilder().add("type", "texture").add("id", textureId));
+    }
+
+    public B hoverBackground(WidgetThemeKey<?> widgetTheme, JsonBuilder builder) {
+        mergeAdd(widgetTheme.getFullName() + IThemeApi.HOVER_SUFFIX,
+                new JsonBuilder().add(IThemeApi.BACKGROUND, builder));
+        return getThis();
+    }
+
+    public B color(WidgetThemeKey<?> widgetTheme, int v) {
+        mergeAdd(widgetTheme.getFullName(), new JsonBuilder().add(IThemeApi.COLOR, v));
+        return getThis();
+    }
+
+    public B hoverColor(WidgetThemeKey<?> widgetTheme, int v) {
+        mergeAdd(widgetTheme.getFullName() + IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.COLOR, v));
+        return getThis();
+    }
+
+    public B textColor(WidgetThemeKey<?> widgetTheme, int v) {
+        mergeAdd(widgetTheme.getFullName(), new JsonBuilder().add(IThemeApi.TEXT_COLOR, v));
+        return getThis();
+    }
+
+    public B textHoverColor(WidgetThemeKey<?> widgetTheme, int v) {
+        mergeAdd(widgetTheme.getFullName() + IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.TEXT_COLOR, v));
+        return getThis();
+    }
+
+    public B textShadow(WidgetThemeKey<?> widgetTheme, boolean v) {
+        mergeAdd(widgetTheme.getFullName(), new JsonBuilder().add(IThemeApi.TEXT_SHADOW, v));
+        return getThis();
+    }
+
+    public B textHoverShadow(WidgetThemeKey<?> widgetTheme, boolean v) {
+        mergeAdd(widgetTheme.getFullName() + IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.TEXT_SHADOW, v));
+        return getThis();
+    }
+
+    public B iconColor(WidgetThemeKey<?> widgetTheme, int v) {
+        mergeAdd(widgetTheme.getFullName(), new JsonBuilder().add(IThemeApi.ICON_COLOR, v));
+        return getThis();
+    }
+
+    public B iconHoverColor(WidgetThemeKey<?> widgetTheme, int v) {
+        mergeAdd(widgetTheme.getFullName() + IThemeApi.HOVER_SUFFIX, new JsonBuilder().add(IThemeApi.ICON_COLOR, v));
+        return getThis();
+    }
+
+    public B itemSlotHoverColor(int v) {
+        mergeAdd(IThemeApi.ITEM_SLOT.getFullName(), new JsonBuilder().add(IThemeApi.SLOT_HOVER_COLOR, v));
+        return getThis();
+    }
+
+    public B fluidSlotHoverColor(int v) {
+        mergeAdd(IThemeApi.FLUID_SLOT.getName(), new JsonBuilder().add(IThemeApi.SLOT_HOVER_COLOR, v));
+        return getThis();
+    }
+
+    public B textFieldMarkedColor(int v) {
+        mergeAdd(IThemeApi.TEXT_FIELD.getName(), new JsonBuilder().add(IThemeApi.MARKED_COLOR, v));
+        return getThis();
+    }
+
+    public B textFieldHintColor(int v) {
+        mergeAdd(IThemeApi.TEXT_FIELD.getName(), new JsonBuilder().add(IThemeApi.HINT_COLOR, v));
+        return getThis();
+    }
+
+    /**
+     * Customizes widget themes in a more organized way than with the methods above.
+     *
+     * @param widgetThemeKey     key of the widget theme to customize
+     * @param widgetThemeBuilder builder of the widget theme (take a look at its subclasses)
+     * @param <T>                type of the widget theme
+     * @return this
+     */
+    public <T extends WidgetTheme> B widgetTheme(WidgetThemeKey<T> widgetThemeKey,
+                                                 WidgetThemeBuilder<T, ?> widgetThemeBuilder) {
+        add(widgetThemeKey.getFullName(), widgetThemeBuilder);
+        return getThis();
+    }
+
+    /**
+     * Customizes widget themes in a more organized way than with the methods above.
+     *
+     * @param widgetThemeKey     key of the widget theme to customize
+     * @param widgetThemeBuilder builder of the widget theme (take a look at its subclasses)
+     * @param <T>                type of the widget theme
+     * @return this
+     */
+    public <T extends WidgetTheme> B widgetThemeHover(WidgetThemeKey<T> widgetThemeKey,
+                                                      WidgetThemeBuilder<T, ?> widgetThemeBuilder) {
+        add(widgetThemeKey.getFullName() + IThemeApi.HOVER_SUFFIX, widgetThemeBuilder);
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeManager.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeManager.java
new file mode 100644
index 00000000000..7a3e7e26815
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/ThemeManager.java
@@ -0,0 +1,396 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.utils.*;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.Resource;
+import net.minecraft.server.packs.resources.ResourceManager;
+import net.minecraft.server.packs.resources.SimplePreparableReloadListener;
+import net.minecraft.util.profiling.ProfilerFiller;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.common.MinecraftForge;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import it.unimi.dsi.fastutil.objects.*;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@ApiStatus.Internal
+@OnlyIn(Dist.CLIENT)
+public class ThemeManager extends SimplePreparableReloadListener<Map<String, List<ResourceLocation>>> {
+
+    public static final String THEMES_PATH = "themes.json";
+    // public static final FileToIdConverter THEME_LISTER = new FileToIdConverter("gtceu/themes", ".json");
+    protected static final WidgetThemeEntry<WidgetTheme> defaultFallbackWidgetTheme = IThemeApi.get().getDefaultTheme()
+            .getWidgetTheme(IThemeApi.FALLBACK);
+    private static final JsonObject emptyJson = new JsonObject();
+
+    public ThemeManager() {}
+
+    public static void reload() {
+        // hackery to reload themes on this thread
+        // usually resources are loaded off-thread to not block the main thread
+        // but this should be fine since it is currently not expected to take longer than a second
+        ThemeManager tm = new ThemeManager();
+        ResourceManager rm = Minecraft.getInstance().getResourceManager();
+        ProfilerFiller p = Minecraft.getInstance().getProfiler();
+        tm.apply(tm.prepare(rm, p), rm, p);
+    }
+
+    @Override
+    protected @NotNull Map<String, List<ResourceLocation>> prepare(ResourceManager resourceManager,
+                                                                   ProfilerFiller profiler) {
+        GTCEu.LOGGER.info("Reloading Themes...");
+        MinecraftForge.EVENT_BUS.post(new ReloadThemeEvent.Pre());
+        ThemeAPI.INSTANCE.onReload();
+
+        Map<String, List<ResourceLocation>> themes = new Object2ObjectOpenHashMap<>();
+        profiler.startTick();
+        List<String> themeJsonSources = new ArrayList<>();
+        for (String namespace : resourceManager.getNamespaces()) {
+            profiler.push(namespace);
+
+            for (Resource resource : resourceManager.getResourceStack(new ResourceLocation(namespace, THEMES_PATH))) {
+                profiler.push(resource.sourcePackId());
+                themeJsonSources.add(resource.sourcePackId());
+
+                JsonElement element;
+                try (InputStream stream = resource.open()) {
+                    element = JsonHelper.parse(stream);
+                } catch (Exception e) {
+                    GTCEu.LOGGER.catching(e);
+                    continue;
+                }
+                JsonObject definitions;
+                if (!element.isJsonObject()) {
+                    continue;
+                }
+                definitions = element.getAsJsonObject();
+                for (Map.Entry<String, JsonElement> entry : definitions.entrySet()) {
+                    if (entry.getKey().equals("screens")) {
+                        if (!entry.getValue().isJsonObject()) {
+                            GTCEu.LOGGER.error("Theme screen definitions must be an object!");
+                            continue;
+                        }
+                        loadScreenThemes(entry.getValue().getAsJsonObject());
+                        continue;
+                    }
+                    if (entry.getValue().isJsonObject() || entry.getValue().isJsonArray() ||
+                            entry.getValue().isJsonNull()) {
+                        GTCEu.LOGGER.throwing(new JsonParseException("Theme must be a string!"));
+                        continue;
+                    }
+                    themes.computeIfAbsent(entry.getKey(), key -> new ArrayList<>())
+                            .add(new ResourceLocation(entry.getValue().getAsString()));
+                }
+                profiler.pop();
+            }
+
+            profiler.pop();
+
+        }
+        GTCEu.LOGGER.info("Found themes.json's at {}", themeJsonSources);
+        return themes;
+    }
+
+    @Override
+    protected void apply(@NotNull Map<String, List<ResourceLocation>> themes,
+                         @NotNull ResourceManager resourceManager, @NotNull ProfilerFiller profiler) {
+        Map<String, ThemeJson> themeMap = new Object2ObjectOpenHashMap<>();
+        profiler.startTick();
+
+        // load json files from the path and parse their parent
+        for (Map.Entry<String, List<ResourceLocation>> entry : themes.entrySet()) {
+            if (entry.getValue().isEmpty()) continue;
+            profiler.push(entry.getKey());
+            ThemeJson theme = loadThemeJson(entry.getKey(), entry.getValue(), resourceManager, profiler);
+            if (theme != null) {
+                themeMap.put(entry.getKey(), theme);
+            }
+            profiler.pop();
+        }
+        for (Map.Entry<String, List<JsonBuilder>> entry : ThemeAPI.INSTANCE.defaultThemes.entrySet()) {
+            if (!themeMap.containsKey(entry.getKey())) {
+                themeMap.put(entry.getKey(), new ThemeJson(entry.getKey(),
+                        entry.getValue().stream().map(JsonBuilder::getJson).collect(Collectors.toList()), false));
+            }
+        }
+        if (themeMap.isEmpty()) return;
+        // yeet any invalid parent declarations
+        validateAncestorTree(themeMap);
+        if (themeMap.isEmpty()) return;
+        // create a sorted list of themes
+
+        Map<String, ThemeJson> sortedThemes = new Object2ObjectLinkedOpenHashMap<>();
+        Iterator<Map.Entry<String, ThemeJson>> iterator;
+        boolean changed;
+        do {
+            changed = false;
+            iterator = themeMap.entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<String, ThemeJson> entry = iterator.next();
+                if (ThemeAPI.DEFAULT_ID.equals(entry.getValue().parent) ||
+                        sortedThemes.containsKey(entry.getValue().parent)) {
+                    sortedThemes.put(entry.getKey(), entry.getValue());
+                    iterator.remove();
+                    changed = true;
+                    break;
+                }
+            }
+        } while (changed);
+
+        // finally parse and register themes
+        for (ThemeJson themeJson : sortedThemes.values()) {
+            Theme theme = themeJson.deserialize();
+            ThemeAPI.INSTANCE.registerTheme(theme);
+        }
+
+        validateJsonScreenThemes();
+        MinecraftForge.EVENT_BUS.post(new ReloadThemeEvent.Post());
+    }
+
+    private static void validateAncestorTree(Map<String, ThemeJson> themeMap) {
+        Set<ThemeJson> invalidThemes = new ObjectOpenHashSet<>();
+        for (ThemeJson theme : themeMap.values()) {
+            if (invalidThemes.contains(theme)) {
+                continue;
+            }
+            Set<ThemeJson> parents = new ObjectOpenHashSet<>();
+            parents.add(theme);
+            ThemeJson parent = theme;
+            do {
+                if (ThemeAPI.DEFAULT_ID.equals(parent.parent)) {
+                    break;
+                }
+                parent = themeMap.get(parent.parent);
+                if (parent == null) {
+                    GTCEu.LOGGER.error(
+                            "Can't find parent '{}' for theme '{}'! All children for '{}' are therefore invalid!",
+                            theme.parent, theme.id, theme.id);
+                    invalidThemes.addAll(parents);
+                    break;
+                }
+                if (parents.contains(parent)) {
+                    GTCEu.LOGGER.error(
+                            "Ancestor tree for themes can't be circular! All of the following make a circle or are children of the circle: {}",
+                            parents);
+                    invalidThemes.addAll(parents);
+                    break;
+                }
+                if (invalidThemes.contains(parent)) {
+                    GTCEu.LOGGER.error(
+                            "Parent '{}' was found to be invalid before. All following are children of it and are therefore invalid too: {}",
+                            theme.parent, parents);
+                    invalidThemes.addAll(parents);
+                    break;
+                }
+                parents.add(parent);
+            } while (true);
+        }
+        for (ThemeJson theme : invalidThemes) {
+            themeMap.remove(theme.id);
+        }
+    }
+
+    private static ThemeJson loadThemeJson(String id, List<ResourceLocation> paths,
+                                           @NotNull ResourceManager resourceManager, @NotNull ProfilerFiller profiler) {
+        List<JsonObject> jsons = new ArrayList<>();
+        boolean override = false;
+        for (ResourceLocation path : paths) {
+            profiler.push(path.toString());
+            ResourceLocation rl = new ResourceLocation(path.getNamespace(), "themes/" + path.getPath() + ".json");
+            Resource resource = resourceManager.getResource(rl).orElse(null);
+            if (resource == null) {
+                profiler.pop();
+                GTCEu.LOGGER.warn("Theme '{}' was not found at path '{}'", id, rl);
+                continue;
+            }
+            JsonElement element;
+            try (InputStream stream = resource.open()) {
+                element = JsonHelper.parse(stream);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            if (element.isJsonObject()) {
+                if (JsonHelper.getBoolean(element.getAsJsonObject(), false, "override")) {
+                    jsons.clear();
+                    override = true;
+                }
+                jsons.add(element.getAsJsonObject());
+            }
+            profiler.pop();
+        }
+        if (jsons.isEmpty()) {
+            GTCEu.LOGGER.throwing(new JsonParseException("Theme must be a JsonObject!"));
+            return null;
+        }
+        return new ThemeJson(id, jsons, override);
+    }
+
+    private static void loadScreenThemes(JsonObject json) {
+        for (Map.Entry<String, JsonElement> entry : json.entrySet()) {
+            if (entry.getValue().isJsonPrimitive()) {
+                String theme = entry.getValue().getAsString();
+                ThemeAPI.INSTANCE.jsonScreenThemes.put(entry.getKey(), theme);
+            } else {
+                GTCEu.LOGGER.error("Theme screen definitions must be strings!");
+            }
+        }
+    }
+
+    private static void validateJsonScreenThemes() {
+        for (ObjectIterator<Object2ObjectMap.Entry<String, String>> iterator = ThemeAPI.INSTANCE.jsonScreenThemes
+                .object2ObjectEntrySet().fastIterator(); iterator.hasNext();) {
+            Map.Entry<String, String> entry = iterator.next();
+            if (!ThemeAPI.INSTANCE.hasTheme(entry.getValue())) {
+                GTCEu.LOGGER.error("Tried to register theme '{}' for screen '{}', but theme does not exist",
+                        entry.getValue(), entry.getKey());
+                iterator.remove();
+            }
+        }
+    }
+
+    private static class ThemeJson {
+
+        private final String id;
+        private final String parent;
+        private final List<JsonObject> jsons;
+        private final boolean override;
+
+        private ThemeJson(String id, List<JsonObject> jsons, boolean override) {
+            this.id = id;
+            this.override = override;
+            String p = null;
+            for (ListIterator<JsonObject> iterator = jsons.listIterator(jsons.size()); iterator.hasPrevious();) {
+                JsonObject json = iterator.previous();
+                if (json.has(IThemeApi.PARENT)) {
+                    p = json.get(IThemeApi.PARENT).getAsString();
+                    break;
+                }
+            }
+            this.parent = p == null ? "DEFAULT" : p;
+            this.jsons = jsons;
+        }
+
+        private Theme deserialize() {
+            if (!ThemeAPI.INSTANCE.hasTheme(this.parent)) {
+                throw new IllegalStateException(String.format(
+                        "Ancestor tree was validated, but parent '%s' was still null during parsing!", this.parent));
+            }
+            ITheme parent = ThemeAPI.INSTANCE.getTheme(this.parent);
+            // merge themes defined in java and via resource pack of the same id into 1 json
+            JsonBuilder jsonBuilder = new JsonBuilder();
+            if (!this.override) {
+                for (JsonBuilder builder : ThemeAPI.INSTANCE.getJavaDefaultThemes(this.id)) {
+                    jsonBuilder.addAllOf(builder);
+                }
+            }
+            for (JsonObject json : this.jsons) {
+                jsonBuilder.addAllOf(json);
+            }
+
+            // parse fallback theme for widget themes
+            WidgetThemeMap widgetThemes = new WidgetThemeMap();
+            WidgetThemeEntry<?> parentWidgetTheme = parent.getFallback(); // fallback theme of parent
+            // fallback theme of new theme
+            WidgetTheme fallback = new WidgetTheme(parentWidgetTheme.getTheme(), jsonBuilder.getJson(), null);
+            WidgetTheme fallbackHover = fallback;
+
+            JsonObject hoverJson = getJson(jsonBuilder.getJson(), IThemeApi.HOVER_SUFFIX);
+            if (hoverJson == null)
+                hoverJson = getJson(jsonBuilder.getJson(), IThemeApi.FALLBACK.getFullName() + IThemeApi.HOVER_SUFFIX);
+            if (hoverJson != null) {
+                fallbackHover = new WidgetTheme(fallback, hoverJson, null);
+            }
+            widgetThemes.putTheme(IThemeApi.FALLBACK,
+                    new WidgetThemeEntry<>(IThemeApi.FALLBACK, fallback, fallbackHover));
+
+            // parse all main widget themes
+            for (WidgetThemeKey<?> key : ThemeAPI.INSTANCE.getWidgetThemeKeys()) {
+                if (key != IThemeApi.FALLBACK) {
+                    parse(widgetThemes, parent, key, jsonBuilder);
+                }
+            }
+            return new Theme(this.id, parent, widgetThemes);
+        }
+
+        private <T extends WidgetTheme> void parse(WidgetThemeMap map, ITheme parent, WidgetThemeKey<T> key,
+                                                   JsonBuilder json) {
+            WidgetThemeParser<T> parser = key.getParser();
+            JsonObject widgetThemeJson = getJson(json.getJson(), key.getFullName());
+            boolean definedStandard = widgetThemeJson != null;
+
+            JsonObject widgetThemeHoverJson = getJson(json.getJson(), key.getFullName() + IThemeApi.HOVER_SUFFIX);
+            boolean definedHover = widgetThemeHoverJson != null;
+            if (!definedHover) {
+                if (!definedStandard) {
+                    // widget theme undefined -> copy from parent
+                    if (key.isSubWidgetTheme()) {
+                        // if it is a sub widget theme, we use the parent widget theme from this theme
+                        WidgetThemeEntry<T> entry = map.getTheme(key.getParent());
+                        map.putTheme(key, new WidgetThemeEntry<>(key, entry.getTheme(), entry.getHoverTheme()));
+                        return;
+                    }
+                    // we still need to parse non inherited values (fallback)
+                    widgetThemeJson = emptyJson;
+                    widgetThemeHoverJson = emptyJson;
+                }
+            }
+
+            JsonObject fallback = key.isSubWidgetTheme() ? null : json.getJson();
+            T widgetTheme;
+            if (widgetThemeJson != null) {
+                T parentWidgetTheme = key.isSubWidgetTheme() ? map.getTheme(key.getParent()).getTheme() :
+                        parent.getWidgetTheme(key).getTheme();
+                // sub widget themes strictly only inherit from their parent widget theme and not the parent theme
+                widgetTheme = parser.parse(parentWidgetTheme, widgetThemeJson, fallback);
+            } else {
+                widgetTheme = parent.getWidgetTheme(key).getTheme();
+            }
+
+            if (!definedHover && definedStandard) {
+                // marker to use the standard theme background on hover
+                widgetThemeJson.addProperty(IThemeApi.BACKGROUND, "none");
+                widgetThemeHoverJson = widgetThemeJson;
+            }
+
+            // only inherit from the widget theme if it was actually defined, otherwise use parent
+            T parentWidgetHoverTheme = widgetThemeJson != null ? widgetTheme :
+                    parent.getWidgetTheme(key).getHoverTheme();
+            T widgetThemeHover = parser.parse(parentWidgetHoverTheme, widgetThemeHoverJson, fallback);
+
+            map.putTheme(key, new WidgetThemeEntry<>(key, widgetTheme, widgetThemeHover));
+        }
+
+        private JsonObject getJson(JsonObject json, String key) {
+            if (json.has(key)) {
+                // theme has widget theme defined
+                JsonElement element = json.get(key);
+                if (element.isJsonObject()) {
+                    // widget theme is a json object
+                    return element.getAsJsonObject();
+                }
+                // incorrect data format
+                GTCEu.LOGGER.warn(
+                        "WidgetTheme '{}' of theme '{}' with parent '{}' was found to have an incorrect data format.",
+                        key, this.id, this.parent);
+            }
+            // theme doesn't have widget theme defined
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetTheme.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetTheme.java
new file mode 100644
index 00000000000..12022b72e3a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetTheme.java
@@ -0,0 +1,90 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class WidgetTheme {
+
+    public static WidgetThemeEntry<WidgetTheme> getDefault() {
+        return ThemeAPI.DEFAULT_THEME.getFallback();
+    }
+
+    @Getter
+    private final int defaultWidth;
+    @Getter
+    private final int defaultHeight;
+    @Getter
+    @Nullable
+    private final IDrawable background;
+    @Getter
+    private final int color;
+    @Getter
+    private final int textColor;
+    @Getter
+    private final boolean textShadow;
+    @Getter
+    private final int iconColor;
+
+    public static WidgetTheme whiteTextShadow(int defaultWidth, int defaultHeight, @Nullable IDrawable background) {
+        return new WidgetTheme(defaultWidth, defaultHeight, background, Color.WHITE.main,
+                Color.WHITE.main, true, Color.WHITE.main);
+    }
+
+    public static WidgetTheme darkTextNoShadow(int defaultWidth, int defaultHeight, @Nullable IDrawable background) {
+        return new WidgetTheme(defaultWidth, defaultHeight, background, Color.WHITE.main,
+                Color.TEXT_COLOR_DARK, false, Color.WHITE.main);
+    }
+
+    public WidgetTheme(int defaultWidth, int defaultHeight, @Nullable IDrawable background,
+                       int color, int textColor, boolean textShadow, int iconColor) {
+        this.defaultWidth = defaultWidth;
+        this.defaultHeight = defaultHeight;
+        this.background = background;
+        this.color = color;
+        this.textColor = textColor == 0 ? color : textColor;
+        this.textShadow = textShadow;
+        this.iconColor = iconColor == 0 ? color : iconColor;
+    }
+
+    public WidgetTheme(WidgetTheme parent, JsonObject json, JsonObject fallback) {
+        this.defaultWidth = JsonHelper.getInt(json, parent.getDefaultWidth(), "w", "width");
+        this.defaultHeight = JsonHelper.getInt(json, parent.getDefaultHeight(), "h", "height");
+        this.background = JsonHelper.deserialize(json, IDrawable.class, parent.getBackground(),
+                IThemeApi.BACKGROUND, "bg");
+        // color, textColor, textShadow and iconColor inherit from fallback first and then from parent widget theme
+        this.color = JsonHelper.getColorWithFallback(json, inherits(json, IThemeApi.COLOR) ? null : fallback,
+                parent.getColor(), IThemeApi.COLOR);
+        int textColor = JsonHelper.getColorWithFallback(json, inherits(json, IThemeApi.TEXT_COLOR) ? null : fallback,
+                parent.getTextColor(), IThemeApi.TEXT_COLOR);
+        this.textColor = textColor == 0 ? color : textColor;
+        this.textShadow = JsonHelper.getBoolWithFallback(json, inherits(json, IThemeApi.TEXT_SHADOW) ? null : fallback,
+                parent.isTextShadow(), IThemeApi.TEXT_SHADOW);
+        int iconColor = JsonHelper.getColorWithFallback(json, inherits(json, IThemeApi.ICON_COLOR) ? null : fallback,
+                parent.getTextColor(), IThemeApi.TEXT_COLOR);
+        this.iconColor = iconColor == 0 ? color : iconColor;
+    }
+
+    protected static boolean inherits(JsonObject json, String property) {
+        if (!json.has("inherit")) return false;
+        JsonElement element = json.get("inherit");
+        if (element.isJsonPrimitive()) return element.getAsString().equals(property);
+        if (element.isJsonArray()) {
+            for (JsonElement e : element.getAsJsonArray()) {
+                if (e.isJsonPrimitive() && e.getAsString().equals(property)) return true;
+            }
+        }
+        return false;
+    }
+
+    public WidgetTheme withNoHoverBackground() {
+        return new WidgetTheme(this.defaultWidth, this.defaultHeight, IDrawable.NONE, this.color, this.textColor,
+                this.textShadow, this.iconColor);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeBuilder.java
new file mode 100644
index 00000000000..c74a4699bfa
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeBuilder.java
@@ -0,0 +1,53 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableSerialization;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+
+public class WidgetThemeBuilder<T extends WidgetTheme, B extends WidgetThemeBuilder<T, B>> extends JsonBuilder {
+
+    @SuppressWarnings("unchecked")
+    protected B getThis() {
+        return (B) this;
+    }
+
+    public B defaultWidth(int defaultWidth) {
+        add(IThemeApi.DEFAULT_WIDTH, defaultWidth);
+        return getThis();
+    }
+
+    public B defaultHeight(int defaultHeight) {
+        add(IThemeApi.DEFAULT_HEIGHT, defaultHeight);
+        return getThis();
+    }
+
+    public B color(int color) {
+        add(IThemeApi.COLOR, color);
+        return getThis();
+    }
+
+    public B textShadow(int shadow) {
+        add(IThemeApi.TEXT_SHADOW, shadow);
+        return getThis();
+    }
+
+    public B iconColor(int color) {
+        add(IThemeApi.ICON_COLOR, color);
+        return getThis();
+    }
+
+    public B background(JsonBuilder background) {
+        add(IThemeApi.BACKGROUND, background);
+        return getThis();
+    }
+
+    public B background(IDrawable background) {
+        add(IThemeApi.BACKGROUND, DrawableSerialization.serialize(background));
+        return getThis();
+    }
+
+    public B background(String textureId) {
+        return background(new JsonBuilder().add("type", "texture").add("id", textureId));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeEntry.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeEntry.java
new file mode 100644
index 00000000000..5ce1e946512
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeEntry.java
@@ -0,0 +1,37 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import lombok.Getter;
+
+public class WidgetThemeEntry<T extends WidgetTheme> {
+
+    @Getter
+    private final WidgetThemeKey<T> key;
+    @Getter
+    private final T theme;
+    @Getter
+    private final T hoverTheme;
+
+    public WidgetThemeEntry(WidgetThemeKey<T> key, T theme) {
+        this(key, theme, theme);
+    }
+
+    public WidgetThemeEntry(WidgetThemeKey<T> key, T theme, T hoverTheme) {
+        this.key = key;
+        this.theme = theme;
+        this.hoverTheme = hoverTheme;
+    }
+
+    public T getTheme(boolean hover) {
+        return hover ? hoverTheme : theme;
+    }
+
+    @SuppressWarnings("unchecked")
+    public <F extends WidgetTheme> WidgetThemeEntry<F> expectType(Class<F> expectedType) {
+        if (this.key.isOfType(expectedType)) {
+            return (WidgetThemeEntry<F>) this;
+        }
+        throw new IllegalStateException(
+                String.format("Got widget theme with invalid type. Got type '%s', but expected type '%s'",
+                        this.key.getWidgetThemeType().getSimpleName(), expectedType.getSimpleName()));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeKey.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeKey.java
new file mode 100644
index 00000000000..c59040dc4e8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeKey.java
@@ -0,0 +1,144 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Objects;
+
+public class WidgetThemeKey<T extends WidgetTheme> implements Comparable<WidgetThemeKey<?>> {
+
+    private static final Map<String, WidgetThemeKey<?>> KEYS = new Object2ObjectOpenHashMap<>();
+
+    @Nullable
+    public static WidgetThemeKey<?> getFromFullName(String key) {
+        return KEYS.get(key);
+    }
+
+    @Nullable
+    @Getter
+    private final WidgetThemeKey<T> parent;
+    private final Class<T> type;
+    @Getter
+    private final String name;
+    @Nullable
+    @Getter
+    private final String subName;
+    @Getter
+    private final T defaultValue;
+    @Getter
+    private final T defaultHoverValue;
+    @Getter
+    private final WidgetThemeParser<T> parser;
+
+    WidgetThemeKey(Class<T> type, String name, T defaultValue, WidgetThemeParser parser) {
+        this(type, name, defaultValue, defaultValue, parser);
+    }
+
+    WidgetThemeKey(Class<T> type, String name, T defaultValue, T defaultHoverValue, WidgetThemeParser<T> parser) {
+        this(null, type, name, null, defaultValue, defaultHoverValue, parser);
+    }
+
+    WidgetThemeKey(@Nullable WidgetThemeKey<T> parent, Class<T> type, String name, @Nullable String subName,
+                   T defaultValue, T defaultHoverValue, WidgetThemeParser<T> parser) {
+        this.parent = parent;
+        this.type = type;
+        this.name = name;
+        this.subName = subName;
+        this.defaultValue = defaultValue;
+        this.defaultHoverValue = defaultHoverValue;
+        this.parser = parser;
+        KEYS.put(getFullName(), this);
+        ThemeAPI.INSTANCE.registerWidgetThemeKey(this);
+    }
+
+    public WidgetThemeKey<T> createSubKey(String subName) {
+        return createSubKey(subName, null, null);
+    }
+
+    public WidgetThemeKey<T> createSubKey(String subName, @Nullable T defaultValue, @Nullable T defaultHoverValue) {
+        WidgetThemeKey<?> existing = KEYS.get(getName() + ":" + subName);
+        if (existing != null) {
+            if (existing.type == type) {
+                return (WidgetThemeKey<T>) existing;
+            }
+            throw new IllegalStateException("A widget theme key for id " + getName() + ":" + subName +
+                    " already exists, but with different types '" + existing.type.getSimpleName() + "' and '" +
+                    type.getSimpleName() + "'.");
+        }
+        return new WidgetThemeKey<>(this, type, name, subName,
+                defaultValue != null ? defaultValue : getDefaultValue(),
+                defaultHoverValue != null ? defaultHoverValue : getDefaultHoverValue(),
+                this.parser);
+    }
+
+    public Class<T> getWidgetThemeType() {
+        return type;
+    }
+
+    public String getFullName() {
+        if (subName != null) {
+            return name + ":" + subName;
+        }
+        return name;
+    }
+
+    public boolean isSubWidgetTheme() {
+        return parent != null;
+    }
+
+    public boolean isCompatible(WidgetTheme theme) {
+        return type.isInstance(theme);
+    }
+
+    public boolean isExactType(WidgetTheme theme) {
+        return theme != null && type == theme.getClass();
+    }
+
+    public boolean isOfType(Class<? extends WidgetTheme> type) {
+        return type.isAssignableFrom(this.type);
+    }
+
+    public T cast(WidgetTheme theme) {
+        return type.cast(theme);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        WidgetThemeKey<?> that = (WidgetThemeKey<?>) obj;
+        return Objects.equals(name, that.name) && Objects.equals(subName, that.subName);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, subName);
+    }
+
+    @Override
+    public int compareTo(@NotNull WidgetThemeKey<?> o) {
+        if (o == this) return 0;
+        int i = Boolean.compare(isSubWidgetTheme(), o.isSubWidgetTheme());
+        if (i != 0) return i;
+        i = isAncestor(o);
+        if (i != 0) return i;
+        return name.compareTo(o.name);
+    }
+
+    private int isAncestor(WidgetThemeKey<?> other) {
+        WidgetThemeKey<?> parent = getParent();
+        while (parent != null) {
+            if (parent == other) return 1;
+            parent = parent.getParent();
+        }
+        parent = other.getParent();
+        while (parent != null) {
+            if (parent == other) return -1;
+            parent = parent.getParent();
+        }
+        return 0;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeKeyBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeKeyBuilder.java
new file mode 100644
index 00000000000..3cf9e5e8493
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeKeyBuilder.java
@@ -0,0 +1,73 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+
+import com.google.gson.JsonObject;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Objects;
+
+public class WidgetThemeKeyBuilder<T extends WidgetTheme> {
+
+    private final String id;
+    private T defaultTheme;
+    private T defaultHoverTheme;
+    private WidgetThemeParser<T> parser;
+
+    public WidgetThemeKeyBuilder(String id) {
+        this.id = id;
+    }
+
+    public WidgetThemeKeyBuilder<T> defaultTheme(T defaultTheme) {
+        this.defaultTheme = defaultTheme;
+        return this;
+    }
+
+    public WidgetThemeKeyBuilder<T> defaultHoverTheme(T defaultHoverTheme) {
+        this.defaultHoverTheme = defaultHoverTheme;
+        return this;
+    }
+
+    public WidgetThemeKeyBuilder<T> parser(WidgetThemeParser<T> parser) {
+        this.parser = parser;
+        return this;
+    }
+
+    @SuppressWarnings("unchecked")
+    public WidgetThemeKey<T> register() {
+        Objects.requireNonNull(this.id, "Id for widget theme must not be null");
+        Objects.requireNonNull(this.defaultTheme,
+                "Default theme for widget theme must not be null, but is null for id '" + this.id + "'.");
+        if (parser == null) parser = createParserWithReflection();
+        if (defaultHoverTheme == null) {
+            WidgetTheme hover = this.defaultTheme.withNoHoverBackground();
+            if (hover.getClass() != this.defaultTheme.getClass()) {
+                throw new IllegalArgumentException(
+                        "Tried to create a default hover theme, but method withNoHoverBackground()" +
+                                "is not overridden to create its type");
+            }
+            defaultHoverTheme = (T) hover;
+        }
+        return IThemeApi.get().registerWidgetTheme(this.id, this.defaultTheme, this.defaultHoverTheme, this.parser);
+    }
+
+    @SuppressWarnings("unchecked")
+    private WidgetThemeParser<T> createParserWithReflection() {
+        Class<T> type = (Class<T>) this.defaultTheme.getClass();
+        try {
+            Constructor<T> ctor = type.getConstructor(type, JsonObject.class, JsonObject.class);
+            return (parent, json, fallback) -> {
+                try {
+                    return ctor.newInstance(parent, json, fallback);
+                } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+                    throw new RuntimeException("Failed to instantiate widget theme of type " + type.getSimpleName(), e);
+                }
+            };
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException(String.format(
+                    "No constructor with signature '%s(%s parent, JsonObject json, JsonObject fallback)' found",
+                    type.getSimpleName(), type.getSimpleName()));
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeMap.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeMap.java
new file mode 100644
index 00000000000..41d030aaa22
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeMap.java
@@ -0,0 +1,26 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+
+public class WidgetThemeMap extends Object2ObjectOpenHashMap<WidgetThemeKey<?>, WidgetThemeEntry<?>> {
+
+    @Override
+    public WidgetThemeEntry<?> put(WidgetThemeKey<?> widgetThemeKey, WidgetThemeEntry<?> widgetTheme) {
+        if (widgetThemeKey != widgetTheme.getKey()) {
+            throw new IllegalArgumentException(widgetThemeKey.getFullName() + " is not compatible with " +
+                    widgetTheme.getKey().getFullName());
+        }
+        return super.put(widgetThemeKey, widgetTheme);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends WidgetTheme> WidgetThemeEntry<T> putTheme(WidgetThemeKey<T> widgetThemeKey,
+                                                                WidgetThemeEntry<T> widgetTheme) {
+        return (WidgetThemeEntry<T>) super.put(widgetThemeKey, widgetTheme);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends WidgetTheme> WidgetThemeEntry<T> getTheme(WidgetThemeKey<T> widgetThemeKey) {
+        return (WidgetThemeEntry<T>) super.get(widgetThemeKey);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeParser.java b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeParser.java
new file mode 100644
index 00000000000..b26fa0bdbab
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/theme/WidgetThemeParser.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.api.mui.theme;
+
+import com.google.gson.JsonObject;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An interface used to parse json objects to widget themes.
+ */
+@FunctionalInterface
+public interface WidgetThemeParser<T extends WidgetTheme> {
+
+    /**
+     * Parses a json object to a widget theme,
+     *
+     * @param parent   the widget theme from the parent of the currently parsed theme
+     * @param json     the widget theme json data object
+     * @param fallback a fallback widget theme json data object
+     * @return the parsed widget theme
+     */
+    @NotNull
+    T parse(T parent, JsonObject json, JsonObject fallback);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Alignment.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Alignment.java
new file mode 100644
index 00000000000..8efc81e474a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Alignment.java
@@ -0,0 +1,145 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.common.base.CaseFormat;
+import com.google.gson.*;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+
+import java.lang.reflect.Type;
+import java.util.Map;
+
+public class Alignment {
+
+    private static final Map<String, Alignment> ALIGNMENT_MAP = new Object2ObjectOpenHashMap<>();
+
+    public final float x, y;
+
+    public static final Alignment TopLeft = new Alignment(0, 0, "TopLeft");
+    public static final Alignment TopCenter = new Alignment(0.5f, 0, "TopCenter");
+    public static final Alignment TopRight = new Alignment(1, 0, "TopRight");
+    public static final Alignment CenterLeft = new Alignment(0, 0.5f, "CenterLeft");
+    public static final Alignment Center = new Alignment(0.5f, 0.5f, "Center");
+    public static final Alignment CenterRight = new Alignment(1, 0.5f, "CenterRight");
+    public static final Alignment BottomLeft = new Alignment(0, 1, "BottomLeft");
+    public static final Alignment BottomCenter = new Alignment(0.5f, 1, "BottomCenter");
+    public static final Alignment BottomRight = new Alignment(1, 1, "BottomRight");
+
+    public static final Alignment START = TopLeft;
+    public static final Alignment CENTER = Center;
+    public static final Alignment END = BottomRight;
+
+    public static final Alignment[] ALL = {
+            TopLeft, TopCenter, TopRight,
+            CenterLeft, Center, CenterRight,
+            BottomLeft, BottomCenter, BottomRight
+    };
+
+    public static final Alignment[] CORNERS = {
+            TopLeft, TopRight,
+            BottomLeft, BottomRight
+    };
+
+    public Alignment(float x, float y) {
+        this(x, y, null);
+    }
+
+    private Alignment(float x, float y, String name) {
+        this.x = x;
+        this.y = y;
+        if (name != null) {
+            ALIGNMENT_MAP.put(name, this);
+            ALIGNMENT_MAP.put(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, name), this);
+            String abbrev = name.replaceAll("[a-z]", "");
+            ALIGNMENT_MAP.put(abbrev, this);
+            ALIGNMENT_MAP.put(abbrev.toLowerCase(), this);
+        }
+    }
+
+    /**
+     * Defines how elements should be aligned on the main axis.
+     * In a row this would mean the x coordinates.
+     */
+    public enum MainAxis {
+
+        /**
+         * All children will be put at the start of the Flow next to each other.
+         */
+        START,
+        /**
+         * All children will be put in the center of the Flow next to each other.
+         */
+        CENTER,
+        /**
+         * All children will be put at the end of the Flow next to each other (this does not reverse children order).
+         */
+        END,
+        /**
+         * This maximizes the space between children with the given available space of the Flow. The first widget will
+         * be put at the very
+         * start and the last widget will be put at the very end. If the flow has exactly one child, then this behaves
+         * the same as
+         * {@link #CENTER}.
+         */
+        SPACE_BETWEEN,
+        /**
+         * This maximizes the space around the children with the given available space of the Flow. Contrary to
+         * {@link #SPACE_BETWEEN} this
+         * does not put one "space" between every widget, but rather one "space" on both sides of every widget. If the
+         * flow has exactly one
+         * child, then this behaves the same as {@link #CENTER}.
+         */
+        SPACE_AROUND
+    }
+
+    /**
+     * Defines how elements should be aligned on the cross axis.
+     * In a row this would mean the y coordinates.
+     */
+    public enum CrossAxis {
+
+        /**
+         * All children will be put at the start of the Flow next to each other.
+         */
+        START,
+        /**
+         * All children will be put in the center of the Flow next to each other.
+         */
+        CENTER,
+        /**
+         * All children will be put at the end of the Flow next to each other (this does not reverse children order).
+         */
+        END
+    }
+
+    public static class Json implements JsonDeserializer<Alignment>, JsonSerializer<Alignment> {
+
+        @Override
+        public Alignment deserialize(JsonElement json, Type typeOfT,
+                                     JsonDeserializationContext context) throws JsonParseException {
+            if (!json.isJsonObject()) {
+                Alignment alignment = ALIGNMENT_MAP.get(json.getAsString());
+                if (alignment == null) {
+                    throw new JsonParseException("Can't find alignment for " + json.getAsString());
+                }
+                return alignment;
+            }
+            float x = JsonHelper.getFloat(json.getAsJsonObject(), 0f, "x");
+            float y = JsonHelper.getFloat(json.getAsJsonObject(), 0f, "y");
+            return new Alignment(x, y);
+        }
+
+        @Override
+        public JsonElement serialize(Alignment src, Type typeOfSrc, JsonSerializationContext context) {
+            for (Map.Entry<String, Alignment> entry : ALIGNMENT_MAP.entrySet()) {
+                if (entry.getValue() == src) {
+                    return new JsonPrimitive(entry.getKey());
+                }
+            }
+            return JsonHelper.makeJson(json -> {
+                json.addProperty("x", src.x);
+                json.addProperty("y", src.y);
+            });
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Color.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Color.java
new file mode 100644
index 00000000000..e11da3a60de
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Color.java
@@ -0,0 +1,1219 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IInterpolation;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import net.minecraft.util.Mth;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.mojang.blaze3d.systems.RenderSystem;
+
+import java.util.Locale;
+import java.util.function.ToIntFunction;
+
+/**
+ * Utility class for dealing with colors.
+ * <b>All methods assume the color int to be AARRGGBB if not stated otherwise!</b>
+ * Most of the conversion methods are written by me with the help of <a
+ * href=https://www.rapidtables.com/convert/color/>this website</a>.
+ */
+public class Color {
+
+    /**
+     * Creates a color int. All values should be 0 - 255
+     */
+    public static int rgb(int red, int green, int blue) {
+        return argb(red, green, blue, 255);
+    }
+
+    /**
+     * Creates a color int. All values should be 0 - 255
+     */
+    public static int argb(int red, int green, int blue, int alpha) {
+        return ((alpha & 0xFF) << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | ((blue & 0xFF));
+    }
+
+    /**
+     * Creates a color int. All values should be 0 - 1
+     */
+    public static int argb(float red, float green, float blue, float alpha) {
+        return argb((int) (red * 255), (int) (green * 255), (int) (blue * 255), (int) (alpha * 255));
+    }
+
+    /**
+     * Creates a color int. All values should be 0 - 255
+     */
+    public static int rgba(int red, int green, int blue, int alpha) {
+        return ((red & 0xFF) << 24) | ((green & 0xFF) << 16) | ((blue & 0xFF) << 8) | (alpha & 0xFF);
+    }
+
+    /**
+     * Creates a color int. All values should be 0 - 1
+     */
+    public static int rgba(float red, float green, float blue, float alpha) {
+        return rgba((int) (red * 255), (int) (green * 255), (int) (blue * 255), (int) (alpha * 255));
+    }
+
+    /**
+     * Creates a color int. All values should be 0 - 1
+     */
+    public static int rgb(float red, float green, float blue) {
+        return argb(red, green, blue, 1f);
+    }
+
+    /**
+     * Converts the HSV format into ARGB. With H being hue, S being saturation and V being value.
+     *
+     * @param hue        value from 0 to 360 (wraps around)
+     * @param saturation value from 0 to 1
+     * @param value      value from 0 to 1
+     * @return the color with fully opacity
+     */
+    public static int ofHSV(float hue, float saturation, float value) {
+        return ofHSV(hue, saturation, value, 1f);
+    }
+
+    /**
+     * Converts the HSV format into ARGB. With H being hue, S being saturation and V being value.
+     *
+     * @param hue        value from 0 to 360 (wraps around)
+     * @param saturation value from 0 to 1
+     * @param value      value from 0 to 1
+     * @param alpha      value from 0 to 1
+     * @return the color
+     */
+    public static int ofHSV(float hue, float saturation, float value, float alpha) {
+        hue %= 360;
+        if (hue < 0) hue += 360;
+        saturation = Mth.clamp(saturation, 0f, 1f);
+        value = Mth.clamp(value, 0f, 1f);
+        alpha = Mth.clamp(alpha, 0f, 1f);
+        float c = value * saturation;
+        float x = c * (1 - Math.abs(hue / 60f % 2 - 1));
+        float m = value - c;
+        return ofHxcm(hue, c, x, m, alpha);
+    }
+
+    /**
+     * Converts the HSL format into ARGB. With H being hue, S being saturation and L being lightness.
+     *
+     * @param hue        value from 0 to 360 (wraps around)
+     * @param saturation value from 0 to 1
+     * @param lightness  value from 0 to 1
+     * @return the color with fully opacity
+     */
+    public static int ofHSL(float hue, float saturation, float lightness) {
+        return ofHSL(hue, saturation, lightness, 1f);
+    }
+
+    /**
+     * Converts the HSL format into ARGB. With H being hue, S being saturation and L being lightness.
+     *
+     * @param hue        value from 0 to 360 (wraps around)
+     * @param saturation value from 0 to 1
+     * @param lightness  value from 0 to 1
+     * @param alpha      value from 0 to 1
+     * @return the color
+     */
+    public static int ofHSL(float hue, float saturation, float lightness, float alpha) {
+        hue %= 360;
+        if (hue < 0) hue += 360;
+        saturation = Mth.clamp(saturation, 0f, 1f);
+        lightness = Mth.clamp(lightness, 0f, 1f);
+        alpha = Mth.clamp(alpha, 0f, 1f);
+        float c = (1 - Math.abs(2 * lightness - 1)) * saturation;
+        float x = c * (1 - Math.abs(hue / 60f % 2 - 1));
+        float m = lightness - c / 2;
+        return ofHxcm(hue, c, x, m, alpha);
+    }
+
+    /**
+     * Helper method to calculate argb's of hue based formats.
+     */
+    private static int ofHxcm(float hue, float c, float x, float m, float alpha) {
+        if (hue < 60) return argb(c + m, x + m, m, alpha);
+        if (hue < 120) return argb(x + m, c + m, m, alpha);
+        if (hue < 180) return argb(m, c + m, x + m, alpha);
+        if (hue < 240) return argb(m, x + m, c + m, alpha);
+        if (hue < 300) return argb(x + m, m, c + m, alpha);
+        return argb(c + m, m, x + m, alpha);
+    }
+
+    /**
+     * Converts the CMYK format into ARGB. All values are from 0 to 1.
+     *
+     * @param cyan    cyan value
+     * @param magenta magenta value
+     * @param yellow  yellow value
+     * @param black   black value
+     * @return ARGB color with fully opacity
+     */
+    public static int ofCMYK(float cyan, float magenta, float yellow, float black) {
+        return ofCMYK(cyan, magenta, yellow, black, 1f);
+    }
+
+    /**
+     * Converts the CMYK format into ARGB. All values are from 0 to 1.
+     *
+     * @param cyan    cyan value
+     * @param magenta magenta value
+     * @param yellow  yellow value
+     * @param black   black value
+     * @param alpha   alpha value
+     * @return ARGB color
+     */
+    public static int ofCMYK(float cyan, float magenta, float yellow, float black, float alpha) {
+        float oneMinusBlack = 1f - black;
+        return argb((1 - cyan) * oneMinusBlack, (1 - magenta) * oneMinusBlack, (1 - yellow) * oneMinusBlack, alpha);
+    }
+
+    /**
+     * Extracts the red bits from the ARGB color.
+     *
+     * @return the red value (from 0 to 255)
+     */
+    public static int getRed(int argb) {
+        return argb >> 16 & 255;
+    }
+
+    /**
+     * Extracts the green bits from the ARGB color.
+     *
+     * @return the green value (from 0 to 255)
+     */
+    public static int getGreen(int argb) {
+        return argb >> 8 & 255;
+    }
+
+    /**
+     * Extracts the blue bits from the ARGB color.
+     *
+     * @return the blue value (from 0 to 255)
+     */
+    public static int getBlue(int argb) {
+        return argb & 255;
+    }
+
+    /**
+     * Extracts the alpha bits from the ARGB color.
+     *
+     * @return the alpha value (from 0 to 255)
+     */
+    public static int getAlpha(int argb) {
+        return argb >> 24 & 255;
+    }
+
+    /**
+     * Extracts the red bits from the ARGB color.
+     *
+     * @return the red value (from 0 to 1)
+     */
+    public static float getRedF(int argb) {
+        return getRed(argb) / 255f;
+    }
+
+    /**
+     * Extracts the green bits from the ARGB color.
+     *
+     * @return the green value (from 0 to 1)
+     */
+    public static float getGreenF(int argb) {
+        return getGreen(argb) / 255f;
+    }
+
+    /**
+     * Extracts the blue bits from the ARGB color.
+     *
+     * @return the blue value (from 0 to 1)
+     */
+    public static float getBlueF(int argb) {
+        return getBlue(argb) / 255f;
+    }
+
+    /**
+     * Extracts the alpha bits from the ARGB color.
+     *
+     * @return the alpha value (from 0 to 1)
+     */
+    public static float getAlphaF(int argb) {
+        return getAlpha(argb) / 255f;
+    }
+
+    /**
+     * Extracts the red bits from the ARGB color and squares it.
+     *
+     * @return the squared red value
+     */
+    public static int getRedSq(int argb) {
+        int v = getRed(argb);
+        return v * v;
+    }
+
+    /**
+     * Extracts the green bits from the ARGB color and squares it.
+     *
+     * @return the squared green value
+     */
+    public static int getGreenSq(int argb) {
+        int v = getGreen(argb);
+        return v * v;
+    }
+
+    /**
+     * Extracts the blue bits from the ARGB color and squares it.
+     *
+     * @return the squared blue value
+     */
+    public static int getBlueSq(int argb) {
+        int v = getBlue(argb);
+        return v * v;
+    }
+
+    /**
+     * Replaces the red bits in the ARGB color.
+     *
+     * @param argb color in argb format
+     * @param red  red value from 0 to 255
+     * @return new ARGB color
+     */
+    public static int withRed(int argb, int red) {
+        argb &= ~(0xFF << 16);
+        return argb | red << 16;
+    }
+
+    /**
+     * Replaces the green bits in the ARGB color.
+     *
+     * @param argb  color in argb format
+     * @param green green value from 0 to 255
+     * @return new ARGB color
+     */
+    public static int withGreen(int argb, int green) {
+        argb &= ~(0xFF << 8);
+        return argb | green << 8;
+    }
+
+    /**
+     * Replaces the blue bits in the ARGB color.
+     *
+     * @param argb color in argb format
+     * @param blue blue value from 0 to 255
+     * @return new ARGB color
+     */
+    public static int withBlue(int argb, int blue) {
+        argb &= ~0xFF;
+        return argb | blue;
+    }
+
+    /**
+     * Replaces the alpha bits in the ARGB color.
+     *
+     * @param argb  color in argb format
+     * @param alpha alpha value from 0 to 255
+     * @return new ARGB color
+     */
+    public static int withAlpha(int argb, int alpha) {
+        argb &= ~(0xFF << 24);
+        return argb | alpha << 24;
+    }
+
+    /**
+     * Replaces the red bits in the ARGB color.
+     *
+     * @param argb color in argb format
+     * @param red  red value from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withRed(int argb, float red) {
+        return withRed(argb, (int) (red * 255));
+    }
+
+    /**
+     * Replaces the green bits in the ARGB color.
+     *
+     * @param argb  color in argb format
+     * @param green green value from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withGreen(int argb, float green) {
+        return withGreen(argb, (int) (green * 255));
+    }
+
+    /**
+     * Replaces the blue bits in the ARGB color.
+     *
+     * @param argb color in argb format
+     * @param blue blue value from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withBlue(int argb, float blue) {
+        return withBlue(argb, (int) (blue * 255));
+    }
+
+    /**
+     * Replaces the alpha bits in the ARGB color.
+     *
+     * @param argb  color in argb format
+     * @param alpha alpha value from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withAlpha(int argb, float alpha) {
+        return withAlpha(argb, (int) (alpha * 255));
+    }
+
+    public static int ensureAlpha(int argb) {
+        int a = getAlpha(argb);
+        if (a == 0) argb = withAlpha(argb, 0xFF);
+        return argb;
+    }
+
+    /**
+     * Calculates the hue value (HSV or HSL format) from the ARGB color.
+     *
+     * @param argb color
+     * @return hue value from 0 to 360
+     */
+    public static float getHue(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        if (r == g && r == b) return 0;
+        float min = Math.min(r, Math.min(g, b));
+        float hue = 0;
+        if (r >= g && r >= b) {
+            hue = ((g - b) / (r - min)) % 6;
+        } else if (g >= r && g >= b) {
+            hue = ((b - r) / (g - min)) + 2;
+        } else if (b >= r && b >= g) {
+            hue = ((r - g) / (b - min)) + 4;
+        }
+        hue *= 60;
+        if (hue < 0) hue += 360;
+        return hue;
+    }
+
+    /**
+     * Calculates the HSV saturation value from the ARGB color.
+     *
+     * @param argb color
+     * @return HSV saturation value from 0 to 1
+     */
+    public static float getHSVSaturation(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        float min = Math.min(r, Math.min(g, b));
+        float max = Math.max(r, Math.max(g, b));
+        return max == 0 ? 0 : (max - min) / max;
+    }
+
+    /**
+     * Calculates the HSL saturation value from the ARGB color.
+     *
+     * @param argb color
+     * @return HSL saturation value from 0 to 1
+     */
+    public static float getHSLSaturation(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        float min = Math.min(r, Math.min(g, b));
+        float max = Math.max(r, Math.max(g, b));
+        return (max - min) / (1 - Math.abs(max + min - 1));
+    }
+
+    /**
+     * Calculates the HSV value from the ARGB color.
+     *
+     * @param argb color
+     * @return HSV value from 0 to 1
+     */
+    public static float getValue(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        return Math.max(r, Math.max(g, b));
+    }
+
+    /**
+     * Calculates the HSL lightness value from the ARGB color.
+     *
+     * @param argb color
+     * @return HSL lightness value from 0 to 1
+     */
+    public static float getLightness(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        float min = Math.min(r, Math.min(g, b));
+        float max = Math.max(r, Math.max(g, b));
+        return (max + min) / 2;
+    }
+
+    /**
+     * Replaces the hue value in the ARGB color in the HSV format.
+     *
+     * @param argb color
+     * @param hue  new hue from 0 to 360
+     * @return new ARGB color
+     */
+    public static int withHSVHue(int argb, float hue) {
+        return ofHSV(hue, getHSVSaturation(argb), getValue(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the saturation value in the ARGB color in the HSV format.
+     *
+     * @param argb       color
+     * @param saturation new saturation from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withHSVSaturation(int argb, float saturation) {
+        return ofHSV(getHue(argb), saturation, getValue(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the value in the ARGB color in the HSV format.
+     *
+     * @param argb  color
+     * @param value new value from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withValue(int argb, float value) {
+        return ofHSV(getHue(argb), getHSVSaturation(argb), value, getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the hue value in the ARGB color in the HSL format.
+     *
+     * @param argb color
+     * @param hue  new hue from 0 to 360
+     * @return new ARGB color
+     */
+    public static int withHSLHue(int argb, float hue) {
+        return ofHSL(hue, getHSLSaturation(argb), getLightness(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the saturation value in the ARGB color in the HSL format.
+     *
+     * @param argb       color
+     * @param saturation new saturation from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withHSLSaturation(int argb, float saturation) {
+        return ofHSL(getHue(argb), saturation, getLightness(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the lightness value in the ARGB color in the HSL format.
+     *
+     * @param argb      color
+     * @param lightness new lightness from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withLightness(int argb, float lightness) {
+        return ofHSL(getHue(argb), getHSLSaturation(argb), lightness, getAlphaF(argb));
+    }
+
+    /**
+     * Calculates the CMYK cyan value from the ARGB color.
+     *
+     * @param argb color
+     * @return cyan value from 0 to 1
+     */
+    public static float getCyan(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        float oneMinusBlack = Math.max(r, Math.max(g, b));
+        return oneMinusBlack == 0 ? 0 : 1f - r / oneMinusBlack;
+    }
+
+    /**
+     * Calculates the CMYK magenta value from the ARGB color.
+     *
+     * @param argb color
+     * @return magenta value from 0 to 1
+     */
+    public static float getMagenta(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        float oneMinusBlack = Math.max(r, Math.max(g, b));
+        return oneMinusBlack == 0 ? 0 : 1f - g / oneMinusBlack;
+    }
+
+    /**
+     * Calculates the CMYK yellow value from the ARGB color.
+     *
+     * @param argb color
+     * @return yellow value from 0 to 1
+     */
+    public static float getYellow(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        float oneMinusBlack = Math.max(r, Math.max(g, b));
+        return oneMinusBlack == 0 ? 0 : 1f - b / oneMinusBlack;
+    }
+
+    /**
+     * Calculates the CMYK black value from the ARGB color.
+     *
+     * @param argb color
+     * @return black value from 0 to 1
+     */
+    public static float getBlack(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        return 1f - Math.max(r, Math.max(g, b));
+    }
+
+    /**
+     * Replaces the cyan value in the ARGB color in the CMYK format.
+     *
+     * @param argb color
+     * @param cyan new cyan from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withCyan(int argb, float cyan) {
+        return ofCMYK(cyan, getMagenta(argb), getYellow(argb), getBlack(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the magenta value in the ARGB color in the CMYK format.
+     *
+     * @param argb    color
+     * @param magenta new magenta from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withMagenta(int argb, float magenta) {
+        return ofCMYK(getCyan(argb), magenta, getYellow(argb), getBlack(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the yellow value in the ARGB color in the CMYK format.
+     *
+     * @param argb   color
+     * @param yellow new yellow from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withYellow(int argb, float yellow) {
+        return ofCMYK(getCyan(argb), getMagenta(argb), yellow, getBlack(argb), getAlphaF(argb));
+    }
+
+    /**
+     * Replaces the black value in the ARGB color in the CMYK format.
+     *
+     * @param argb  color
+     * @param black new black from 0 to 1
+     * @return new ARGB color
+     */
+    public static int withBlack(int argb, float black) {
+        return ofCMYK(getCyan(argb), getMagenta(argb), getYellow(argb), black, getAlphaF(argb));
+    }
+
+    /**
+     * Extracts the RGB bits into an array.
+     *
+     * @return rgba as an array [red, green, blue]
+     */
+    public static int[] getRGBValues(int argb) {
+        return new int[] { getRed(argb), getGreen(argb), getBlue(argb) };
+    }
+
+    /**
+     * Extracts the ARGB bits into an array.
+     *
+     * @return rgba as an array [red, green, blue, alpha]
+     */
+    public static int[] getARGBValues(int argb) {
+        return new int[] { getRed(argb), getGreen(argb), getBlue(argb), getAlpha(argb) };
+    }
+
+    /**
+     * Calculates the HSV values and puts them into an array.
+     *
+     * @param argb ARGB color
+     * @return HSV values array
+     */
+    public static float[] getHSVValues(int argb) {
+        return new float[] { getHue(argb), getHSVSaturation(argb), getValue(argb) };
+    }
+
+    /**
+     * Calculates the HSL values and puts them into an array.
+     *
+     * @param argb ARGB color
+     * @return HSL values array
+     */
+    public static float[] getHSLValues(int argb) {
+        return new float[] { getHue(argb), getHSLSaturation(argb), getLightness(argb) };
+    }
+
+    /**
+     * Calculates the CMYK values and puts them into an array.
+     *
+     * @param argb ARGB color
+     * @return CMYK values array
+     */
+    public static float[] getCMYKValues(int argb) {
+        return new float[] { getCyan(argb), getMagenta(argb), getYellow(argb), getBlack(argb) };
+    }
+
+    /**
+     * Calculates perceived luminance according to <a href="https://alienryderflex.com/hsp.html">this web page</a>.
+     *
+     * @param argb argb color
+     * @return perceived luminance
+     */
+    public static float getLuminance(int argb) {
+        float r = getRedF(argb), g = getGreenF(argb), b = getBlueF(argb);
+        return Mth.sqrt(0.299f * r * r + 0.587f * g * g + 0.114f * b * b);
+    }
+
+    /**
+     * Converts an RGBA int to an ARGB int.
+     *
+     * @param rgba RGBA color
+     * @return ARGB color
+     */
+    public static int rgbaToArgb(int rgba) {
+        return Color.argb(getAlpha(rgba), getRed(rgba), getGreen(rgba), getBlue(rgba));
+    }
+
+    /**
+     * Converts an ARGB int to an RGBA int.
+     *
+     * @param argb ARGB color
+     * @return RGBA color
+     */
+    public static int argbToRgba(int argb) {
+        return Color.rgba(getRed(argb), getGreen(argb), getBlue(argb), getAlpha(argb));
+    }
+
+    /**
+     * Inverts all color bytes except alpha.
+     *
+     * @param argb ARGB color
+     * @return inverted color
+     */
+    public static int invert(int argb) {
+        return Color.argb(255 - getRed(argb), 255 - getGreen(argb), 255 - getBlue(argb), getAlpha(argb));
+    }
+
+    /**
+     * Multiplies each color byte with a factor to make it darker or brighter.
+     *
+     * @param argb          ARGB color
+     * @param factor        multiplication factor
+     * @param multiplyAlpha if alpha byte should be multiplied too
+     * @return multiplied ARGB color
+     */
+    public static int multiply(int argb, float factor, boolean multiplyAlpha) {
+        return argb(getRedF(argb) * factor, getGreenF(argb) * factor, getBlueF(argb) * factor,
+                multiplyAlpha ? getAlphaF(argb) * factor : getAlphaF(argb));
+    }
+
+    /**
+     * Multiplies each argb component of two colors and returns the result argb.
+     *
+     * @param argb1 color 1
+     * @param argb2 color 2
+     * @return mixed color
+     */
+    public static int mix(int argb1, int argb2) {
+        return argb(getRedF(argb1) * getRedF(argb2), getGreenF(argb1) * getGreenF(argb2),
+                getBlueF(argb1) * getBlueF(argb2), getAlphaF(argb1) * getAlphaF(argb2));
+    }
+
+    /**
+     * Calculates the average of each color byte in the array and puts it into a new ARGB color.
+     *
+     * @param colors ARGB colors
+     * @return average ARGB color
+     */
+    public static int average(int... colors) {
+        float r = 0, g = 0, b = 0;
+        int a = 0;
+        for (int color : colors) {
+            r += getRedSq(color);
+            g += getGreenSq(color);
+            b += getBlueSq(color);
+            a += getAlpha(color);
+        }
+        return argb((int) Math.sqrt(r / colors.length), (int) Math.sqrt(g / colors.length),
+                (int) Math.sqrt(b / colors.length), (int) Math.sqrt(a / colors.length));
+    }
+
+    /**
+     * Calculates the average of each color byte in the array and puts it into a new ARGB color.
+     *
+     * @param colorFunction function to extract a ARGB color from the objects
+     * @param colorHolders  objects that can be converted to ARGB colors
+     * @return average ARGB color
+     */
+    @SafeVarargs
+    public static <T> int average(ToIntFunction<T> colorFunction, T... colorHolders) {
+        float r = 0, g = 0, b = 0, a = 0;
+        for (T colorHolder : colorHolders) {
+            int color = colorFunction.applyAsInt(colorHolder);
+            r += getRedSq(color);
+            g += getGreenSq(color);
+            b += getBlueSq(color);
+            a += getAlpha(color);
+        }
+        return argb((int) Math.sqrt(r / colorHolders.length), (int) Math.sqrt(g / colorHolders.length),
+                (int) Math.sqrt(b / colorHolders.length), a / colorHolders.length);
+    }
+
+    public static int average(int argb1, int argb2) {
+        return lerp(argb1, argb2, 0.5f);
+    }
+
+    /**
+     * Interpolates each color byte between two ARGB colors using linear interpolation and a progress value.
+     *
+     * @param argb1 color 1
+     * @param argb2 color 2
+     * @param value progress value
+     * @return linear interpolated ARGB color
+     */
+    public static int lerp(int argb1, int argb2, float value) {
+        return interpolate(Interpolation.LINEAR, argb1, argb2, value);
+    }
+
+    /**
+     * Interpolates each color byte between two ARGB colors with an interpolation curve and a progress value.
+     *
+     * @param curve  interpolation curve
+     * @param color1 lower color
+     * @param color2 higher color
+     * @param value  progress value
+     * @return interpolated ARGB color
+     */
+    public static int interpolate(IInterpolation curve, int color1, int color2, float value) {
+        value = Mth.clamp(value, 0, 1);
+        int r = (int) lerpComp(curve, Color.getRed(color1), Color.getRed(color2), value);
+        int g = (int) lerpComp(curve, Color.getGreen(color1), Color.getGreen(color2), value);
+        int b = (int) lerpComp(curve, Color.getBlue(color1), Color.getBlue(color2), value);
+        int a = Interpolations.lerp(Color.getAlpha(color1), Color.getAlpha(color2), value);
+        return Color.argb(r, g, b, a);
+    }
+
+    public static float lerpComp(IInterpolation curve, float a, float b, float v) {
+        return Mth.sqrt(curve.interpolate(a * a, b * b, v));
+    }
+
+    /**
+     * A helper method to apply a color to rendering.
+     * If the alpha is 0 and any other value is not null, the alpha will be set to max.
+     *
+     * @param color argb color
+     */
+    @OnlyIn(Dist.CLIENT)
+    public static void setGlColor(int color) {
+        if (color == 0) {
+            RenderSystem.setShaderColor(0, 0, 0, 0);
+            return;
+        }
+        float a = getAlphaF(color);
+        if (a == 0) a = 1f;
+        RenderSystem.setShaderColor(getRedF(color), getGreenF(color), getBlueF(color), a);
+    }
+
+    /**
+     * Applies a ARGB color to OpenGL with a fixed alpha value of 255.
+     *
+     * @param color ARGB color.
+     */
+    @OnlyIn(Dist.CLIENT)
+    public static void setGlColorOpaque(int color) {
+        if (color == 0) {
+            RenderSystem.setShaderColor(0, 0, 0, 0);
+            return;
+        }
+        RenderSystem.setShaderColor(getRedF(color), getGreenF(color), getBlueF(color), 1f);
+    }
+
+    /**
+     * Enables the OpenGL color mask and sets its colors to white.
+     */
+    @OnlyIn(Dist.CLIENT)
+    public static void resetGlColor() {
+        setGlColorOpaque(WHITE.main);
+    }
+
+    /**
+     * Returns a six digit hex string representation of a color component with upper case letters. Alpha is ignored.
+     *
+     * @param rgb rgb color
+     * @return hex string representation
+     */
+    public static String rgbToFullHexString(int rgb) {
+        return toFullHexString(getRed(rgb), getGreen(rgb), getBlue(rgb));
+    }
+
+    /**
+     * Returns an eight digit hex string representation of a color component with upper case letters.
+     *
+     * @param argb argb color
+     * @return hex string representation
+     */
+    public static String argbToFullHexString(int argb) {
+        return toFullHexString(getRed(argb), getGreen(argb), getBlue(argb), getAlpha(argb));
+    }
+
+    /**
+     * Returns a six digit hex string representation of a color component with upper case letters.
+     *
+     * @param r red
+     * @param g green
+     * @param b blue
+     * @return hex string representation
+     */
+    public static String toFullHexString(int r, int g, int b) {
+        return componentToFullHexString(r) + componentToFullHexString(g) + componentToFullHexString(b);
+    }
+
+    /**
+     * Returns an eight digit hex string representation of a color component with upper case letters.
+     *
+     * @param r red
+     * @param g green
+     * @param b blue
+     * @param a alpha
+     * @return hex string representation
+     */
+    public static String toFullHexString(int r, int g, int b, int a) {
+        return componentToFullHexString(a) + toFullHexString(r, g, b);
+    }
+
+    /**
+     * Returns a double-digit hex string representation of a color component with upper case letters.
+     *
+     * @param component red, green, blue or alpha
+     * @return hex string representation
+     */
+    public static String componentToFullHexString(int component) {
+        component &= 0xFF;
+        if (component == 0) return "00";
+        if (component == 255) return "FF";
+        String s = Integer.toHexString(component).toUpperCase(Locale.ENGLISH);
+        if (s.length() == 1) s = "0" + s;
+        return s;
+    }
+
+    public static int parseString(String colorString) {
+        if (colorString.isEmpty()) return WHITE.main;
+        char c = colorString.charAt(0);
+        // a normal int string
+        if (Character.isDigit(c) || c == '-' || c == '#') {
+            int color;
+            try {
+                color = (int) (long) Long.decode(colorString); // bruh
+            } catch (NumberFormatException e) {
+                GTCEu.LOGGER.error("Failed to decode color of string '{}'. Exception: ", colorString);
+                GTCEu.LOGGER.catching(e);
+                return WHITE.main;
+            }
+            if (color != 0 && getAlpha(color) == 0) {
+                return withAlpha(color, 255);
+            }
+            return color;
+        }
+
+        if ("invisible".equals(colorString)) {
+            return withAlpha(WHITE.main, 0);
+        }
+        int i = colorString.indexOf(':');
+        int index = 0;
+        if (i > 0) {
+            try {
+                index = Integer.parseInt(colorString.substring(i + 1));
+            } catch (NumberFormatException e) {
+                GTCEu.LOGGER.error("[THEME] If the color is a word then after the : must come a negative or " +
+                        "positive integer, but got '{}'", colorString.substring(i + 1));
+            }
+            colorString = colorString.substring(0, i);
+        }
+        ColorShade colorShade = ColorShade.getFromName(colorString);
+        if (colorShade != null) {
+            if (index == 0) return colorShade.main;
+            if (index > 0) return colorShade.brighterSafe(index - 1);
+            return colorShade.darkerSafe(-index - 1);
+        }
+        GTCEu.LOGGER.error("[THEME] No color shade for name '{}' was found", colorString);
+        return WHITE.main;
+    }
+
+    /**
+     * Parses a ARGB color of a json element.
+     *
+     * @param jsonElement json element
+     * @return ARGB color
+     * @throws JsonParseException if color could not be parsed
+     */
+    public static int ofJson(JsonElement jsonElement) {
+        if (jsonElement.isJsonPrimitive()) {
+            return parseString(jsonElement.getAsString());
+        }
+        if (jsonElement.isJsonObject()) {
+            JsonObject json = jsonElement.getAsJsonObject();
+            String alphaS = JsonHelper.getString(json, "1f", "a", "alpha");
+            float alphaF;
+            int alpha;
+            if (alphaS.contains(".") || alphaS.endsWith("f") || alphaS.endsWith("F") || alphaS.endsWith("d") ||
+                    alphaS.endsWith("D")) {
+                try {
+                    alphaF = Mth.clamp(Float.parseFloat(alphaS), 0f, 1f);
+                    alpha = (int) (alphaF * 255);
+                } catch (NumberFormatException e) {
+                    throw new JsonParseException("Failed to parse alpha value", e);
+                }
+            } else {
+                try {
+                    alpha = Mth.clamp(Integer.parseInt(alphaS), 0, 255);
+                    alphaF = alpha / 255f;
+                } catch (NumberFormatException e) {
+                    throw new JsonParseException("Failed to parse alpha value", e);
+                }
+            }
+            if (hasRGB(json)) {
+                if (hasHS(json) || hasV(json) || hasL(json))
+                    throw new JsonParseException("Found RGB values, but also HSV or HSL values!");
+                if (hasCMYK(json))
+                    throw new JsonParseException("Found RGB values, but also CMYK values!");
+                int red = JsonHelper.getInt(json, 255, "r", "red");
+                int green = JsonHelper.getInt(json, 255, "g", "green");
+                int blue = JsonHelper.getInt(json, 255, "b", "blue");
+                if ((red | green | blue) != 0 && alpha == 0) {
+                    alpha = 255;
+                }
+                return Color.argb(red, green, blue, alpha);
+            }
+            if (hasHS(json)) {
+                if (hasCMYK(json))
+                    throw new JsonParseException("Found HSV or HSL values, but also CMYK values!");
+                int hue = JsonHelper.getInt(json, 0, "h", "hue");
+                float saturation = JsonHelper.getFloat(json, 0, "s", "saturation");
+                if (hasV(json)) {
+                    if (hasL(json)) throw new JsonParseException("Found HSV values, but also HSL values!");
+                    float value = JsonHelper.getFloat(json, 1f, "v", "value");
+                    return ofHSV(hue, saturation, value, alphaF);
+                }
+                float lightness = JsonHelper.getFloat(json, 0.5f, "l", "lightness");
+                return ofHSL(hue, saturation, lightness, alphaF);
+            }
+            if (hasCMYK(json)) {
+                float c = JsonHelper.getFloat(json, 1f, "c", "cyan");
+                float m = JsonHelper.getFloat(json, 1f, "m", "magenta");
+                float y = JsonHelper.getFloat(json, 1f, "y", "yellow");
+                float k = JsonHelper.getFloat(json, 1f, "k", "black");
+                return ofCMYK(c, m, y, k, alphaF);
+            }
+            throw new JsonParseException("Empty color declaration");
+        }
+        throw new JsonParseException("Color must be a primitive or an object!");
+    }
+
+    private static boolean hasRGB(JsonObject json) {
+        return json.has("r") || json.has("red") ||
+                json.has("g") || json.has("green") ||
+                json.has("b") || json.has("blue");
+    }
+
+    private static boolean hasHS(JsonObject json) {
+        return json.has("h") || json.has("hue") ||
+                json.has("s") || json.has("saturation");
+    }
+
+    private static boolean hasV(JsonObject json) {
+        return json.has("v") || json.has("value");
+    }
+
+    private static boolean hasL(JsonObject json) {
+        return json.has("l") || json.has("lightness");
+    }
+
+    private static boolean hasCMYK(JsonObject json) {
+        return json.has("c") || json.has("cyan") ||
+                json.has("m") || json.has("magenta") ||
+                json.has("y") || json.has("yellow") ||
+                json.has("k") || json.has("black");
+    }
+
+    public static final int TEXT_COLOR_DARK = 0xFF404040;
+
+    public static final ColorShade WHITE = ColorShade.builder("white", 0xFFFFFFFF)
+            .addDarker(0xFFF7F7F7, 0xFFEFEFEF, 0xFFE7E7E7, 0xFFDFDFDF, 0xFFD7D7D7, 0xFFCFCFCF, 0xFFC7C7C7, 0xFFBFBFBF)
+            .build();
+
+    public static final ColorShade BLACK = ColorShade.builder("black", 0xFF000000)
+            .addBrighter(0xFF080808, 0xFF101010, 0xFF181818, 0xFF202020, 0xFF282828, 0xFF303030, 0xFF383838, 0xFF404040)
+            .build();
+
+    public static final ColorShade RED = ColorShade.builder("red", 0xFFF44336)
+            .addBrighter(0xFFEF5350, 0xFFE57373, 0xFFEF9A9A, 0xFFFFCDD2, 0xFFFFEBEE)
+            .addDarker(0xFFE53935, 0xFFD32F2F, 0xFFC62828, 0xFFB71C1C)
+            .build();
+
+    public static final ColorShade RED_ACCENT = ColorShade.builder("red_accent", 0xFFFF5252)
+            .addBrighter(0xFFFF8A80)
+            .addDarker(0xFFFF1744, 0xFFD50000)
+            .build();
+
+    public static final ColorShade PINK = ColorShade.builder("pink", 0xFFE91E63)
+            .addBrighter(0xFFEC407A, 0xFFF06292, 0xFFF48FB1, 0xFFF8BBD0, 0xFFFCE4EC)
+            .addDarker(0xFFD81B60, 0xFFC2185B, 0xFFAD1457, 0xFF880E4F)
+            .build();
+
+    public static final ColorShade PINK_ACCENT = ColorShade.builder("pink_accent", 0xFFFF4081)
+            .addBrighter(0xFFFF80AB)
+            .addDarker(0xFFF50057, 0xFFC51162)
+            .build();
+
+    public static final ColorShade PURPLE = ColorShade.builder("purple", 0xFF9C27B0)
+            .addBrighter(0xFFAB47BC, 0xFFBA68C8, 0xFFCE93D8, 0xFFE1BEE7, 0xFFF3E5F5)
+            .addDarker(0xFF8E24AA, 0xFF7B1FA2, 0xFF6A1B9A, 0xFF4A148C)
+            .build();
+
+    public static final ColorShade PURPLE_ACCENT = ColorShade.builder("purple_accent", 0xFFE040FB)
+            .addBrighter(0xFFEA80FC)
+            .addDarker(0xFFD500F9, 0xFFAA00FF)
+            .build();
+
+    public static final ColorShade DEEP_PURPLE = ColorShade.builder("deep_purple", 0xFF673AB7)
+            .addBrighter(0xFF7E57C2, 0xFF9575CD, 0xFFB39DDB, 0xFFD1C4E9, 0xFFEDE7F6)
+            .addDarker(0xFF5E35B1, 0xFF512DA8, 0xFF4527A0, 0xFF311B92)
+            .build();
+
+    public static final ColorShade DEEP_PURPLE_ACCENT = ColorShade.builder("deep_purple_accent", 0xFF7C4DFF)
+            .addBrighter(0xFFB388FF)
+            .addDarker(0xFF651FFF, 0xFF651FFF)
+            .build();
+
+    public static final ColorShade INDIGO = ColorShade.builder("indigo", 0xFF3F51B5)
+            .addBrighter(0xFF5C6BC0, 0xFF7986CB, 0xFF9FA8DA, 0xFFC5CAE9, 0xFFE8EAF6)
+            .addDarker(0xFF3949AB, 0xFF303F9F, 0xFF283593, 0xFF1A237E)
+            .build();
+
+    public static final ColorShade INDIGO_ACCENT = ColorShade.builder("indigo_accent", 0xFF536DFE)
+            .addBrighter(0xFF8C9EFF)
+            .addDarker(0xFF3D5AFE, 0xFF304FFE)
+            .build();
+
+    public static final ColorShade BLUE = ColorShade.builder("blue", 0xFF2196F3)
+            .addBrighter(0xFF42A5F5, 0xFF64B5F6, 0xFF90CAF9, 0xFFBBDEFB, 0xFFE3F2FD)
+            .addDarker(0xFF1E88E5, 0xFF1976D2, 0xFF1565C0, 0xFF0D47A1)
+            .build();
+
+    public static final ColorShade BLUE_ACCENT = ColorShade.builder("blue_accent", 0xFF448AFF)
+            .addBrighter(0xFF82B1FF)
+            .addDarker(0xFF2979FF, 0xFF2962FF)
+            .build();
+
+    public static final ColorShade LIGHT_BLUE = ColorShade.builder("light_blue", 0xFF03A9F4)
+            .addBrighter(0xFF29B6F6, 0xFF4FC3F7, 0xFF81D4FA, 0xFFB3E5FC, 0xFFE1F5FE)
+            .addDarker(0xFF039BE5, 0xFF0288D1, 0xFF0277BD, 0xFF01579B)
+            .build();
+
+    public static final ColorShade LIGHT_BLUE_ACCENT = ColorShade.builder("light_blue_accent", 0xFF40C4FF)
+            .addBrighter(0xFF80D8FF)
+            .addDarker(0xFF00B0FF, 0xFF0091EA)
+            .build();
+
+    public static final ColorShade CYAN = ColorShade.builder("cyan", 0xFF00BCD4)
+            .addBrighter(0xFF26C6DA, 0xFF4DD0E1, 0xFF80DEEA, 0xFFB2EBF2, 0xFFE0F7FA)
+            .addDarker(0xFF00ACC1, 0xFF0097A7, 0xFF00838F, 0xFF006064)
+            .build();
+
+    public static final ColorShade CYAN_ACCENT = ColorShade.builder("cyan_accent", 0xFF18FFFF)
+            .addBrighter(0xFF84FFFF)
+            .addDarker(0xFF00E5FF, 0xFF00B8D4)
+            .build();
+
+    public static final ColorShade TEAL = ColorShade.builder("teal", 0xFF009688)
+            .addBrighter(0xFF26A69A, 0xFF4DB6AC, 0xFF80CBC4, 0xFFB2DFDB, 0xFFE0F2F1)
+            .addDarker(0xFF00897B, 0xFF00796B, 0xFF00695C, 0xFF004D40)
+            .build();
+
+    public static final ColorShade TEAL_ACCENT = ColorShade.builder("teal_accent", 0xFF64FFDA)
+            .addBrighter(0xFFA7FFEB)
+            .addDarker(0xFF1DE9B6, 0xFF00BFA5)
+            .build();
+
+    public static final ColorShade GREEN = ColorShade.builder("green", 0xFF4CAF50)
+            .addBrighter(0xFF66BB6A, 0xFF81C784, 0xFFA5D6A7, 0xFFC8E6C9, 0xFFE8F5E9)
+            .addDarker(0xFF43A047, 0xFF388E3C, 0xFF2E7D32, 0xFF1B5E20)
+            .build();
+
+    public static final ColorShade GREEN_ACCENT = ColorShade.builder("green_accent", 0xFF69F0AE)
+            .addBrighter(0xFFB9F6CA)
+            .addDarker(0xFF00E676, 0xFF00C853)
+            .build();
+
+    public static final ColorShade LIGHT_GREEN = ColorShade.builder("light_green", 0xFF8BC34A)
+            .addBrighter(0xFF9CCC65, 0xFFAED581, 0xFFC5E1A5, 0xFFDCEDC8, 0xFFF1F8E9)
+            .addDarker(0xFF7CB342, 0xFF689F38, 0xFF558B2F, 0xFF33691E)
+            .build();
+
+    public static final ColorShade LIGHT_GREEN_ACCENT = ColorShade.builder("light_green_accent", 0xFFB2FF59)
+            .addBrighter(0xFFCCFF90)
+            .addDarker(0xFF76FF03, 0xFF64DD17)
+            .build();
+
+    public static final ColorShade LIME = ColorShade.builder("lime", 0xFFCDDC39)
+            .addBrighter(0xFFD4E157, 0xFFDCE775, 0xFFE6EE9C, 0xFFF0F4C3, 0xFFF9FBE7)
+            .addDarker(0xFFC0CA33, 0xFFAFB42B, 0xFF9E9D24, 0xFF827717)
+            .build();
+
+    public static final ColorShade LIME_ACCENT = ColorShade.builder("lime_accent", 0xFFEEFF41)
+            .addBrighter(0xFFF4FF81)
+            .addDarker(0xFFC6FF00, 0xFFAEEA00)
+            .build();
+
+    public static final ColorShade YELLOW = ColorShade.builder("yellow", 0xFFFFEB3B)
+            .addBrighter(0xFFFFEE58, 0xFFFFF176, 0xFFFFF59D, 0xFFFFF9C4, 0xFFFFFDE7)
+            .addDarker(0xFFFDD835, 0xFFFBC02D, 0xFFF9A825, 0xFFF57F17)
+            .build();
+
+    public static final ColorShade YELLOW_ACCENT = ColorShade.builder("yellow_accent", 0xFFFFFF00)
+            .addBrighter(0xFFFFFF8D)
+            .addDarker(0xFFFFEA00, 0xFFFFD600)
+            .build();
+
+    public static final ColorShade AMBER = ColorShade.builder("amber", 0xFFFFC107)
+            .addBrighter(0xFFFFCA28, 0xFFFFD54F, 0xFFFFE082, 0xFFFFECB3, 0xFFFFF8E1)
+            .addDarker(0xFFFFB300, 0xFFFFA000, 0xFFFF8F00, 0xFFFF6F00)
+            .build();
+
+    public static final ColorShade AMBER_ACCENT = ColorShade.builder("amber_accent", 0xFFFFD740)
+            .addBrighter(0xFFFFE57F)
+            .addDarker(0xFFFFC400, 0xFFFFAB00)
+            .build();
+
+    public static final ColorShade ORANGE = ColorShade.builder("orange", 0xFFFF9800)
+            .addBrighter(0xFFFFA726, 0xFFFFB74D, 0xFFFFCC80, 0xFFFFE0B2, 0xFFFFF3E0)
+            .addDarker(0xFFFB8C00, 0xFFF57C00, 0xFFEF6C00, 0xFFE65100)
+            .build();
+
+    public static final ColorShade ORANGE_ACCENT = ColorShade.builder("orange_accent", 0xFFFFAB40)
+            .addBrighter(0xFFFFD180)
+            .addDarker(0xFFFF9100, 0xFFFF6D00)
+            .build();
+
+    public static final ColorShade DEEP_ORANGE = ColorShade.builder("deep_orange", 0xFFFF5722)
+            .addBrighter(0xFFFF7043, 0xFFFF8A65, 0xFFFFAB91, 0xFFFFCCBC, 0xFFFBE9E7)
+            .addDarker(0xFFF4511E, 0xFFE64A19, 0xFFD84315, 0xFFBF360C)
+            .build();
+
+    public static final ColorShade DEEP_ORANGE_ACCENT = ColorShade.builder("deep_orange_accent", 0xFFFF6E40)
+            .addBrighter(0xFFFF9E80)
+            .addDarker(0xFFFF3D00, 0xFFDD2C00)
+            .build();
+
+    public static final ColorShade BROWN = ColorShade.builder("brown", 0xFF795548)
+            .addBrighter(0xFF8D6E63, 0xFFA1887F, 0xFFBCAAA4, 0xFFD7CCC8, 0xFFEFEBE9)
+            .addDarker(0xFF6D4C41, 0xFF5D4037, 0xFF4E342E, 0xFF3E2723)
+            .build();
+
+    public static final ColorShade GREY = ColorShade.builder("grey", 0xFF9E9E9E)
+            .addBrighter(0xFFBDBDBD, 0xFFE0E0E0, 0xFFEEEEEE, 0xFFF5F5F5, 0xFFFAFAFA)
+            .addDarker(0xFF757575, 0xFF616161, 0xFF424242, 0xFF212121)
+            .build();
+
+    public static final ColorShade BLUE_GREY = ColorShade.builder("blue_grey", 0xFF607D8B)
+            .addBrighter(0xFF78909C, 0xFF90A4AE, 0xFFB0BEC5, 0xFFCFD8DC, 0xFFECEFF1)
+            .addDarker(0xFF546E7A, 0xFF455A64, 0xFF37474F, 0xFF263238)
+            .build();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ColorShade.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ColorShade.java
new file mode 100644
index 00000000000..13df39eb786
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ColorShade.java
@@ -0,0 +1,117 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.util.Mth;
+
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.ints.IntIterable;
+import it.unimi.dsi.fastutil.ints.IntIterator;
+import it.unimi.dsi.fastutil.ints.IntIterators;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+public class ColorShade implements IntIterable {
+
+    public static Builder builder(String name, int main) {
+        return new Builder(name, main);
+    }
+
+    private static final Map<String, ColorShade> COLOR_SHADES = new Object2ObjectOpenHashMap<>();
+
+    @Nullable
+    public static ColorShade getFromName(String name) {
+        return COLOR_SHADES.get(name);
+    }
+
+    @UnmodifiableView
+    public static Collection<ColorShade> getAll() {
+        return Collections.unmodifiableCollection(COLOR_SHADES.values());
+    }
+
+    public final String name;
+    public final int main;
+    private final int[] brighter;
+    private final int[] darker;
+    private final int[] all;
+
+    private ColorShade(String name, int main, int[] brighter, int[] darker) {
+        this.name = name;
+        this.main = main;
+        this.brighter = brighter;
+        this.darker = darker;
+        this.all = new int[brighter.length + darker.length + 1];
+        int k = 0;
+        for (int i = brighter.length - 1; i >= 0; i--) {
+            this.all[k++] = brighter[i];
+        }
+        this.all[k++] = this.main;
+        for (int j : darker) {
+            this.all[k++] = j;
+        }
+        COLOR_SHADES.put(name, this);
+    }
+
+    public int darker(int index) {
+        return this.darker[index];
+    }
+
+    public int darkerSafe(int index) {
+        return this.darker[Mth.clamp(index, 0, this.darker.length - 1)];
+    }
+
+    public int darkerShadeCount() {
+        return this.darker.length;
+    }
+
+    public int brighter(int index) {
+        return this.brighter[index];
+    }
+
+    public int brighterSafe(int index) {
+        return this.brighter[Mth.clamp(index, 0, this.brighter.length - 1)];
+    }
+
+    public int brighterShadeCount() {
+        return this.brighter.length;
+    }
+
+    @NotNull
+    @Override
+    public IntIterator iterator() {
+        return IntIterators.wrap(this.all);
+    }
+
+    public static class Builder {
+
+        private final String name;
+        private final int main;
+        private final IntArrayList darker = new IntArrayList();
+        private final IntArrayList brighter = new IntArrayList();
+
+        public Builder(String name, int main) {
+            this.name = name;
+            this.main = main;
+        }
+
+        public Builder addDarker(int... darker) {
+            this.darker.addElements(this.darker.size(), darker, 0, darker.length);
+            return this;
+        }
+
+        public Builder addBrighter(int... brighter) {
+            this.brighter.addElements(this.brighter.size(), brighter, 0, brighter.length);
+            return this;
+        }
+
+        public ColorShade build() {
+            this.darker.trim();
+            this.brighter.trim();
+            return new ColorShade(this.name, this.main, this.brighter.elements(), this.darker.elements());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/DAM.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/DAM.java
new file mode 100644
index 00000000000..33cc7eb7320
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/DAM.java
@@ -0,0 +1,432 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.util.Mth;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+
+/**
+ * A helper class providing math operations on 1D double arrays similar to numpy.
+ * DAM stands for DoubleArrayMath.
+ */
+public class DAM {
+
+    public static final double[] EMPTY = new double[0];
+
+    /**
+     * Creates an array of length n filled with zeros.
+     *
+     * @param n length
+     * @return zero filled array
+     */
+    public static double[] zeros(int n) {
+        return new double[n];
+    }
+
+    /**
+     * Creates an array of length n filled with f.
+     *
+     * @param n length
+     * @param f fill value
+     * @return f filled array
+     */
+    public static double[] full(int n, double f) {
+        double[] arr = new double[n];
+        Arrays.fill(arr, f);
+        return arr;
+    }
+
+    /**
+     * Creates an array of length n filled with ones.
+     *
+     * @param n length
+     * @return one filled array
+     */
+    public static double[] ones(int n) {
+        return full(n, 1);
+    }
+
+    public static double[] copyInto(double[] src, double @Nullable [] res) {
+        if (src == res) return res;
+        if (res == null) res = new double[src.length];
+        int n = Math.min(src.length, res.length);
+        System.arraycopy(src, 0, res, 0, n);
+        return res;
+    }
+
+    public static double[] subArray(double[] src, int start, int length) {
+        double[] res = new double[length];
+        System.arraycopy(src, start, res, 0, length);
+        return res;
+    }
+
+    public static double[] ofFloats(float[] src) {
+        double[] res = new double[src.length];
+        for (int i = 0; i < src.length; i++) res[i] = src[i];
+        return res;
+    }
+
+    public static double[] ofInts(int[] src) {
+        double[] res = new double[src.length];
+        for (int i = 0; i < src.length; i++) res[i] = src[i];
+        return res;
+    }
+
+    public static double[] ofLongs(long[] src) {
+        double[] res = new double[src.length];
+        for (int i = 0; i < src.length; i++) res[i] = src[i];
+        return res;
+    }
+
+    public static double[] linspace(double start, double stop) {
+        return linspace(start, stop, 50, true);
+    }
+
+    public static double[] linspace(double start, double stop, boolean includeEndpoint) {
+        return linspace(start, stop, 50, includeEndpoint);
+    }
+
+    public static double[] linspace(double start, double stop, int n) {
+        return linspace(start, stop, n, true);
+    }
+
+    /**
+     * Creates an evenly spaced array over a specified interval.
+     *
+     * @param start           start of interval
+     * @param stop            stop of interval
+     * @param n               sample size = array length
+     * @param includeEndpoint true if stop should be included at the end of the array
+     * @return evenly spaced array over interval
+     */
+    public static double[] linspace(double start, double stop, int n, boolean includeEndpoint) {
+        double[] arr = new double[n];
+        double step = (stop - start) / (includeEndpoint ? n + 1 : n);
+        int s = n;
+        if (includeEndpoint) {
+            arr[n - 1] = stop;
+            s--;
+        }
+        for (int i = 0; i < s; i++) {
+            arr[i] = start + step * i;
+        }
+        return arr;
+    }
+
+    public static double[] arange(double stop, double step) {
+        return arange(0, stop, step);
+    }
+
+    public static double[] arange(double start, double stop, double step) {
+        double[] arr = new double[(int) Math.ceil((stop - start) / step)];
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = start + step * i;
+        }
+        return arr;
+    }
+
+    /**
+     * Returns the index of the largest value in the array. If array is empty, -1 is returned.
+     *
+     * @param arr array
+     * @return index of largest value
+     */
+    public static int argMax(double[] arr) {
+        if (arr.length == 0) return -1;
+        if (arr.length == 1) return 0;
+        if (arr.length == 2) return arr[0] >= arr[1] ? 0 : 1;
+        int index = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] > arr[index]) index = i;
+        }
+        return index;
+    }
+
+    /**
+     * Returns the index of the smallest value in the array. If array is empty, -1 is returned.
+     *
+     * @param arr array
+     * @return index of smallest value
+     */
+    public static int argMin(double[] arr) {
+        if (arr.length == 0) return -1;
+        if (arr.length == 1) return 0;
+        if (arr.length == 2) return arr[0] <= arr[1] ? 0 : 1;
+        int index = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] < arr[index]) index = i;
+        }
+        return index;
+    }
+
+    /**
+     * Returns the largest value in the array. If array is empty, 0 is returned.
+     *
+     * @param arr array
+     * @return largest value
+     */
+    public static double max(double[] arr) {
+        int i = argMax(arr);
+        return i < 0 ? 0 : arr[i];
+    }
+
+    /**
+     * Returns the smallest value in the array. If array is empty, 0 is returned.
+     *
+     * @param arr array
+     * @return smallest value
+     */
+    public static double min(double[] arr) {
+        int i = argMin(arr);
+        return i < 0 ? 0 : arr[i];
+    }
+
+    /**
+     * Adds an operand to every element of the source array.
+     *
+     * @param src source array
+     * @param op  operand
+     * @param res result array. If this is null a new array is created. This can be the same as src.
+     * @return result array
+     */
+    public static double[] plus(double[] src, double op, double @Nullable [] res) {
+        return applyEach(src, v -> v + op, res);
+    }
+
+    public static double[] plusMut(double[] src, double op) {
+        return plus(src, op, src);
+    }
+
+    /**
+     * Adds each element of the operand to the element at the corresponding index of the source array.
+     *
+     * @param src source array
+     * @param op  operands
+     * @param res result array. If this is null a new array is created. This can be the same as src.
+     * @return result array
+     */
+    public static double[] plus(double[] src, double[] op, double @Nullable [] res) {
+        return applyEach(src, op, Double::sum, res);
+    }
+
+    public static double[] plusMut(double[] src, double[] op) {
+        return plus(src, op, src);
+    }
+
+    /**
+     * Multiplies an operand with every element of the source array.
+     *
+     * @param src source array
+     * @param op  operand
+     * @param res result array. If this is null a new array is created. This can be the same as src.
+     * @return result array
+     */
+    public static double[] mult(double[] src, double op, double @Nullable [] res) {
+        return applyEach(src, v -> v * op, res);
+    }
+
+    public static double[] multMut(double[] src, double op) {
+        return mult(src, op, src);
+    }
+
+    public static double[] mult(double[] src, double[] op, double @Nullable [] res) {
+        return applyEach(src, op, (v, op1) -> v * op1, res);
+    }
+
+    public static double[] multMut(double[] src, double[] op) {
+        return mult(src, op, src);
+    }
+
+    public static double[] div(double[] src, double op, double @Nullable [] res) {
+        return mult(src, 1 / op, res);
+    }
+
+    public static double[] divMut(double[] src, double op) {
+        return div(src, op, src);
+    }
+
+    public static double[] div(double[] src, double[] op, double @Nullable [] res) {
+        return applyEach(src, op, (v, op1) -> v / op1, res);
+    }
+
+    public static double[] divMut(double[] src, double[] op) {
+        return div(src, op, src);
+    }
+
+    public static double[] reciprocal(double a, double[] b, double @Nullable [] res) {
+        return applyEach(b, v -> a / v, res);
+    }
+
+    public static double[] square(double[] src, double @Nullable [] res) {
+        return applyEach(src, v -> v * v, res);
+    }
+
+    public static double[] cube(double[] src, double @Nullable [] res) {
+        return applyEach(src, v -> v * v * v, res);
+    }
+
+    public static double[] pow(double[] src, double op, double @Nullable [] res) {
+        return applyEach(src, v -> (double) Math.pow(v, op), res);
+    }
+
+    public static double[] diff(double[] src) {
+        if (src.length < 2) return EMPTY;
+        if (src.length == 2) return new double[] { src[1] - src[0] };
+        double[] res = new double[src.length - 1];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = src[i + 1] - src[i];
+        }
+        return res;
+    }
+
+    public static double[] applyEach(double[] src, UnaryDoubleOperator op, double @Nullable [] res) {
+        if (res == null) res = new double[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i]);
+        return res;
+    }
+
+    public static double[] applyEach(double[] src, double[] operands, BinaryDoubleOperator op,
+                                     double @Nullable [] res) {
+        if (src.length != operands.length)
+            throw new IllegalArgumentException("Can't apply operator to operands of different size.");
+        if (res == null) res = new double[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i], operands[i]);
+        return res;
+    }
+
+    public static double[] applyEach(double[] src, double[] operands1, double[] operands2, TernaryDoubleOperator op,
+                                     double @Nullable [] res) {
+        if (src.length != operands1.length || src.length != operands2.length) {
+            throw new IllegalArgumentException("Can't apply operator to operands of different size.");
+        }
+        if (res == null) res = new double[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i], operands1[i], operands2[i]);
+        return res;
+    }
+
+    public static double[] applyEach(double[] src, double[][] operands, NDoubleOperator op, double @Nullable [] res) {
+        if (src.length != operands.length) {
+            throw new IllegalArgumentException("Can't apply operator to operands of different size.");
+        }
+        if (res == null) res = new double[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i], operands[i]);
+        return res;
+    }
+
+    public static double[] abs(double[] src, double @Nullable [] res) {
+        return applyEach(src, Math::abs, res);
+    }
+
+    public static double[] sin(double[] src, double @Nullable [] res) {
+        return applyEach(src, Math::sin, res);
+    }
+
+    public static double[] cos(double[] src, double @Nullable [] res) {
+        return applyEach(src, Math::cos, res);
+    }
+
+    public static double[] tan(double[] src, double @Nullable [] res) {
+        return applyEach(src, Math::tan, res);
+    }
+
+    public static double[] clamp(double[] src, double min, double max, double @Nullable [] res) {
+        return applyEach(src, v -> Mth.clamp(v, min, max), res);
+    }
+
+    public static double[] polynomial(double[] src, double[] coeff, double @Nullable [] res) {
+        if (coeff.length == 0) return copyInto(src, res);
+        if (coeff.length == 1) return plus(src, coeff[0], res);
+        return applyEach(src, x -> {
+            double y = 0;
+            y += coeff[0];
+            if (coeff.length == 2) return y + x * coeff[1];
+            for (int i = 1; i < coeff.length; i++) {
+                y += (double) (Math.pow(x, i) * coeff[i]);
+            }
+            return y;
+        }, res);
+    }
+
+    public static double reduce(double[] src, BinaryDoubleOperator op) {
+        if (src.length == 0) return 0;
+        if (src.length == 1) return src[0];
+        double res = op.apply(src[0], src[1]);
+        if (src.length == 2) return res;
+        for (int i = 2; i < src.length; i++) {
+            res = op.apply(res, src[i]);
+        }
+        return res;
+    }
+
+    public static double[] reverse(double[] src, double @Nullable [] res) {
+        if (res == null) res = new double[src.length];
+        for (int i = 0; i < src.length; i++) {
+            res[i] = src[src.length - i - 1];
+        }
+        return res;
+    }
+
+    public static double sum(double[] src) {
+        return reduce(src, Double::sum);
+    }
+
+    public static double product(double[] src) {
+        return reduce(src, (f1, f2) -> f1 * f2);
+    }
+
+    public static double arithmeticMean(double[] src) {
+        return sum(src) / src.length;
+    }
+
+    public static double geometricMean(double[] src) {
+        return (double) Math.pow(product(src), 1f / src.length);
+    }
+
+    public static double[] concat(double[] a, double[] b) {
+        double[] res = new double[a.length + b.length];
+        System.arraycopy(a, 0, res, 0, a.length);
+        System.arraycopy(b, 0, res, a.length, b.length);
+        return res;
+    }
+
+    public static double[] flatten(double[]... src) {
+        if (src.length == 0) return EMPTY;
+        if (src.length == 1) return src[0];
+        if (src.length == 2) return concat(src[0], src[1]);
+        int n = 0;
+        for (double[] doubles : src) n += doubles.length;
+        if (n == 0) return EMPTY;
+        double[] res = new double[n];
+        n = 0;
+        for (double[] doubles : src) {
+            System.arraycopy(doubles, 0, res, n, doubles.length);
+            n += doubles.length;
+        }
+        return res;
+    }
+
+    public interface UnaryDoubleOperator {
+
+        double apply(double v);
+    }
+
+    public interface BinaryDoubleOperator {
+
+        double apply(double v, double op);
+    }
+
+    public interface TernaryDoubleOperator {
+
+        double apply(double v, double op1, double op2);
+    }
+
+    public interface NDoubleOperator {
+
+        double apply(double v, double[] op);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/FAM.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/FAM.java
new file mode 100644
index 00000000000..97ed24e5712
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/FAM.java
@@ -0,0 +1,314 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.util.Mth;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+
+/**
+ * A helper class providing math operations on 1D float arrays similar to numpy.
+ */
+public class FAM {
+
+    public static final float[] EMPTY = new float[0];
+
+    /**
+     * Creates an array of length n filled with zeros.
+     *
+     * @param n length
+     * @return zero filled array
+     */
+    public static float[] zeros(int n) {
+        return new float[n];
+    }
+
+    /**
+     * Creates an array of length n filled with f.
+     *
+     * @param n length
+     * @param f fill value
+     * @return f filled array
+     */
+    public static float[] full(int n, float f) {
+        float[] arr = new float[n];
+        Arrays.fill(arr, f);
+        return arr;
+    }
+
+    /**
+     * Creates an array of length n filled with ones.
+     *
+     * @param n length
+     * @return one filled array
+     */
+    public static float[] ones(int n) {
+        return full(n, 1);
+    }
+
+    public static float[] copyInto(float[] src, float @Nullable [] res) {
+        if (src == res) return res;
+        if (res == null) res = new float[src.length];
+        int n = Math.min(src.length, res.length);
+        System.arraycopy(src, 0, res, 0, n);
+        return res;
+    }
+
+    public static float[] subArray(float[] src, int start, int length) {
+        float[] res = new float[length];
+        System.arraycopy(src, start, res, 0, length);
+        return res;
+    }
+
+    public static float[] linspace(float start, float stop) {
+        return linspace(start, stop, 50, true);
+    }
+
+    public static float[] linspace(float start, float stop, boolean includeEndpoint) {
+        return linspace(start, stop, 50, includeEndpoint);
+    }
+
+    public static float[] linspace(float start, float stop, int n) {
+        return linspace(start, stop, n, true);
+    }
+
+    /**
+     * Creates an evenly spaced array over a specified interval.
+     *
+     * @param start           start of interval
+     * @param stop            stop of interval
+     * @param n               sample size = array length
+     * @param includeEndpoint true if stop should be included at the end of the array
+     * @return evenly spaced array over interval
+     */
+    public static float[] linspace(float start, float stop, int n, boolean includeEndpoint) {
+        float[] arr = new float[n];
+        float step = (stop - start) / (includeEndpoint ? n + 1 : n);
+        int s = n;
+        if (includeEndpoint) {
+            arr[n - 1] = stop;
+            s--;
+        }
+        for (int i = 0; i < s; i++) {
+            arr[i] = start + step * i;
+        }
+        return arr;
+    }
+
+    public static float[] arange(float stop, float step) {
+        return arange(0, stop, step);
+    }
+
+    public static float[] arange(float start, float stop, float step) {
+        float[] arr = new float[(int) Math.ceil((stop - start) / step)];
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = start + step * i;
+        }
+        return arr;
+    }
+
+    /**
+     * Returns the index of the largest value in the array. If array is empty, -1 is returned.
+     *
+     * @param arr array
+     * @return index of largest value
+     */
+    public static int argMax(float[] arr) {
+        if (arr.length == 0) return -1;
+        if (arr.length == 1) return 0;
+        if (arr.length == 2) return arr[0] >= arr[1] ? 0 : 1;
+        int index = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] > arr[index]) index = i;
+        }
+        return index;
+    }
+
+    /**
+     * Returns the index of the smallest value in the array. If array is empty, -1 is returned.
+     *
+     * @param arr array
+     * @return index of smallest value
+     */
+    public static int argMin(float[] arr) {
+        if (arr.length == 0) return -1;
+        if (arr.length == 1) return 0;
+        if (arr.length == 2) return arr[0] <= arr[1] ? 0 : 1;
+        int index = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] < arr[index]) index = i;
+        }
+        return index;
+    }
+
+    /**
+     * Returns the largest value in the array. If array is empty, 0 is returned.
+     *
+     * @param arr array
+     * @return largest value
+     */
+    public static float max(float[] arr) {
+        int i = argMax(arr);
+        return i < 0 ? 0 : arr[i];
+    }
+
+    /**
+     * Returns the smallest value in the array. If array is empty, 0 is returned.
+     *
+     * @param arr array
+     * @return smallest value
+     */
+    public static float min(float[] arr) {
+        int i = argMin(arr);
+        return i < 0 ? 0 : arr[i];
+    }
+
+    /**
+     * Adds an operand to every element of the source array.
+     *
+     * @param src source array
+     * @param op  operand
+     * @param res result array. If this is null a new array is created. This can be the same as src.
+     * @return result array
+     */
+    public static float[] plus(float[] src, float op, float @Nullable [] res) {
+        return applyEach(src, v -> v + op, res);
+    }
+
+    /**
+     * Adds each element of the operand to the element at the corresponding index of the source array.
+     *
+     * @param src source array
+     * @param op  operands
+     * @param res result array. If this is null a new array is created. This can be the same as src.
+     * @return result array
+     */
+    public static float[] plus(float[] src, float[] op, float @Nullable [] res) {
+        return applyEach(src, op, Float::sum, res);
+    }
+
+    /**
+     * Multiplies an operand with every element of the source array.
+     *
+     * @param src source array
+     * @param op  operand
+     * @param res result array. If this is null a new array is created. This can be the same as src.
+     * @return result array
+     */
+    public static float[] mult(float[] src, float op, float @Nullable [] res) {
+        return applyEach(src, v -> v * op, res);
+    }
+
+    public static float[] mult(float[] src, float[] op, float @Nullable [] res) {
+        return applyEach(src, op, (v, op1) -> v * op1, res);
+    }
+
+    public static float[] div(float[] src, float op, float @Nullable [] res) {
+        return mult(src, 1 / op, res);
+    }
+
+    public static float[] div(float[] src, float[] op, float @Nullable [] res) {
+        return applyEach(src, op, (v, op1) -> v / op1, res);
+    }
+
+    public static float[] diff(float[] src) {
+        if (src.length < 2) return EMPTY;
+        if (src.length == 2) return new float[] { src[1] - src[0] };
+        float[] res = new float[src.length - 1];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = src[i + 1] - src[i];
+        }
+        return res;
+    }
+
+    public static float[] applyEach(float[] src, UnaryFloatOperator op, float @Nullable [] res) {
+        if (res == null) res = new float[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i]);
+        return res;
+    }
+
+    public static float[] applyEach(float[] src, float[] operands, BinaryFloatOperator op, float @Nullable [] res) {
+        if (src.length != operands.length)
+            throw new IllegalArgumentException("Can't apply operator to operands of different size.");
+        if (res == null) res = new float[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i], operands[i]);
+        return res;
+    }
+
+    public static float[] applyEach(float[] src, float[] operands1, float[] operands2, TernaryFloatOperator op,
+                                    float @Nullable [] res) {
+        if (src.length != operands1.length || src.length != operands2.length) {
+            throw new IllegalArgumentException("Can't apply operator to operands of different size.");
+        }
+        if (res == null) res = new float[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i], operands1[i], operands2[i]);
+        return res;
+    }
+
+    public static float[] applyEach(float[] src, float[][] operands, NFloatOperator op, float @Nullable [] res) {
+        if (src.length != operands.length) {
+            throw new IllegalArgumentException("Can't apply operator to operands of different size.");
+        }
+        if (res == null) res = new float[src.length];
+        int n = Math.min(src.length, res.length);
+        for (int i = 0; i < n; i++) res[i] = op.apply(src[i], operands[i]);
+        return res;
+    }
+
+    public static float[] abs(float[] src, float @Nullable [] res) {
+        return applyEach(src, Math::abs, res);
+    }
+
+    public static float[] sin(float[] src, float @Nullable [] res) {
+        return applyEach(src, Mth::sin, res);
+    }
+
+    public static float[] cos(float[] src, float @Nullable [] res) {
+        return applyEach(src, Mth::cos, res);
+    }
+
+    public static float[] tan(float[] src, float @Nullable [] res) {
+        return applyEach(src, (r) -> (float) Math.tan(r), res);
+    }
+
+    public static float[] clamp(float[] src, float min, float max, float @Nullable [] res) {
+        return applyEach(src, v -> Mth.clamp(v, min, max), res);
+    }
+
+    public static float[] polynomial(float[] src, float[] coeff, float @Nullable [] res) {
+        if (coeff.length == 0) return copyInto(src, res);
+        if (coeff.length == 1) return plus(src, coeff[0], res);
+        return applyEach(src, x -> {
+            float y = 0;
+            y += coeff[0];
+            if (coeff.length == 2) return y + x * coeff[1];
+            for (int i = 1; i < coeff.length; i++) {
+                y += (float) (Math.pow(x, i) * coeff[i]);
+            }
+            return y;
+        }, res);
+    }
+
+    public interface UnaryFloatOperator {
+
+        float apply(float v);
+    }
+
+    public interface BinaryFloatOperator {
+
+        float apply(float v, float op);
+    }
+
+    public interface TernaryFloatOperator {
+
+        float apply(float v, float op1, float op2);
+    }
+
+    public interface NFloatOperator {
+
+        float apply(float v, float[] op);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/FpsCounter.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/FpsCounter.java
new file mode 100644
index 00000000000..33ea8fe9d0a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/FpsCounter.java
@@ -0,0 +1,29 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.Util;
+
+import lombok.Getter;
+
+public class FpsCounter {
+
+    @Getter
+    private int fps = 0;
+    private int frameCount = 0;
+    private long timer = Util.getMillis();
+
+    public void reset() {
+        this.fps = 0;
+        this.frameCount = 0;
+        this.timer = Util.getMillis();
+    }
+
+    public void onDraw() {
+        frameCount++;
+        long time = Util.getMillis();
+        if (time - timer >= 1000) {
+            fps = frameCount;
+            frameCount = 0;
+            timer += 1000;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/HoveredWidgetList.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/HoveredWidgetList.java
new file mode 100644
index 00000000000..d794e31bea6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/HoveredWidgetList.java
@@ -0,0 +1,33 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.LocatedWidget;
+
+import org.jetbrains.annotations.Nullable;
+
+public class HoveredWidgetList {
+
+    private final ObjectList<LocatedWidget> delegate;
+
+    public HoveredWidgetList(ObjectList<LocatedWidget> delegate) {
+        this.delegate = delegate;
+    }
+
+    public void add(IWidget widget, IViewportStack viewports, Object additionalHoverInfo) {
+        this.delegate.addFirst(new LocatedWidget(widget, viewports.peek(), additionalHoverInfo));
+    }
+
+    @Nullable
+    public IWidget peek() {
+        return isEmpty() ? null : this.delegate.get(0).getElement();
+    }
+
+    public boolean isEmpty() {
+        return this.delegate.isEmpty();
+    }
+
+    public int size() {
+        return this.delegate.size();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ImageUtil.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ImageUtil.java
new file mode 100644
index 00000000000..0e16e1dfe94
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ImageUtil.java
@@ -0,0 +1,263 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.GTCEu;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.Resource;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ImageUtil {
+
+    private static final List<ImageType> TYPES = new ArrayList<>();
+    private static final byte[] buffer = new byte[256];
+
+    public static final long ERROR_NO_RESOURCE = -1;
+    public static final long ERROR_NO_IMAGE_TYPE = -2;
+    public static final long ERROR_IO_EXCEPTION = -3;
+    public static final long ERROR_PNG = -4;
+    public static final long ERROR_JPEG_1 = -5;
+    public static final long ERROR_JPEG_2 = -6;
+
+    private static final String[] ERROR_MSG = {
+            "Resource not found",
+            "Unsupported file type",
+            "Failed to parse image with unknown cause",
+            "PNG file ended too early",
+            "JPEG started again within itself",
+            "JPEG ended too early"
+    };
+
+    public static Resource getResource(ResourceLocation resLoc) {
+        try {
+            return Minecraft.getInstance().getResourceManager().getResourceOrThrow(resLoc);
+        } catch (FileNotFoundException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Parses the image size from a resource. The returned packed size can be unpacked with {@link #getWidth(long)} and
+     * {@link #getHeight(long)}. If it failed a negative value is returned. Negative values can be translated into an
+     * error
+     * message using {@link #getError(long)}.
+     *
+     * @param resLoc resource location of the image
+     * @return packed size or negative error value
+     */
+    public static long readImageSize(ResourceLocation resLoc) {
+        Resource res = getResource(resLoc);
+        return res == null ? ERROR_NO_RESOURCE : readImageSize(res);
+    }
+
+    public static String getError(long size) {
+        return size < 0 ? ERROR_MSG[(int) (-size - 1)] : null;
+    }
+
+    /**
+     * Parses the image size from a resource. The returned packed size can be unpacked with {@link #getWidth(long)} and
+     * {@link #getHeight(long)}. If it failed a negative value is returned. Negative values can be translated into an
+     * error
+     * message using {@link #getError(long)}. A resource can be obtained with {@link #getResource(ResourceLocation)}.
+     *
+     * @param resource resource to read image size from
+     * @return packed size or negative error value
+     */
+    public static long readImageSize(Resource resource) {
+        try (InputStream inputStream = resource.open()) {
+            return readImageSize(inputStream);
+        } catch (IOException e) {
+            return ERROR_IO_EXCEPTION;
+        }
+    }
+
+    /**
+     * Parses the image size from the input stream. The returned packed size can be unpacked with
+     * {@link #getWidth(long)} and
+     * {@link #getHeight(long)}. If it failed a negative value is returned or an exception is thrown.
+     * Negative values can be translated into an error message using {@link #getError(long)}.
+     *
+     * @param inputStream bytes to read from
+     * @return packed size or negative error value
+     * @throws IOException if the input stream is not a valid image file
+     */
+    public static long readImageSize(InputStream inputStream) throws IOException {
+        ImageType type = parseImageType(inputStream);
+        return type == null ? ERROR_NO_IMAGE_TYPE : type.parse(inputStream);
+    }
+
+    public static long packSize(int width, int height) {
+        return width | (long) height << 32;
+    }
+
+    public static int getWidth(long packedSize) {
+        return (int) (packedSize & 0xFFFFFFFFL);
+    }
+
+    public static int getHeight(long packedSize) {
+        return (int) ((packedSize >> 32) & 0xFFFFFFFFL);
+    }
+
+    public static boolean testImageSize(ResourceLocation resLoc, int width, int height) {
+        long size = ImageUtil.readImageSize(resLoc);
+        if (size < 0) {
+            GTCEu.LOGGER.error("{} for location '{}'", getError(size), resLoc);
+            return false;
+        }
+        int w = ImageUtil.getWidth(size);
+        int h = ImageUtil.getHeight(size);
+        if (w != width || h != height) {
+            GTCEu.LOGGER.error("Image size is incorrect of image '{}'. Expected {}|{}, but actually is {}|{}", resLoc,
+                    width, height, w, h);
+        } else {
+            GTCEu.LOGGER.info("Image '{}' has correct size", resLoc);
+        }
+        return true;
+    }
+
+    private static ImageType parseImageType(InputStream inputStream) throws IOException {
+        if (TYPES.isEmpty()) initImageTypes();
+        int bytesRead = 0;
+        for (ImageType type : TYPES) {
+            while (type.signatureLength > bytesRead) {
+                buffer[bytesRead] = (byte) inputStream.read();
+                bytesRead++;
+            }
+            if (startsWith(buffer, bytesRead, type.signatureStart)) {
+                return type;
+            }
+        }
+        return null;
+    }
+
+    public static String getImageType(InputStream inputStream) {
+        try {
+            ImageType type = parseImageType(inputStream);
+            return type == null ? null : type.name();
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    private static void initImageTypes() {
+        // puts image types into the list sorted by signature length
+        // this allows checking for all image types without using PushbackInputStream
+        TYPES.clear();
+        ImageType[] types = ImageType.values();
+        TYPES.add(types[0]);
+        for (int i = 1; i < types.length; i++) {
+            for (int j = 0; j < TYPES.size(); j++) {
+                if (TYPES.get(j).signatureLength > types[i].signatureLength) {
+                    TYPES.add(j, types[i]);
+                    break;
+                }
+            }
+        }
+    }
+
+    public static DataInput getDataInput(InputStream is) {
+        return is instanceof DataInput dataInput ? dataInput : new DataInputStream(is);
+    }
+
+    public static byte[] toBytes(int... ints) {
+        byte[] bytes = new byte[ints.length];
+        for (int i = 0; i < ints.length; i++) {
+            bytes[i] = (byte) (ints[i] & 0xFF);
+        }
+        return bytes;
+    }
+
+    private static boolean startsWith(byte[] bytes, int bytesLen, byte[] startsWith) {
+        if (startsWith.length > bytesLen) return false;
+        for (int i = 0; i < startsWith.length; i++) {
+            if (startsWith[i] != bytes[i]) return false;
+        }
+        return true;
+    }
+
+    public static String getFileTypeOfPath(String path) {
+        int i = path.lastIndexOf('.');
+        return i < 0 || i == path.length() - 1 ? null : path.substring(i + 1);
+    }
+
+    public static int readLittleEndianShort(InputStream inputStream) throws IOException {
+        // DataInputStream reads big endian shorts
+        return (inputStream.read() & 0xFF) | ((inputStream.read() & 0xFF) << 8);
+    }
+
+    private interface SizeParser {
+
+        long parse(InputStream inputStream) throws IOException;
+    }
+
+    private enum ImageType implements SizeParser {
+
+        PNG(8, 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A) {
+
+            @Override
+            public long parse(InputStream inputStream) throws IOException {
+                DataInput dataInput = getDataInput(inputStream);
+                int skipped = dataInput.skipBytes(8); // IHDR length (4), IHDR type (4)
+                if (skipped != 8) return ERROR_PNG;
+                return packSize(dataInput.readInt(), dataInput.readInt()); // width and height
+            }
+        },
+        JPEG(2, 0xFF, 0xD8) {
+
+            @Override
+            public long parse(InputStream inputStream) throws IOException {
+                DataInput dis = getDataInput(inputStream);
+
+                while (true) {
+                    int marker = dis.readUnsignedShort();
+
+                    // Skip padding FFs
+                    while (marker == 0xFFFF) {
+                        marker = dis.readUnsignedByte();
+                    }
+
+                    // SOFn markers that contain size:
+                    if (marker >= 0xFFC0 && marker <= 0xFFC3 ||
+                            marker >= 0xFFC5 && marker <= 0xFFC7 ||
+                            marker >= 0xFFC9 && marker <= 0xFFCB ||
+                            marker >= 0xFFCD && marker <= 0xFFCF) {
+
+                        dis.readUnsignedShort(); // block length
+                        dis.readUnsignedByte();  // sample precision (8 bits)
+                        int height = dis.readUnsignedShort();
+                        int width = dis.readUnsignedShort();
+                        return packSize(width, height);
+                    }
+
+                    if (marker == 0xFFD8) return ERROR_JPEG_1;
+                    if (marker == 0xFFD9) return ERROR_JPEG_2;
+                    if (marker >= 0xFFD0 && marker <= 0xFFD7 || marker == 0xFF01) continue; // no payload
+
+                    // read length of payload and skip it
+                    // length includes marker, hence -2
+                    int len = dis.readUnsignedShort();
+                    dis.skipBytes(len - 2);
+                }
+            }
+        },
+        // 5th byte is variable -> only use the first 4
+        GIF(6, 0x47, 0x49, 0x46, 0x38) {
+
+            @Override
+            public long parse(InputStream inputStream) throws IOException {
+                return packSize(readLittleEndianShort(inputStream), readLittleEndianShort(inputStream));
+            }
+        };
+
+        private final int signatureLength;
+        private final byte[] signatureStart;
+
+        ImageType(int signatureLength, int... signatureStart) {
+            this.signatureLength = signatureLength;
+            this.signatureStart = toBytes(signatureStart);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Interpolation.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Interpolation.java
new file mode 100644
index 00000000000..ca082c44168
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Interpolation.java
@@ -0,0 +1,352 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IInterpolation;
+
+import net.minecraft.util.Mth;
+import net.minecraft.util.StringRepresentable;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Check out <a href=https://easings.net/en>this website</a> to find your desired interpolation method.
+ */
+public enum Interpolation implements IInterpolation, StringRepresentable {
+
+    LINEAR("linear") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return Interpolations.lerp(a, b, x);
+        }
+    },
+    QUAD_IN("quad_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return a + (b - a) * x * x;
+        }
+    },
+    QUAD_OUT("quad_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return a - (b - a) * x * (x - 2);
+        }
+    },
+    QUAD_INOUT("quad_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            x *= 2;
+
+            if (x < 1F) return a + (b - a) / 2 * x * x;
+
+            x -= 1;
+
+            return a - (b - a) / 2 * (x * (x - 2) - 1);
+        }
+    },
+    CUBIC_IN("cubic_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return a + (b - a) * x * x * x;
+        }
+    },
+    CUBIC_OUT("cubic_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            x -= 1;
+            return a + (b - a) * (x * x * x + 1);
+        }
+    },
+    CUBIC_INOUT("cubic_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            x *= 2;
+
+            if (x < 1F) return a + (b - a) / 2 * x * x * x;
+
+            x -= 2;
+
+            return a + (b - a) / 2 * (x * x * x + 2);
+        }
+    },
+    EXP_IN("exp_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return a + (b - a) * (float) Math.pow(2, 10 * (x - 1));
+        }
+    },
+    EXP_OUT("exp_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return a + (b - a) * (float) (-Math.pow(2, -10 * x) + 1);
+        }
+    },
+    EXP_INOUT("exp_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            if (x == 0) return a;
+            if (x == 1) return b;
+
+            x *= 2;
+
+            if (x < 1F) return a + (b - a) / 2 * (float) Math.pow(2, 10 * (x - 1));
+
+            x -= 1;
+
+            return a + (b - a) / 2 * (float) (-Math.pow(2, -10 * x) + 2);
+        }
+    },
+    /* Following interpolations below were copied from: https://easings.net/ */
+    BACK_IN("back_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float c1 = 1.70158F;
+            final float c3 = c1 + 1;
+
+            return Interpolations.lerp(a, b, c3 * x * x * x - c1 * x * x);
+        }
+    },
+    BACK_OUT("back_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float c1 = 1.70158F;
+            final float c3 = c1 + 1;
+
+            return Interpolations.lerp(a, b, 1 + c3 * (float) Math.pow(x - 1, 3) + c1 * (float) Math.pow(x - 1, 2));
+        }
+    },
+    BACK_INOUT("back_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float c1 = 1.70158F;
+            final float c2 = c1 * 1.525F;
+
+            float factor = x < 0.5 ? ((float) Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2 :
+                    ((float) Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    ELASTIC_IN("elastic_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float c4 = (2 * (float) Math.PI) / 3;
+
+            float factor = x == 0 ? 0 :
+                    (x == 1 ? 1 : -(float) Math.pow(2, 10 * x - 10) * (float) Math.sin((x * 10 - 10.75) * c4));
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    ELASTIC_OUT("elastic_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float c4 = (2 * (float) Math.PI) / 3;
+
+            float factor = x == 0 ? 0 :
+                    (x == 1 ? 1 : (float) Math.pow(2, -10 * x) * (float) Math.sin((x * 10 - 0.75) * c4) + 1);
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    ELASTIC_INOUT("elastic_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float c5 = (2 * (float) Math.PI) / 4.5F;
+
+            float v = (float) Math.sin((20 * x - 11.125) * c5);
+            float factor = x == 0 ? 0 : (x == 1 ? 1 :
+                    (x < 0.5 ? -((float) Math.pow(2, 20 * x - 10) * v) / 2 :
+                            ((float) Math.pow(2, -20 * x + 10) * v) / 2 + 1));
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    BOUNCE_IN("bounce_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            return Interpolations.lerp(a, b, 1 - BOUNCE_OUT.interpolate(0, 1, 1 - x));
+        }
+    },
+    BOUNCE_OUT("bounce_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            final float n1 = 7.5625F;
+            final float d1 = 2.75F;
+            float factor;
+
+            if (x < 1 / d1) {
+                factor = n1 * x * x;
+            } else if (x < 2 / d1) {
+                factor = n1 * (x -= 1.5F / d1) * x + 0.75F;
+            } else if (x < 2.5 / d1) {
+                factor = n1 * (x -= 2.25F / d1) * x + 0.9375F;
+            } else {
+                factor = n1 * (x -= 2.625F / d1) * x + 0.984375F;
+            }
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    BOUNCE_INOUT("bounce_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = x < 0.5 ? (1 - BOUNCE_OUT.interpolate(0, 1, 1 - 2 * x)) / 2 :
+                    (1 + BOUNCE_OUT.interpolate(0, 1, 2 * x - 1)) / 2;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    SINE_IN("sine_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = 1 - (float) Math.cos((x * Math.PI) / 2);
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    SINE_OUT("sine_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = (float) Math.sin((x * Math.PI) / 2);
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    SINE_INOUT("sine_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = (float) (-(Math.cos(Math.PI * x) - 1) / 2);
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    QUART_IN("quart_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = x * x * x * x;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    QUART_OUT("quart_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = 1 - (float) Math.pow(1 - x, 4);
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    QUART_INOUT("quart_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = x < 0.5 ? 8 * x * x * x * x : 1 - (float) Math.pow(-2 * x + 2, 4) / 2;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    QUINT_IN("quint_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = x * x * x * x * x;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    QUINT_OUT("quint_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = 1 - (float) Math.pow(1 - x, 5);
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    QUINT_INOUT("quint_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            float factor = x < 0.5 ? 16 * x * x * x * x * x : 1 - (float) Math.pow(-2 * x + 2, 5) / 2;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    CIRCLE_IN("circle_in") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            x = Mth.clamp(x, 0, 1);
+
+            float factor = 1 - (float) Math.sqrt(1 - Math.pow(x, 2));
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    CIRCLE_OUT("circle_out") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            x = Mth.clamp(x, 0, 1);
+
+            float factor = (float) Math.sqrt(1 - Math.pow(x - 1, 2));
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    },
+    CIRCLE_INOUT("circle_inout") {
+
+        @Override
+        public float interpolate(float a, float b, float x) {
+            x = Mth.clamp(x, 0, 1);
+
+            float factor = x < 0.5 ? (float) (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2 :
+                    (float) (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;
+
+            return Interpolations.lerp(a, b, factor);
+        }
+    };
+
+    public final String name;
+
+    Interpolation(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public @NotNull String getSerializedName() {
+        return this.name;
+    }
+
+    public static Interpolation getForName(String name) {
+        for (Interpolation interpolation : values()) {
+            if (interpolation.name.equals(name)) {
+                return interpolation;
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Interpolations.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Interpolations.java
new file mode 100644
index 00000000000..5653c09dac0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Interpolations.java
@@ -0,0 +1,349 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.util.Mth;
+
+/**
+ * Interpolation methods
+ * <p>
+ * This class is responsible for doing different kind of interpolations. Cubic
+ * interpolation code was from website below, but BauerCam also uses this code.
+ *
+ * @author mchorse
+ * @see <a href="http://paulbourke.net/miscellaneous/interpolation/">Interpolations</a>
+ */
+public class Interpolations {
+
+    /**
+     * Linear interpolation
+     */
+    public static float lerp(float a, float b, float position) {
+        return a + (b - a) * position;
+    }
+
+    public static int lerp(int a, int b, float position) {
+        return (int) (a + (b - a) * position);
+    }
+
+    /**
+     * Special interpolation method for interpolating yaw. The problem with yaw,
+     * is that it may go in the "wrong" direction when having, for example,
+     * -170 (as a) and 170 (as b) degress or other way around (170 and -170).
+     * <p>
+     * This interpolation method fixes this problem.
+     */
+    public static float lerpYaw(float a, float b, float position) {
+        a = Mth.wrapDegrees(a);
+        b = Mth.wrapDegrees(b);
+
+        return lerp(a, normalizeYaw(a, b), position);
+    }
+
+    /**
+     * Cubic interpolation using Hermite between y1 and y2. Taken from paul's
+     * website.
+     *
+     * @param y0 - points[x-1]
+     * @param y1 - points[x]
+     * @param y2 - points[x+1]
+     * @param y3 - points[x+2]
+     * @param x  - step between 0 and 1
+     */
+    public static double cubicHermite(double y0, double y1, double y2, double y3, double x) {
+        double a = -0.5 * y0 + 1.5 * y1 - 1.5 * y2 + 0.5 * y3;
+        double b = y0 - 2.5 * y1 + 2 * y2 - 0.5 * y3;
+        double c = -0.5 * y0 + 0.5 * y2;
+
+        return ((a * x + b) * x + c) * x + y1;
+    }
+
+    /**
+     * Yaw normalization for cubic interpolation
+     */
+    public static double cubicHermiteYaw(float y0, float y1, float y2, float y3, float position) {
+        y0 = Mth.wrapDegrees(y0);
+        y1 = Mth.wrapDegrees(y1);
+        y2 = Mth.wrapDegrees(y2);
+        y3 = Mth.wrapDegrees(y3);
+
+        y1 = normalizeYaw(y0, y1);
+        y2 = normalizeYaw(y1, y2);
+        y3 = normalizeYaw(y2, y3);
+
+        return cubicHermite(y0, y1, y2, y3, position);
+    }
+
+    /**
+     * Cubic interpolation between y1 and y2. Taken from paul's website.
+     *
+     * @param y0 - points[x-1]
+     * @param y1 - points[x]
+     * @param y2 - points[x+1]
+     * @param y3 - points[x+2]
+     * @param x  - step between 0 and 1
+     */
+    public static float cubic(float y0, float y1, float y2, float y3, float x) {
+        float a = y3 - y2 - y0 + y1;
+        float b = y0 - y1 - a;
+        float c = y2 - y0;
+
+        return ((a * x + b) * x + c) * x + y1;
+    }
+
+    /**
+     * Yaw normalization for cubic interpolation
+     */
+    public static float cubicYaw(float y0, float y1, float y2, float y3, float position) {
+        y0 = Mth.wrapDegrees(y0);
+        y1 = Mth.wrapDegrees(y1);
+        y2 = Mth.wrapDegrees(y2);
+        y3 = Mth.wrapDegrees(y3);
+
+        y1 = normalizeYaw(y0, y1);
+        y2 = normalizeYaw(y1, y2);
+        y3 = normalizeYaw(y2, y3);
+
+        return cubic(y0, y1, y2, y3, position);
+    }
+
+    /**
+     * Calculate X value for given T using some brute force algorithm...
+     * This method should be precise enough
+     *
+     * @param x1      - control point of initial value
+     * @param x2      - control point of final value
+     * @param t       - time (should be 0..1)
+     * @param epsilon - delta that would satisfy the approximation
+     */
+    public static float bezierX(float x1, float x2, float t, final float epsilon) {
+        float x = t;
+        float init = bezier(0, x1, x2, 1, t);
+        float factor = Math.copySign(0.1F, t - init);
+
+        while (Math.abs(t - init) > epsilon) {
+            float oldFactor = factor;
+
+            x += factor;
+            init = bezier(0, x1, x2, 1, x);
+
+            if (Math.copySign(factor, t - init) != oldFactor) {
+                factor *= -0.25F;
+            }
+        }
+
+        return x;
+    }
+
+    /**
+     * Calculate X value for given T using default epsilon value. See
+     * other overload method for more information.
+     */
+    public static float bezierX(float x1, float x2, float t) {
+        return bezierX(x1, x2, t, 0.0005F);
+    }
+
+    /**
+     * Calculate cubic bezier from given variables
+     *
+     * @param x1 - initial value
+     * @param x2 - control point of initial value
+     * @param x3 - control point of final value
+     * @param x4 - final value
+     * @param t  - time (should be 0..1)
+     */
+    public static float bezier(float x1, float x2, float x3, float x4, float t) {
+        float t1 = lerp(x1, x2, t);
+        float t2 = lerp(x2, x3, t);
+        float t3 = lerp(x3, x4, t);
+        float t4 = lerp(t1, t2, t);
+        float t5 = lerp(t2, t3, t);
+
+        return lerp(t4, t5, t);
+    }
+
+    /**
+     * Normalize yaw rotation (argument {@code b}) based on the previous
+     * yaw rotation.
+     */
+    public static float normalizeYaw(float a, float b) {
+        float diff = a - b;
+
+        if (diff > 180 || diff < -180) {
+            diff = Math.copySign(360 - Math.abs(diff), diff);
+
+            return a + diff;
+        }
+
+        return b;
+    }
+
+    /**
+     * Envelope function allows to create simple attack, sustain and release function.
+     * <p>
+     * This version only goes from 0 to duration with fade in/out being the same
+     */
+    public static float envelope(float x, float duration, float fades) {
+        return envelope(x, 0, fades, duration - fades, duration);
+    }
+
+    /**
+     * Envelope function allows to create simple attack, sustain and release function.
+     * <p>
+     * This advanced version allows you to specify a more customized range
+     */
+    public static float envelope(float x, float lowIn, float lowOut, float highIn, float highOut) {
+        if (x < lowIn || x > highOut) return 0;
+        if (x < lowOut) return (x - lowIn) / (lowOut - lowIn);
+        if (x > highIn) return 1 - (x - highIn) / (highOut - highIn);
+
+        return 1;
+    }
+
+    /* --- Double versions of the functions --- */
+
+    /**
+     * Linear interpolation
+     */
+    public static double lerp(double a, double b, double position) {
+        return a + (b - a) * position;
+    }
+
+    /**
+     * Special interpolation method for interpolating yaw. The problem with yaw,
+     * is that it may go in the "wrong" direction when having, for example,
+     * -170 (as a) and 170 (as b) degress or other way around (170 and -170).
+     * <p>
+     * This interpolation method fixes this problem.
+     */
+    public static double lerpYaw(double a, double b, double position) {
+        a = Mth.wrapDegrees(a);
+        b = Mth.wrapDegrees(b);
+
+        return lerp(a, normalizeYaw(a, b), position);
+    }
+
+    /**
+     * Cubic interpolation between y1 and y2. Taken from paul's website.
+     *
+     * @param y0 - points[x-1]
+     * @param y1 - points[x]
+     * @param y2 - points[x+1]
+     * @param y3 - points[x+2]
+     * @param x  - step between 0 and 1
+     */
+    public static double cubic(double y0, double y1, double y2, double y3, double x) {
+        double a = y3 - y2 - y0 + y1;
+        double b = y0 - y1 - a;
+        double c = y2 - y0;
+
+        return ((a * x + b) * x + c) * x + y1;
+    }
+
+    /**
+     * Yaw normalization for cubic interpolation
+     */
+    public static double cubicYaw(double y0, double y1, double y2, double y3, double position) {
+        y0 = Mth.wrapDegrees(y0);
+        y1 = Mth.wrapDegrees(y1);
+        y2 = Mth.wrapDegrees(y2);
+        y3 = Mth.wrapDegrees(y3);
+
+        y1 = normalizeYaw(y0, y1);
+        y2 = normalizeYaw(y1, y2);
+        y3 = normalizeYaw(y2, y3);
+
+        return cubic(y0, y1, y2, y3, position);
+    }
+
+    /**
+     * Calculate X value for given T using some brute force algorithm...
+     * This method should be precise enough
+     *
+     * @param x1      - control point of initial value
+     * @param x2      - control point of final value
+     * @param t       - time (should be 0..1)
+     * @param epsilon - delta that would satisfy the approximation
+     */
+    public static double bezierX(double x1, double x2, double t, final double epsilon) {
+        double x = t;
+        double init = bezier(0, x1, x2, 1, t);
+        double factor = Math.copySign(0.1F, t - init);
+
+        while (Math.abs(t - init) > epsilon) {
+            double oldFactor = factor;
+
+            x += factor;
+            init = bezier(0, x1, x2, 1, x);
+
+            if (Math.copySign(factor, t - init) != oldFactor) {
+                factor *= -0.25F;
+            }
+        }
+
+        return x;
+    }
+
+    /**
+     * Calculate X value for given T using default epsilon value. See
+     * other overload method for more information.
+     */
+    public static double bezierX(double x1, double x2, float t) {
+        return bezierX(x1, x2, t, 0.0005F);
+    }
+
+    /**
+     * Calculate cubic bezier from given variables
+     *
+     * @param x1 - initial value
+     * @param x2 - control point of initial value
+     * @param x3 - control point of final value
+     * @param x4 - final value
+     * @param t  - time (should be 0..1)
+     */
+    public static double bezier(double x1, double x2, double x3, double x4, double t) {
+        double t1 = lerp(x1, x2, t);
+        double t2 = lerp(x2, x3, t);
+        double t3 = lerp(x3, x4, t);
+        double t4 = lerp(t1, t2, t);
+        double t5 = lerp(t2, t3, t);
+
+        return lerp(t4, t5, t);
+    }
+
+    /**
+     * Normalize yaw rotation (argument {@code b}) based on the previous
+     * yaw rotation.
+     */
+    public static double normalizeYaw(double a, double b) {
+        double diff = a - b;
+
+        if (diff > 180 || diff < -180) {
+            diff = Math.copySign(360 - Math.abs(diff), diff);
+
+            return a + diff;
+        }
+
+        return b;
+    }
+
+    /**
+     * Envelope function allows to create simple attack, sustain and release function.
+     * <p>
+     * This version only goes from 0 to duration with fade in/out being the same
+     */
+    public static double envelope(double x, double duration, double fades) {
+        return envelope(x, 0, fades, duration - fades, duration);
+    }
+
+    /**
+     * Envelope function allows to create simple attack, sustain and release function.
+     * <p>
+     * This advanced version allows you to specify a more customized range
+     */
+    public static double envelope(double x, double lowIn, double lowOut, double highIn, double highOut) {
+        if (x < lowIn || x > highOut) return 0;
+        if (x < lowOut) return (x - lowIn) / (lowOut - lowIn);
+        if (x > highIn) return 1 - (x - highIn) / (highOut - highIn);
+
+        return 1;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/KeyboardData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/KeyboardData.java
new file mode 100644
index 00000000000..dbb099b0208
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/KeyboardData.java
@@ -0,0 +1,44 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.lwjgl.glfw.GLFW;
+
+public record KeyboardData(Dist side, int keyCode, int scanCode, int modifiers) {
+
+    public boolean hasControlDown() {
+        return (this.modifiers & GLFW.GLFW_MOD_CONTROL) != 0;
+    }
+
+    public boolean hasShiftDown() {
+        return (this.modifiers & GLFW.GLFW_MOD_SHIFT) != 0;
+    }
+
+    public boolean hasAltDown() {
+        return (this.modifiers & GLFW.GLFW_MOD_ALT) != 0;
+    }
+
+    public boolean isClient() {
+        return this.side.isClient();
+    }
+
+    public void writeToPacket(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(this.keyCode);
+        buffer.writeVarInt(this.scanCode);
+        buffer.writeVarInt(this.modifiers);
+    }
+
+    public static KeyboardData readPacket(FriendlyByteBuf buffer) {
+        int keyCode = buffer.readVarInt();
+        int scanCode = buffer.readVarInt();
+        int modifiers = buffer.readVarInt();
+        return new KeyboardData(Dist.DEDICATED_SERVER, keyCode, scanCode, modifiers);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static KeyboardData create(int keyCode, int scanCode, int modifiers) {
+        return new KeyboardData(Dist.CLIENT, keyCode, scanCode, modifiers);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/MouseData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/MouseData.java
new file mode 100644
index 00000000000..7195f7f2072
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/MouseData.java
@@ -0,0 +1,35 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+public record MouseData(Dist side, int mouseButton, boolean shift, boolean ctrl, boolean alt) {
+
+    public boolean isClient() {
+        return this.side.isClient();
+    }
+
+    public void writeToPacket(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(this.mouseButton);
+        byte data = 0;
+        if (this.shift) data |= 1;
+        if (this.ctrl) data |= 2;
+        if (this.alt) data |= 4;
+        buffer.writeByte(data);
+    }
+
+    public static MouseData readPacket(FriendlyByteBuf buffer) {
+        int button = buffer.readVarInt();
+        byte data = buffer.readByte();
+        return new MouseData(Dist.DEDICATED_SERVER, button, (data & 1) != 0, (data & 2) != 0, (data & 4) != 0);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public static MouseData create(int mouse) {
+        return new MouseData(Dist.CLIENT, mouse,
+                Interactable.hasShiftDown(), Interactable.hasControlDown(), Interactable.hasAltDown());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/MutableSingletonList.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/MutableSingletonList.java
new file mode 100644
index 00000000000..b707fa9784a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/MutableSingletonList.java
@@ -0,0 +1,280 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class MutableSingletonList<T> implements List<T> {
+
+    private boolean hasValue;
+    private T value;
+
+    public MutableSingletonList() {
+        remove();
+    }
+
+    public MutableSingletonList(T value) {
+        set(value);
+    }
+
+    public T get() {
+        if (!this.hasValue) throw new IndexOutOfBoundsException("List is empty but tried to access index 0!");
+        return value;
+    }
+
+    public T getOrNull() {
+        return hasValue ? value : null;
+    }
+
+    public void set(T t) {
+        this.value = t;
+        this.hasValue = true;
+    }
+
+    public void remove() {
+        this.value = null;
+        this.hasValue = false;
+    }
+
+    @Override
+    public int size() {
+        return hasValue ? 1 : 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return !hasValue;
+    }
+
+    public boolean hasValue() {
+        return hasValue;
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return this.hasValue && Objects.equals(this.value, o);
+    }
+
+    @Override
+    public @NotNull Iterator<T> iterator() {
+        return new Iterator<>() {
+
+            private byte cursor = 0;
+
+            @Override
+            public boolean hasNext() {
+                return MutableSingletonList.this.hasValue && this.cursor == 0;
+            }
+
+            @Override
+            public T next() {
+                if (!hasNext()) throw new NoSuchElementException();
+                this.cursor++;
+                return MutableSingletonList.this.value;
+            }
+
+            @Override
+            public void remove() {
+                if (this.cursor < 1) throw new IllegalStateException();
+                MutableSingletonList.this.remove();
+                this.cursor--;
+            }
+        };
+    }
+
+    @Override
+    public @NotNull Object @NotNull [] toArray() {
+        if (!this.hasValue) return new Object[0];
+        Object[] o = new Object[1];
+        o[0] = this.value;
+        return o;
+    }
+
+    @Override
+    public @NotNull <T1> T1 @NotNull [] toArray(@NotNull T1 @NotNull [] a) {
+        if (!this.hasValue) return a;
+        if (a.length == 0) a = Arrays.copyOf(a, 1);
+        a[0] = (T1) this.value;
+        return a;
+    }
+
+    @Override
+    public boolean add(T t) {
+        if (this.hasValue) throw new IllegalStateException(
+                "MutableSingletonList can only have one value, but it already has a value!");
+        set(t);
+        return false;
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        if (contains(o)) {
+            remove();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        int s = c.size();
+        if (s > 1 || (s == 1 != this.hasValue)) return false;
+        if (!this.hasValue) return true;
+        if (c instanceof List<?> l) return Objects.equals(this.value, l.get(0));
+        return Objects.equals(this.value, c.iterator().next());
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends T> c) {
+        if (this.hasValue || c.isEmpty()) return false;
+        if (c instanceof List<?> l) {
+            add((T) l.get(0));
+        } else {
+            add(c.iterator().next());
+        }
+        return true;
+    }
+
+    private void verifyIndex(int i, boolean checkEmpty) {
+        if (i != 0) throw new IndexOutOfBoundsException("MutableSingletonList only accepts index 0!");
+        if (checkEmpty && !this.hasValue)
+            throw new IndexOutOfBoundsException("Tried to access index 0, but MutableSingletonList has no element!");
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends T> c) {
+        verifyIndex(index, false);
+        return addAll(c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        if (!this.hasValue || c.isEmpty()) return false;
+        if (c instanceof List<?> l) {
+            return remove(l.get(0));
+        }
+        return remove(c.iterator().next());
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        if (!this.hasValue || c.contains(this.value)) return false;
+        remove();
+        return true;
+    }
+
+    @Override
+    public void clear() {
+        remove();
+    }
+
+    @Override
+    public T get(int index) {
+        verifyIndex(index, true);
+        return null;
+    }
+
+    @Override
+    public T set(int index, T element) {
+        verifyIndex(index, true);
+        T t = this.value;
+        this.value = element;
+        return t;
+    }
+
+    @Override
+    public void add(int index, T element) {
+        verifyIndex(index, false);
+        add(element);
+    }
+
+    @Override
+    public T remove(int index) {
+        verifyIndex(index, true);
+        T t = this.value;
+        remove();
+        return t;
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return contains(o) ? 0 : -1;
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return indexOf(o);
+    }
+
+    @Override
+    public @NotNull ListIterator<T> listIterator() {
+        return new ListIterator<T>() {
+
+            private byte cursor = 0;
+
+            @Override
+            public boolean hasNext() {
+                return MutableSingletonList.this.hasValue && (this.cursor == 0 || this.cursor == -1);
+            }
+
+            @Override
+            public T next() {
+                if (!hasNext()) throw new NoSuchElementException();
+                this.cursor = 1;
+                return MutableSingletonList.this.value;
+            }
+
+            @Override
+            public boolean hasPrevious() {
+                return MutableSingletonList.this.hasValue && (this.cursor == 0 || this.cursor == 1);
+            }
+
+            @Override
+            public T previous() {
+                if (!hasNext()) throw new NoSuchElementException();
+                this.cursor = -1;
+                return MutableSingletonList.this.value;
+            }
+
+            @Override
+            public int nextIndex() {
+                return cursor == 0 ? 0 : 1;
+            }
+
+            @Override
+            public int previousIndex() {
+                return cursor == 0 ? 0 : -1;
+            }
+
+            @Override
+            public void remove() {
+                if (this.cursor == 0) throw new IllegalStateException();
+                MutableSingletonList.this.remove();
+                this.cursor = 0;
+            }
+
+            @Override
+            public void set(T t) {
+                if (this.cursor == 0) throw new IllegalStateException();
+                MutableSingletonList.this.set(t);
+            }
+
+            @Override
+            public void add(T t) {
+                MutableSingletonList.this.add(t);
+            }
+        };
+    }
+
+    @Override
+    public @NotNull ListIterator<T> listIterator(int index) {
+        verifyIndex(index, false);
+        return listIterator();
+    }
+
+    @Override
+    public @NotNull List<T> subList(int fromIndex, int toIndex) {
+        if (fromIndex < 0 || toIndex > 1 || toIndex < fromIndex) throw new IndexOutOfBoundsException();
+        return new MutableSingletonList<>(this.value);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ObjectList.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ObjectList.java
new file mode 100644
index 00000000000..aa739ef0511
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/ObjectList.java
@@ -0,0 +1,170 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import it.unimi.dsi.fastutil.objects.ObjectCollection;
+import it.unimi.dsi.fastutil.objects.ObjectIterator;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+public interface ObjectList<V> extends it.unimi.dsi.fastutil.objects.ObjectList<V> {
+
+    static <V> ObjectArrayList<V> create() {
+        return new ObjectArrayList<>();
+    }
+
+    static <V> ObjectArrayList<V> create(int size) {
+        return new ObjectArrayList<>(size);
+    }
+
+    static <V> ObjectArrayList<V> of(Collection<? extends V> c) {
+        return new ObjectArrayList<>(c);
+    }
+
+    static <V> ObjectArrayList<V> of(ObjectCollection<? extends V> c) {
+        return new ObjectArrayList<>(c);
+    }
+
+    static <V> ObjectArrayList<V> of(it.unimi.dsi.fastutil.objects.ObjectList<? extends V> l) {
+        return new ObjectArrayList<>(l);
+    }
+
+    static <V> ObjectArrayList<V> of(V[] a) {
+        return new ObjectArrayList<>(a);
+    }
+
+    static <V> ObjectArrayList<V> of(V[] a, int offset, int length) {
+        return new ObjectArrayList<>(a, offset, length);
+    }
+
+    static <V> ObjectArrayList<V> of(Iterator<? extends V> i) {
+        return new ObjectArrayList<>(i);
+    }
+
+    static <V> ObjectArrayList<V> of(ObjectIterator<? extends V> i) {
+        return new ObjectArrayList<>(i);
+    }
+
+    void addFirst(V v);
+
+    void addLast(V v);
+
+    @NotNull
+    V getFirst();
+
+    @NotNull
+    V getLast();
+
+    @NotNull
+    V removeFirst();
+
+    @NotNull
+    V removeLast();
+
+    @Nullable
+    V peekFirst();
+
+    @Nullable
+    V pollFirst();
+
+    @Nullable
+    V peekLast();
+
+    @Nullable
+    V pollLast();
+
+    void trim();
+
+    @NotNull
+    V[] elements();
+
+    void ensureCapacity(int minCapacity);
+
+    class ObjectArrayList<V> extends it.unimi.dsi.fastutil.objects.ObjectArrayList<V> implements ObjectList<V> {
+
+        public ObjectArrayList(int capacity) {
+            super(capacity);
+        }
+
+        public ObjectArrayList() {}
+
+        public ObjectArrayList(Collection<? extends V> c) {
+            super(c);
+        }
+
+        public ObjectArrayList(ObjectCollection<? extends V> c) {
+            super(c);
+        }
+
+        public ObjectArrayList(it.unimi.dsi.fastutil.objects.ObjectList<? extends V> l) {
+            super(l);
+        }
+
+        public ObjectArrayList(V[] a) {
+            super(a);
+        }
+
+        public ObjectArrayList(V[] a, int offset, int length) {
+            super(a, offset, length);
+        }
+
+        public ObjectArrayList(Iterator<? extends V> i) {
+            super(i);
+        }
+
+        public ObjectArrayList(ObjectIterator<? extends V> i) {
+            super(i);
+        }
+
+        @Override
+        public void addFirst(V v) {
+            add(0, v);
+        }
+
+        @Override
+        public void addLast(V v) {
+            add(v);
+        }
+
+        @Override
+        public @NotNull V getFirst() {
+            return get(0);
+        }
+
+        @Override
+        public @NotNull V getLast() {
+            return get(size() - 1);
+        }
+
+        @Override
+        public @NotNull V removeFirst() {
+            return remove(0);
+        }
+
+        @Override
+        public @NotNull V removeLast() {
+            return remove(size() - 1);
+        }
+
+        @Override
+        public V peekFirst() {
+            return isEmpty() ? null : getFirst();
+        }
+
+        @Override
+        public V pollFirst() {
+            return isEmpty() ? null : removeFirst();
+        }
+
+        @Override
+        public V peekLast() {
+            return isEmpty() ? null : getLast();
+        }
+
+        @Override
+        public V pollLast() {
+            return isEmpty() ? null : removeLast();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Point.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Point.java
new file mode 100644
index 00000000000..8365ad580fa
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Point.java
@@ -0,0 +1,67 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public final class Point {
+
+    public static final Point ZERO = new Point(0, 0);
+
+    @Getter
+    @Setter
+    public int x;
+    @Getter
+    @Setter
+    public int y;
+
+    public Point() {
+        this(0, 0);
+    }
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Point(Point point) {
+        this(point.x, point.y);
+    }
+
+    public Point copy() {
+        return new Point(this);
+    }
+
+    public Point inverse() {
+        return new Point(-this.x, -this.y);
+    }
+
+    public Point move(int x, int y) {
+        return new Point(this.x + x, this.y + y);
+    }
+
+    public Point move(Point point) {
+        return this.move(point.x, point.y);
+    }
+
+    public Point offset(int x, int y) {
+        return move(x, y);
+    }
+
+    public Point offset(Point point) {
+        return this.move(point);
+    }
+
+    public Point set(int x, int y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    public Point set(Point point) {
+        return set(point.x, point.y);
+    }
+
+    public Point set(PointF point) {
+        return set(Math.round(point.x), Math.round(point.y));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/PointF.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/PointF.java
new file mode 100644
index 00000000000..ee0ec8d6450
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/PointF.java
@@ -0,0 +1,71 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public final class PointF {
+
+    public static final PointF ZERO = new PointF(0, 0);
+
+    @Getter
+    @Setter
+    public float x;
+    @Getter
+    @Setter
+    public float y;
+
+    public PointF() {
+        this(0, 0);
+    }
+
+    public PointF(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public PointF(PointF point) {
+        this(point.x, point.y);
+    }
+
+    public PointF(Point point) {
+        this(point.x, point.y);
+    }
+
+    public PointF copy() {
+        return new PointF(this);
+    }
+
+    public PointF inverse() {
+        return new PointF(-this.x, -this.y);
+    }
+
+    public PointF move(float x, float y) {
+        return new PointF(this.x + x, this.y + y);
+    }
+
+    public PointF move(PointF point) {
+        return move(point.x, point.y);
+    }
+
+    public PointF offset(float x, float y) {
+        return move(x, y);
+    }
+
+    public PointF offset(PointF point) {
+        return move(point);
+    }
+
+    public PointF set(float x, float y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    public PointF set(PointF point) {
+        return set(point.x, point.y);
+    }
+
+    public PointF set(Point point) {
+        return set(point.x, point.y);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Rectangle.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Rectangle.java
new file mode 100644
index 00000000000..f3b3225c27b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Rectangle.java
@@ -0,0 +1,88 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.client.renderer.Rect2i;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class Rectangle {
+
+    @Getter
+    @Setter
+    public int x;
+    @Getter
+    @Setter
+    public int y;
+    @Getter
+    @Setter
+    public int width;
+    @Getter
+    @Setter
+    public int height;
+
+    public Rectangle() {
+        this(0, 0, 0, 0);
+    }
+
+    public Rectangle(Rectangle toCopy) {
+        this(toCopy.x, toCopy.y, toCopy.width, toCopy.height);
+    }
+
+    public Rectangle(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public Rectangle intersect(Rectangle other) {
+        int i = this.x;
+        int j = this.y;
+        int k = this.x + this.width;
+        int l = this.y + this.height;
+        int i1 = other.getX();
+        int j1 = other.getY();
+        int k1 = i1 + other.getWidth();
+        int l1 = j1 + other.getHeight();
+        this.x = Math.max(i, i1);
+        this.y = Math.max(j, j1);
+        this.width = Math.max(0, Math.min(k, k1) - this.x);
+        this.height = Math.max(0, Math.min(l, l1) - this.y);
+        return this;
+    }
+
+    public void setPosition(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void setBounds(Rectangle toCopy) {
+        setBounds(toCopy.x, toCopy.y, toCopy.width, toCopy.height);
+    }
+
+    public void setBounds(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public PointF getCenter() {
+        return new PointF(x + width / 2.0f, y + height / 2.0f);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public Rect2i asRect2i() {
+        return new Rect2i(this.x, this.y, this.width, this.height);
+    }
+
+    public boolean contains(int x, int y) {
+        return x >= this.x && x <= this.x + this.width && y >= this.y && y <= this.y + this.height;
+    }
+
+    public boolean contains(Point point) {
+        return contains(point.x, point.y);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/RectangleF.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/RectangleF.java
new file mode 100644
index 00000000000..c85b7dc86ea
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/RectangleF.java
@@ -0,0 +1,95 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class RectangleF {
+
+    @Getter
+    @Setter
+    public float x;
+    @Getter
+    @Setter
+    public float y;
+    @Getter
+    @Setter
+    public float width;
+    @Getter
+    @Setter
+    public float height;
+
+    public RectangleF() {
+        this(0, 0, 0, 0);
+    }
+
+    public RectangleF(RectangleF toCopy) {
+        this(toCopy.x, toCopy.y, toCopy.width, toCopy.height);
+    }
+
+    public RectangleF(float x, float y, float width, float height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public RectangleF intersect(RectangleF other) {
+        float i = this.x;
+        float j = this.y;
+        float k = this.x + this.width;
+        float l = this.y + this.height;
+        float i1 = other.getX();
+        float j1 = other.getY();
+        float k1 = i1 + other.getWidth();
+        float l1 = j1 + other.getHeight();
+        this.x = Math.max(i, i1);
+        this.y = Math.max(j, j1);
+        this.width = Math.max(0, Math.min(k, k1) - this.x);
+        this.height = Math.max(0, Math.min(l, l1) - this.y);
+        return this;
+    }
+
+    public void setPosition(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void setBounds(RectangleF toCopy) {
+        setBounds(toCopy.x, toCopy.y, toCopy.width, toCopy.height);
+    }
+
+    public void setBounds(float x, float y, float width, float height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public PointF getCenter() {
+        return new PointF(x + width / 2.0f, y + height / 2.0f);
+    }
+
+    public boolean contains(float x, float y) {
+        return x >= this.x && x <= this.x + this.width && y >= this.y && y <= this.y + this.height;
+    }
+
+    public boolean contains(Point point) {
+        return contains(point.x, point.y);
+    }
+
+    public float u0() {
+        return x;
+    }
+
+    public float v0() {
+        return y;
+    }
+
+    public float u1() {
+        return width;
+    }
+
+    public float v1() {
+        return height;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/SpriteHelper.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/SpriteHelper.java
new file mode 100644
index 00000000000..02cc6b47a28
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/SpriteHelper.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.MissingTextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.core.Direction;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.inventory.InventoryMenu;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.client.model.data.ModelData;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class SpriteHelper {
+
+    public static TextureAtlasSprite getSpriteOfBlockState(BlockState blockState, Direction facing) {
+        BakedModel model = Minecraft.getInstance().getBlockRenderer().getBlockModel(blockState);
+        return getBestTexture(model, blockState, facing);
+    }
+
+    public static List<BakedQuad> getQuadsOfBlockState(BlockState blockState, Direction facing) {
+        return Minecraft.getInstance().getBlockRenderer()
+                .getBlockModel(blockState).getQuads(blockState, facing, RandomSource.create(), ModelData.EMPTY, null);
+    }
+
+    public static TextureAtlasSprite getBestTexture(BakedModel model, @Nullable BlockState blockState,
+                                                    @Nullable Direction facing) {
+        List<BakedQuad> quads = model.getQuads(blockState, facing, RandomSource.create(), ModelData.EMPTY, null);
+        if (quads.isEmpty()) {
+            return Minecraft.getInstance().getTextureAtlas(InventoryMenu.BLOCK_ATLAS)
+                    .apply(MissingTextureAtlasSprite.getLocation());
+        } else {
+            return quads.get(0).getSprite();
+        }
+    }
+
+    public static TextureAtlasSprite getSpriteOfItem(ItemStack item) {
+        BakedModel model = Minecraft.getInstance().getItemRenderer().getModel(item, null, null, 0);
+        return getBestTexture(model, null, null);
+    }
+
+    public static List<BakedQuad> getQuadsOfItem(ItemStack item) {
+        return Minecraft.getInstance().getItemRenderer().getModel(item, null, null, 0)
+                .getQuads(null, null, RandomSource.create(), ModelData.EMPTY, null);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Stencil.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Stencil.java
new file mode 100644
index 00000000000..223ac7a51f3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/Stencil.java
@@ -0,0 +1,179 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.ShaderInstance;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Matrix4f;
+import org.lwjgl.opengl.GL11;
+
+/**
+ * A util class for stencil stack used as a scissor stack. The reason for using stencils over scissors is that scissors
+ * can not have transformation applied and therefore don't work with 3D holo UI's.
+ */
+public class Stencil {
+
+    // Stores a stack of areas that are transformed, so it represents the actual area
+    private static final ObjectArrayList<Area> stencils = new ObjectArrayList<>();
+    // Stores a stack of stencilShapes which is used to mark and remove the stencil shape area
+    private static final ObjectArrayList<Runnable> stencilShapes = new ObjectArrayList<>();
+    // the current highest stencil value
+    private static int stencilValue = 0;
+
+    private final GuiContext context;
+
+    @ApiStatus.Internal
+    public Stencil(GuiContext context) {
+        this.context = context;
+    }
+
+    /**
+     * Resets all stencil values
+     */
+    public static void reset() {
+        RenderSystem.assertOnRenderThread();
+        stencils.clear();
+        stencilShapes.clear();
+        stencilValue = 0;
+        RenderSystem.stencilMask(0xFF);
+        RenderSystem.clearStencil(0);
+        RenderSystem.clear(GL11.GL_STENCIL_BUFFER_BIT, Minecraft.ON_OSX);
+        RenderSystem.stencilFunc(GL11.GL_ALWAYS, 0, 0xFF);
+        RenderSystem.stencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_KEEP);
+        RenderSystem.stencilMask(0x00);
+    }
+
+    public void push(@NotNull Rectangle area) {
+        push(area.x, area.y, area.width, area.height);
+    }
+
+    public void pushAtZero(@NotNull Rectangle area) {
+        push(0, 0, area.width, area.height);
+    }
+
+    /**
+     * Scissor a transformed part of the screen. OpenGL's transformations do effect these values. If the context is not
+     * null, it's viewport
+     * transformations are applied to the area that will be stored in the stack, but not to the actual stencil.
+     */
+    public void push(int x, int y, int w, int h) {
+        push(() -> drawRectangleStencilShape(context.getGraphics(), x, y, w, h), x, y, w, h);
+    }
+
+    // should not be used inside GUI'S
+    public void push(Runnable stencilShape, boolean hideStencilShape) {
+        push(stencilShape, 0, 0, 0, 0, hideStencilShape);
+    }
+
+    public void push(Runnable stencilShape, int x, int y, int w, int h) {
+        push(stencilShape, x, y, w, h, true);
+    }
+
+    public void push(Runnable stencilShape, int x, int y, int w, int h, boolean hideStencilShape) {
+        RenderSystem.assertOnRenderThread();
+        Area scissor = new Area(x, y, w, h);
+        scissor.transformAndRectanglerize(this.context);
+        if (!stencils.isEmpty()) {
+            stencils.top().clamp(scissor);
+        }
+        applyShape(stencilShape, hideStencilShape);
+        stencils.add(scissor);
+        stencilShapes.add(stencilShape);
+    }
+
+    private void applyShape(Runnable stencilShape, boolean hideStencilShape) {
+        // TODO: figure out exactly what this does, why its needed and why it sometimes causes issues
+        this.context.getGraphics().flush();
+        // increase stencil values in the area
+        GL11.glEnable(GL11.GL_STENCIL_TEST);
+        setStencilValue(stencilShape, stencilValue, false, hideStencilShape);
+        stencilValue++;
+        RenderSystem.stencilFunc(GL11.GL_LEQUAL, stencilValue, 0xFF);
+        RenderSystem.stencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_KEEP);
+        RenderSystem.stencilMask(0x00);
+        this.context.getGraphics().flush();
+    }
+
+    private void setStencilValue(Runnable stencilShape, int stencilValue, boolean remove, boolean hideStencilShape) {
+        // Set stencil func
+        int mode = remove ? GL11.GL_DECR : GL11.GL_INCR;
+        RenderSystem.stencilFunc(GL11.GL_EQUAL, stencilValue, 0xFF);
+        RenderSystem.stencilOp(GL11.GL_KEEP, mode, mode);
+        RenderSystem.stencilMask(0xFF);
+
+        if (hideStencilShape) {
+            // disable colors and depth
+            RenderSystem.colorMask(false, false, false, false);
+            RenderSystem.depthMask(false);
+        }
+        stencilShape.run();
+        if (hideStencilShape) {
+            // Re-enable drawing to color buffer + depth buffer
+            RenderSystem.colorMask(true, true, true, true);
+            RenderSystem.depthMask(true);
+        }
+    }
+
+    private static void drawRectangleStencilShape(GuiGraphics graphics, int x, int y, int w, int h) {
+        RenderSystem.disableDepthTest();
+        RenderSystem.enableBlend();
+        ShaderInstance lastShader = RenderSystem.getShader();
+        RenderSystem.setShader(GameRenderer::getPositionShader);
+        Matrix4f pose = graphics.pose().last().pose();
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder bufferbuilder = tesselator.getBuilder();
+        float x0 = x, x1 = x + w, y0 = y, y1 = y + h;
+        bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION);
+        bufferbuilder.vertex(pose, x0, y0, 0.0f).endVertex();
+        bufferbuilder.vertex(pose, x0, y1, 0.0f).endVertex();
+        bufferbuilder.vertex(pose, x1, y1, 0.0f).endVertex();
+        bufferbuilder.vertex(pose, x1, y0, 0.0f).endVertex();
+        tesselator.end();
+        RenderSystem.setShader(() -> lastShader);
+    }
+
+    /**
+     * Removes the top most stencil
+     */
+    public void pop() {
+        RenderSystem.assertOnRenderThread();
+        if (stencils.isEmpty()) {
+            throw new IllegalStateException("Tried to pop an empty stencil stack!");
+        }
+        stencils.pop();
+        Runnable stencilShape = stencilShapes.pop();
+        this.context.getGraphics().flush();
+        if (stencils.isEmpty()) {
+            reset();
+            GL11.glDisable(GL11.GL_STENCIL_TEST);
+            this.context.getGraphics().flush();
+            return;
+        }
+        setStencilValue(stencilShape, stencilValue, true, true);
+        stencilValue--;
+        RenderSystem.stencilFunc(GL11.GL_LEQUAL, stencilValue, 0xFF);
+        RenderSystem.stencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_KEEP);
+        RenderSystem.stencilMask(0x00);
+        this.context.getGraphics().flush();
+    }
+
+    public static boolean isInsideScissorArea(Area area, IViewportStack stack) {
+        if (stencils.isEmpty()) return true;
+        Area.SHARED.set(0, 0, area.width, area.height);
+        Area.SHARED.transformAndRectanglerize(stack);
+        return stencils.top().intersects(Area.SHARED);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/TooltipLines.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/TooltipLines.java
new file mode 100644
index 00000000000..00043c45659
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/TooltipLines.java
@@ -0,0 +1,144 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.text.FontRenderHelper;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextIcon;
+
+import net.minecraft.network.chat.FormattedText;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TooltipLines extends AbstractList<FormattedText> {
+
+    private final List<Object> elements;
+    private final List<Line> lines = new ArrayList<>(8);
+    private int lastElementIndex = 0;
+
+    public TooltipLines(List<Object> elements) {
+        this.elements = elements;
+    }
+
+    public void clearCache() {
+        this.lines.clear();
+        this.lastElementIndex = 0;
+    }
+
+    private void buildUntil(int index) {
+        while (index >= lines.size()) {
+            Line line = parseNext();
+            if (line == null) break;
+            lines.add(line);
+        }
+    }
+
+    private Line parseNext() {
+        if (this.lastElementIndex >= elements.size()) return null;
+        FormattedText currentLine = FormattedText.EMPTY;
+        int currentLength = 0;
+        for (int i = this.lastElementIndex; i < this.elements.size(); i++) {
+            Object o = elements.get(i);
+            currentLength++;
+            if (o == IKey.LINE_FEED) {
+                Line line = new Line(currentLine, this.lastElementIndex, currentLength);
+                this.lastElementIndex += currentLength;
+                return line;
+            }
+            FormattedText s = null;
+            if (o instanceof FormattedText txt) {
+                s = txt;
+            } else if (o instanceof String str) {
+                s = FormattedText.of(str);
+            } else if (o instanceof IKey key) {
+                s = key.get();
+            } else if (o instanceof TextIcon ti) {
+                s = ti.getText();
+            }
+            if (s != null) {
+                currentLine = FontRenderHelper.isEmpty(currentLine) ? s : FormattedText.composite(currentLine, s);
+            }
+        }
+        if (currentLength > 0) {
+            Line line = new Line(currentLine, this.lastElementIndex, currentLength);
+            this.lastElementIndex += currentLength;
+            return line;
+        }
+        return null;
+    }
+
+    @Override
+    public FormattedText get(int index) {
+        buildUntil(index);
+        return lines.get(index).text;
+    }
+
+    @Override
+    public int size() {
+        buildUntil(Integer.MAX_VALUE);
+        return lines.size();
+    }
+
+    @Override
+    public FormattedText remove(int index) {
+        buildUntil(index);
+        Line line = lines.remove(index);
+
+        if (line.length == 1) {
+            this.elements.remove(line.index);
+        } else {
+            this.elements.subList(line.index, line.index + line.length).clear();
+        }
+        for (int i = index; i < lines.size(); i++) {
+            lines.get(i).index -= line.length;
+        }
+        this.lastElementIndex -= line.length;
+
+        return line.text;
+    }
+
+    @Override
+    public void add(int index, FormattedText s) {
+        buildUntil(index);
+        int elementIndex = index >= this.lines.size() ? this.lastElementIndex : this.lines.get(index).index;
+        lines.add(index, new Line(s, elementIndex, 1));
+        for (int i = index + 1; i < this.lines.size(); i++) {
+            lines.get(i).index++;
+        }
+        this.elements.add(elementIndex, s);
+        this.lastElementIndex++;
+    }
+
+    @Override
+    public FormattedText set(int index, FormattedText element) {
+        Line line = lines.get(index);
+        if (line.length == 1) {
+            this.elements.set(line.index, element);
+            this.lines.set(index, new Line(element, line.index, line.length));
+        } else {
+            remove(index);
+            add(index, element);
+        }
+        return line.text;
+    }
+
+    @Override
+    public void clear() {
+        this.elements.clear();
+        this.lines.clear();
+        this.lastElementIndex = 0;
+    }
+
+    private static class Line {
+
+        private final FormattedText text;
+        private final int length;
+        private int index;
+
+        private Line(FormattedText text, int index, int length) {
+            this.text = text;
+            this.index = index;
+            this.length = length;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/utils/TreeUtil.java b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/TreeUtil.java
new file mode 100644
index 00000000000..6298c6686da
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/utils/TreeUtil.java
@@ -0,0 +1,525 @@
+package com.gregtechceu.gtceu.api.mui.utils;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.ITreeNode;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.ResizeNode;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+
+import com.google.common.collect.AbstractIterator;
+import com.google.common.collect.Streams;
+import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+public class TreeUtil {
+
+    public static boolean allowUnicode = true;
+
+    private static final String U_T = "✓";
+    private static final String U_F = "✘";
+    private static final String T = "T";
+    private static final String F = "F";
+    private static final String U_PIPE = "│";
+    private static final String U_PIPE_MID = "├";
+    private static final String U_PIPE_END = "└";
+    private static final String PIPE = "|";
+    private static final String PIPE_MID = "+";
+    private static final String PIPE_END = "-";
+
+    public static final NodeInfo<ResizeNode> RESIZE_NODE_INFO_FULLY_RESIZED = (root, node, builder) -> builder
+            .append("Fully resized: ")
+            .append(str(node.isFullyCalculated(node.hasParent() && node.getParent().isLayout())));
+    public static final NodeInfo<ResizeNode> RESIZE_NODE_INFO_RESIZED_DETAILED = (root, node, builder) -> {
+        builder.append("XYWH: ")
+                .append(str(node.isXCalculated()))
+                .append(str(node.isYCalculated()))
+                .append(str(node.isWidthCalculated()))
+                .append(str(node.isHeightCalculated()))
+                .append(", Children resized: ").append(str(node.areChildrenCalculated()))
+                .append(", Self layout done: ").append(str(node.isLayoutDone()))
+                .append(", Parent layout done: ")
+                .append(str(!node.canRelayout(node.hasParent() && node.getParent().isLayout())));
+        /*
+         * if (!self) {
+         * builder.append(", Self detail: (");
+         * RESIZE_NODE_INFO_SELF_RESIZED_DETAIL.addInfo(root, node, builder);
+         * builder.append(")");
+         * }
+         */
+    };
+    public static final NodeInfo<ResizeNode> RESIZE_NODE_INFO_RESIZED_COLLAPSED = (root, node, builder) -> {
+        if (node.isFullyCalculated(node.hasParent() && node.getParent().isLayout())) {
+            RESIZE_NODE_INFO_FULLY_RESIZED.addInfo(root, node, builder);
+        } else {
+            RESIZE_NODE_INFO_RESIZED_DETAILED.addInfo(root, node, builder);
+        }
+    };
+
+    private static String str(boolean b) {
+        if (TreeUtil.allowUnicode) return b ? U_T : U_F;
+        return b ? T : F;
+    }
+
+    public static <T extends ITreeNode<T>> boolean foreachChildBFS(T parent, Predicate<T> consumer) {
+        return foreachChildBFS(parent, consumer, false);
+    }
+
+    /**
+     * Iterates through the whole sub widget tree by using breath-first-search.
+     * <p>
+     * This method delivers good performance and can outperform {@link #foreachChild(T, Predicate, boolean)} in certain
+     * small widget
+     * trees.
+     *
+     * @param parent      starting point
+     * @param consumer    Operation on each child. Return false to terminate the iteration.
+     * @param includeSelf true if the consumer should also consume the parent
+     * @return true if the iteration was not terminated by the consumer
+     */
+    public static <T extends ITreeNode<T>> boolean foreachChildBFS(T parent, Predicate<T> consumer,
+                                                                   boolean includeSelf) {
+        if (includeSelf && !consumer.test(parent)) return false;
+        ObjectList<T> parents = ObjectList.create();
+        parents.add(parent);
+        while (!parents.isEmpty()) {
+            for (T child : parents.removeFirst().getChildren()) {
+                if (child.hasChildren()) {
+                    parents.addLast(child);
+                }
+                if (!consumer.test(child)) return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @see #foreachChild(T, Predicate, boolean)
+     */
+    public static <T extends ITreeNode<T>> boolean foreachChild(T parent, Predicate<T> consumer) {
+        return foreachChild(parent, consumer, false);
+    }
+
+    /**
+     * Iterates through the whole sub widget tree recursively.
+     * <p>
+     * This method has the best performance in most cases, but can be outperformed on certain small widget trees.
+     *
+     * @param parent      starting point
+     * @param consumer    Operation on each child. Return false to terminate the iteration.
+     * @param includeSelf true if the consumer should also consume the parent
+     * @return true if the iteration was not terminated by the consumer
+     */
+    public static <T extends ITreeNode<T>> boolean foreachChild(T parent, Predicate<T> consumer, boolean includeSelf) {
+        if (includeSelf && !consumer.test(parent)) return false;
+        if (!parent.hasChildren()) return true;
+        for (T widget : parent.getChildren()) {
+            if (!consumer.test(widget)) return false;
+            if (widget.hasChildren() && !foreachChild(widget, consumer, false)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Iterates through the whole sub widget tree recursively. Unlike {@link #foreachChild(T, Predicate, boolean)},
+     * which can only
+     * return a boolean, this method can return any type. Once the consumer returns a non-null value, the iteration is
+     * terminated and the
+     * value will be returned.
+     *
+     * @param parent      starting point
+     * @param consumer    Operation on each child. Return a non-null value to terminate the iteration and to return the
+     *                    value.
+     * @param includeSelf true if the consumer should also consume the parent
+     * @return the first resulting value of the consumer or null of it always returned null
+     */
+    public static <T extends ITreeNode<T>, V> @Nullable V foreachChildWithResult(T parent, Function<T, V> consumer,
+                                                                                 boolean includeSelf) {
+        if (includeSelf) {
+            V t = consumer.apply(parent);
+            if (t != null) return t;
+        }
+        if (!parent.hasChildren()) return null;
+        for (T widget : parent.getChildren()) {
+            V t = consumer.apply(widget);
+            if (t != null) return t;
+            if (widget.hasChildren()) {
+                t = foreachChildWithResult(widget, consumer, false);
+                if (t != null) return t;
+            }
+        }
+        return null;
+    }
+
+    public static <T extends ITreeNode<T>> boolean foreachChildReverse(T parent, Predicate<T> consumer,
+                                                                       boolean includeSelf) {
+        if (parent.getChildren().isEmpty()) {
+            return !includeSelf || consumer.test(parent);
+        }
+        for (T widget : parent.getChildren()) {
+            if (!widget.getChildren().isEmpty() && foreachChildReverse(widget, consumer, false)) {
+                return false;
+            }
+            if (!consumer.test(widget)) return false;
+        }
+        return !includeSelf || consumer.test(parent);
+    }
+
+    /**
+     * Creates a flat stream of the whole sub widget tree.
+     * <p>
+     * {@link Stream#forEach(Consumer)} on this has slightly worse performance than
+     * {@link #foreachChildBFS(T, Predicate, boolean)} on
+     * small widget trees and has similar performance on large widget trees. The performance is significantly better
+     * than
+     * {@link #iteratorBFS(T)} even though this method uses it.
+     *
+     * @param parent starting point.
+     * @return stream of the sub widget tree
+     */
+    @SuppressWarnings("UnstableApiUsage")
+    public static <T extends ITreeNode<T>> Stream<T> flatStreamBFS(T parent) {
+        if (!parent.hasChildren()) return Stream.of(parent);
+        return Streams.stream(iteratorBFS(parent));
+    }
+
+    public static <T extends ITreeNode<T>> @UnmodifiableView Iterable<T> iterableBFS(T parent) {
+        return () -> iteratorBFS(parent);
+    }
+
+    /**
+     * Creates an unmodifiable iterator of the whole sub widget tree.
+     * <p>
+     * This method of iterating has the worst performance in every case. It's roughly 4 times worse than
+     * {@link #foreachChildBFS(T, Predicate, boolean)}. If not used extensively the performance is still nothing to
+     * worry about.
+     *
+     * @param parent starting point
+     * @return an unmodifiable iterator of the sub widget tree
+     */
+    public static <T extends ITreeNode<T>> @UnmodifiableView Iterator<T> iteratorBFS(T parent) {
+        return new AbstractIterator<>() {
+
+            private final ObjectList<T> queue = ObjectList.create();
+            private Iterator<T> currentIt;
+
+            @Override
+            protected T computeNext() {
+                if (currentIt == null) {
+                    currentIt = parent.getChildren().iterator();
+                    return parent;
+                }
+                if (currentIt.hasNext()) return handleWidget(currentIt.next());
+                while (!queue.isEmpty()) {
+                    currentIt = queue.removeFirst().getChildren().iterator();
+                    if (currentIt.hasNext()) return handleWidget(currentIt.next());
+                }
+                return endOfData();
+            }
+
+            private T handleWidget(T widget) {
+                if (widget.hasChildren()) {
+                    queue.add(widget);
+                }
+                return widget;
+            }
+        };
+    }
+
+    /**
+     * Finds all children in the sub widget tree which match the test and puts them in a list.
+     *
+     * @param parent starting point
+     * @param test   test which the target children have to pass
+     * @return a list of matching children
+     */
+    public static <T extends ITreeNode<T>> List<T> flatList(T parent, Predicate<T> test) {
+        List<T> widgets = new ArrayList<>();
+        foreachChild(parent, w -> {
+            if (test.test(w)) widgets.add(w);
+            return true;
+        }, true);
+        return widgets;
+    }
+
+    /**
+     * Finds all children in the sub widget tree which match the test and puts them in a list.
+     *
+     * @param parent starting point
+     * @param test   test which the target children have to pass
+     * @return a list of matching children
+     */
+    public static <T extends ITreeNode<T>> List<T> flatListBFS(T parent, Predicate<T> test) {
+        List<T> widgets = new ArrayList<>();
+        foreachChildBFS(parent, w -> {
+            if (test.test(w)) widgets.add(w);
+            return true;
+        }, true);
+        return widgets;
+    }
+
+    public static <T extends ITreeNode<T>, R extends ITreeNode<T>> List<R> flatListByType(T parent, Class<R> type) {
+        return flatListByType(parent, type, null);
+    }
+
+    /**
+     * Finds all widgets in the sub widget tree which match the given type and additional test.
+     *
+     * @param parent starting point
+     * @param type   type of the target widgets
+     * @param test   test which the target widgets have to pass
+     * @param <T>    type of the target widgets
+     * @return a list of matching widgets
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends ITreeNode<T>, R extends ITreeNode<T>> List<R> flatListByType(T parent, Class<R> type,
+                                                                                          @Nullable Predicate<R> test) {
+        List<R> widgets = new ArrayList<>();
+        foreachChild(parent, w -> {
+            if (type.isAssignableFrom(w.getClass())) {
+                if (test == null || test.test((R) w)) widgets.add((R) w);
+            }
+            return true;
+        }, true);
+        return widgets;
+    }
+
+    /**
+     * Finds the first widget in the sub widget tree, for which the test returns true.
+     *
+     * @param parent starting point
+     * @param test   test which the widget has to pass
+     * @return the first matching widget
+     */
+    public static <T extends ITreeNode<T>> T findFirst(T parent, @NotNull Predicate<T> test) {
+        return foreachChildWithResult(parent, w -> {
+            if (test.test(w)) {
+                return w;
+            }
+            return null;
+        }, true);
+    }
+
+    /**
+     * Finds the first widget in the sub widget tree with the given type, for which the test returns true.
+     *
+     * @param parent starting point
+     * @param type   type of the target widget
+     * @param test   test which the widget has to pass
+     * @return the first matching widget
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends ITreeNode<T>, R extends ITreeNode<T>> R findFirst(T parent, Class<R> type,
+                                                                               @Nullable Predicate<R> test) {
+        return foreachChildWithResult(parent, t -> {
+            if (type.isAssignableFrom(t.getClass())) {
+                if (test == null || test.test((R) t)) {
+                    return (R) t;
+                }
+            }
+            return null;
+        }, true);
+    }
+
+    public static <T extends ITreeNode<T>> T findParent(T parent, Predicate<T> filter) {
+        if (parent == null) return null;
+        while (!(parent instanceof ModularPanel)) {
+            if (filter.test(parent)) {
+                return parent;
+            }
+            parent = parent.getParent();
+        }
+        return filter.test(parent) ? parent : null;
+    }
+
+    public static <T extends ITreeNode<T>, R extends ITreeNode<T>> R findParent(T parent, Class<R> type) {
+        return findParent(parent, type, null);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T extends ITreeNode<T>, R extends ITreeNode<T>> R findParent(T parent, Class<R> type,
+                                                                                @Nullable Predicate<R> test) {
+        if (parent == null) return null;
+        while (!(parent instanceof ModularPanel)) {
+            if (type.isAssignableFrom(parent.getClass()) && (test == null || test.test((R) parent))) {
+                return (R) parent;
+            }
+            parent = parent.getParent();
+        }
+        return type.isAssignableFrom(parent.getClass()) && (test == null || test.test((R) parent)) ? (R) parent : null;
+    }
+
+    /**
+     * Prints the whole sub widget tree to the log as a human-readable tree graph with Unicode characters. You may need
+     * to enabled Unicode
+     * characters in your IDE terminal to display them properly.
+     *
+     * @param parent starting point
+     */
+    public static <T extends ITreeNode<T>> void print(T parent) {
+        print(parent, w -> true, null);
+    }
+
+    /**
+     * Prints the whole sub widget tree to the log as a human-readable tree graph with Unicode characters. You may need
+     * to enabled Unicode
+     * characters in your IDE terminal to display them properly.
+     *
+     * @param parent         starting point
+     * @param additionalInfo additional info function which is executed for each widget
+     */
+    public static <T extends ITreeNode<T>> void print(T parent, NodeInfo<T> additionalInfo) {
+        print(parent, w -> true, additionalInfo);
+    }
+
+    /**
+     * Prints the whole sub widget tree to the log as a human-readable tree graph with Unicode characters. You may need
+     * to enabled Unicode
+     * characters in your IDE terminal to display them properly.
+     *
+     * @param parent starting point
+     * @param test   test widgets have to pass to be added to the string builder
+     */
+    public static <T extends ITreeNode<T>> void print(T parent, Predicate<T> test) {
+        print(parent, test, null);
+    }
+
+    /**
+     * Prints the whole sub widget tree to the log as a human-readable tree graph with Unicode characters. You may need
+     * to enabled Unicode
+     * characters in your IDE terminal to display them properly.
+     *
+     * @param parent         starting point
+     * @param test           test widgets have to pass to be added to the string builder
+     * @param additionalInfo additional info function which is executed for each widget
+     */
+    public static <T extends ITreeNode<T>> void print(T parent, Predicate<T> test, NodeInfo<T> additionalInfo) {
+        StringBuilder builder = new StringBuilder();
+        if (parent instanceof IWidget) builder.append("Widget");
+        else if (parent instanceof ResizeNode) builder.append("ResizeNode");
+        else builder.append(parent.getClass());
+        builder.append(" tree of ").append(parent).append('\n');
+        GTCEu.LOGGER.info(toString(builder, parent, test, additionalInfo));
+    }
+
+    public static <T extends ITreeNode<T>> String toString(T parent) {
+        return toString(parent, w -> true, null);
+    }
+
+    public static <T extends ITreeNode<T>> String toString(T parent, NodeInfo<T> additionalInfo) {
+        return toString(parent, w -> true, additionalInfo);
+    }
+
+    public static <T extends ITreeNode<T>> String toString(T parent, Predicate<T> test) {
+        return toString(parent, test, null);
+    }
+
+    public static <T extends ITreeNode<T>> String toString(T parent, Predicate<T> test, NodeInfo<T> additionalInfo) {
+        return toString(null, parent, test, additionalInfo).toString();
+    }
+
+    /**
+     * Writes the sub widget tree into a human-readable tree graph with Unicode characters.
+     *
+     * @param builder        the string builder to add the tree to or null for a new builder
+     * @param parent         starting point
+     * @param test           test widgets have to pass to be added to the string builder
+     * @param additionalInfo additional info function which is executed for each widget
+     * @return the string builder which was used to build the graph
+     */
+    public static <T extends ITreeNode<T>> StringBuilder toString(StringBuilder builder, T parent, Predicate<T> test,
+                                                                  NodeInfo<T> additionalInfo) {
+        if (builder == null) builder = new StringBuilder();
+        getTree(parent, parent, test, builder, additionalInfo, "", false, null);
+        return builder;
+    }
+
+    protected static <T extends ITreeNode<T>> void getTree(T root, T parent, Predicate<T> test, StringBuilder builder,
+                                                           NodeInfo<T> additionalInfo, String indent,
+                                                           boolean hasNextSibling, Set<T> visited) {
+        if (!indent.isEmpty()) {
+            builder.append(indent);
+            if (TreeUtil.allowUnicode) {
+                builder.append(hasNextSibling ? U_PIPE_MID : U_PIPE_END);
+            } else {
+                builder.append(hasNextSibling ? PIPE_MID : PIPE_END);
+            }
+            builder.append(' ');
+        }
+        if (visited == null) visited = new ReferenceOpenHashSet<>();
+        if (visited.contains(parent)) {
+            builder.append("CYCLING TREE FOUND (").append(parent).append(")\n");
+            return;
+        }
+        visited.add(parent);
+        builder.append(parent);
+        if (additionalInfo != null) {
+            builder.append(" {");
+            additionalInfo.addInfo(root, parent, builder);
+            builder.append("}");
+        }
+        builder.append('\n');
+        if (parent.hasChildren()) {
+            List<T> children = parent.getChildren();
+            for (int i = 0; i < children.size(); i++) {
+                T child = children.get(i);
+                if (test.test(child)) {
+                    String nextIndent = indent;
+                    if (hasNextSibling) {
+                        nextIndent += (TreeUtil.allowUnicode ? U_PIPE : PIPE) + ' ';
+                    } else {
+                        nextIndent += "  ";
+                    }
+                    getTree(root, child, test, builder, additionalInfo, nextIndent, i < children.size() - 1, visited);
+                }
+            }
+        }
+    }
+
+    public interface NodeInfo<T extends ITreeNode<T>> {
+
+        void addInfo(T root, T widget, StringBuilder builder);
+
+        default NodeInfo<T> combine(NodeInfo<T> other, String joiner) {
+            return (root, widget, builder) -> {
+                addInfo(root, widget, builder);
+                builder.append(joiner);
+                other.addInfo(root, widget, builder);
+            };
+        }
+
+        default NodeInfo<T> combine(NodeInfo<T> other) {
+            return combine(other, " | ");
+        }
+
+        @SafeVarargs
+        static <T extends ITreeNode<T>> NodeInfo<T> of(String joiner, NodeInfo<T>... infos) {
+            return (root, widget, builder) -> {
+                for (int i = 0; i < infos.length; i++) {
+                    NodeInfo<T> info = infos[i];
+                    info.addInfo(root, widget, builder);
+                    if (i < infos.length - 1) {
+                        builder.append(joiner);
+                    }
+                }
+            };
+        }
+
+        @SafeVarargs
+        static <T extends ITreeNode<T>> NodeInfo<T> of(NodeInfo<T>... infos) {
+            return of(" | ", infos);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/BinaryEnumValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/BinaryEnumValue.java
new file mode 100644
index 00000000000..4ac15634e99
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/BinaryEnumValue.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IBoolValue;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * Accepts enums which have exactly two elements. Can act as {@link IBoolValue}.
+ */
+public class BinaryEnumValue<T extends Enum<T>> extends EnumValue<T> implements IBoolValue<T> {
+
+    public static <T extends Enum<T>, V extends EnumValue<T> & IBoolValue<T>> Dynamic<T> wrap(V val) {
+        return new Dynamic<>(val.getEnumClass(), val::getValue, val::setValue);
+    }
+
+    public BinaryEnumValue(Class<T> enumClass, T value) {
+        super(enumClass, value);
+        if (enumClass.getEnumConstants().length != 2) {
+            throw new IllegalArgumentException("Enum class must have exactly two elements");
+        }
+    }
+
+    @Override
+    public boolean getBoolValue() {
+        return this.value.ordinal() == 1;
+    }
+
+    @Override
+    public void setBoolValue(boolean val) {
+        setValue(this.enumClass.getEnumConstants()[val ? 1 : 0]);
+    }
+
+    public static class Dynamic<T extends Enum<T>> extends EnumValue.Dynamic<T> implements IBoolValue<T> {
+
+        public Dynamic(Class<T> enumClass, Supplier<T> getter, Consumer<T> setter) {
+            super(enumClass, getter, setter);
+        }
+
+        @Override
+        public boolean getBoolValue() {
+            return getValue().ordinal() == 1;
+        }
+
+        @Override
+        public void setBoolValue(boolean val) {
+            setValue(this.enumClass.getEnumConstants()[val ? 1 : 0]);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/BoolValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/BoolValue.java
new file mode 100644
index 00000000000..6e61a7c0b0f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/BoolValue.java
@@ -0,0 +1,118 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IBoolValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+
+import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BooleanSupplier;
+
+public class BoolValue implements IBoolValue<Boolean>, IStringValue<Boolean> {
+
+    public static Dynamic wrap(IBoolValue<?> val) {
+        return new Dynamic(val::getBoolValue, val::setBoolValue);
+    }
+
+    public static Dynamic wrapAtomic(AtomicBoolean val) {
+        return new Dynamic(val::get, val::set);
+    }
+
+    private boolean value;
+
+    public BoolValue(boolean value) {
+        this.value = value;
+    }
+
+    @Override
+    public Boolean getValue() {
+        return getBoolValue();
+    }
+
+    @Override
+    public void setValue(Boolean value) {
+        setBoolValue(value);
+    }
+
+    @Override
+    public boolean getBoolValue() {
+        return this.value;
+    }
+
+    @Override
+    public void setBoolValue(boolean val) {
+        this.value = val;
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.value);
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setBoolValue(Boolean.parseBoolean(val));
+    }
+
+    @Override
+    public Class<Boolean> getValueType() {
+        return Boolean.class;
+    }
+
+    public static class Dynamic implements IBoolValue<Boolean>, IIntValue<Boolean>, IStringValue<Boolean> {
+
+        private final BooleanSupplier getter;
+        private final BooleanConsumer setter;
+
+        public Dynamic(BooleanSupplier getter, BooleanConsumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public boolean getBoolValue() {
+            return this.getter.getAsBoolean();
+        }
+
+        @Override
+        public void setBoolValue(boolean val) {
+            this.setter.accept(val);
+        }
+
+        @Override
+        public String getStringValue() {
+            return String.valueOf(getBoolValue());
+        }
+
+        @Override
+        public void setStringValue(String val) {
+            setBoolValue(Boolean.parseBoolean(val));
+        }
+
+        @Override
+        public Boolean getValue() {
+            return getBoolValue();
+        }
+
+        @Override
+        public void setValue(Boolean value) {
+            setBoolValue(value);
+        }
+
+        @Override
+        public int getIntValue() {
+            return getBoolValue() ? 1 : 0;
+        }
+
+        @Override
+        public void setIntValue(int val) {
+            setBoolValue(val == 1);
+        }
+
+        @Override
+        public Class<Boolean> getValueType() {
+            return Boolean.class;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/ByteValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/ByteValue.java
new file mode 100644
index 00000000000..7975d4d822f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/ByteValue.java
@@ -0,0 +1,68 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IByteValue;
+
+public class ByteValue implements IByteValue<Byte> {
+
+    public static Dynamic wrap(IByteValue<Byte> val) {
+        return new Dynamic(val::getByteValue, val::setByteValue);
+    }
+
+    protected byte value;
+
+    @Override
+    public void setByteValue(byte b) {
+        value = b;
+    }
+
+    @Override
+    public byte getByteValue() {
+        return value;
+    }
+
+    @Override
+    public Byte getValue() {
+        return getByteValue();
+    }
+
+    @Override
+    public void setValue(Byte value) {
+        setByteValue(value);
+    }
+
+    @Override
+    public Class<Byte> getValueType() {
+        return Byte.class;
+    }
+
+    public static class Dynamic extends ByteValue {
+
+        private final Supplier getter;
+        private final Consumer setter;
+
+        public Dynamic(Supplier getter, Consumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public void setByteValue(byte b) {
+            this.setter.setByte(b);
+        }
+
+        @Override
+        public byte getByteValue() {
+            return this.getter.getByte();
+        }
+    }
+
+    public interface Supplier {
+
+        byte getByte();
+    }
+
+    public interface Consumer {
+
+        void setByte(byte b);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/ConstValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/ConstValue.java
new file mode 100644
index 00000000000..f800dd17ae7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/ConstValue.java
@@ -0,0 +1,26 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @deprecated use {@link ObjectValue} instead
+ */
+@Deprecated
+public class ConstValue<T> implements IValue<T> {
+
+    @Getter
+    @Setter
+    protected T value;
+
+    public ConstValue(T value) {
+        this.value = value;
+    }
+
+    @Override
+    public Class<T> getValueType() {
+        return (Class<T>) value.getClass();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/DoubleValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/DoubleValue.java
new file mode 100644
index 00000000000..7b0f0c9402d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/DoubleValue.java
@@ -0,0 +1,118 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IDoubleValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IFloatValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+
+import com.google.common.util.concurrent.AtomicDouble;
+
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleSupplier;
+
+public class DoubleValue implements IDoubleValue<Double>, IFloatValue<Double>, IStringValue<Double> {
+
+    public static Dynamic wrap(IDoubleValue<?> val) {
+        return new Dynamic(val::getDoubleValue, val::setDoubleValue);
+    }
+
+    public static Dynamic wrapAtomic(AtomicDouble val) {
+        return new Dynamic(val::get, val::set);
+    }
+
+    private double value;
+
+    public DoubleValue(double value) {
+        this.value = value;
+    }
+
+    @Override
+    public Double getValue() {
+        return getDoubleValue();
+    }
+
+    @Override
+    public void setValue(Double value) {
+        setDoubleValue(value);
+    }
+
+    @Override
+    public double getDoubleValue() {
+        return this.value;
+    }
+
+    @Override
+    public void setDoubleValue(double val) {
+        this.value = val;
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.value);
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setDoubleValue(Double.parseDouble(val));
+    }
+
+    @Override
+    public float getFloatValue() {
+        return (float) getDoubleValue();
+    }
+
+    @Override
+    public void setFloatValue(float val) {
+        setDoubleValue(val);
+    }
+
+    @Override
+    public Class<Double> getValueType() {
+        return Double.class;
+    }
+
+    public static class Dynamic implements IDoubleValue<Double>, IStringValue<Double> {
+
+        private final DoubleSupplier getter;
+        private final DoubleConsumer setter;
+
+        public Dynamic(DoubleSupplier getter, DoubleConsumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public double getDoubleValue() {
+            return this.getter.getAsDouble();
+        }
+
+        @Override
+        public void setDoubleValue(double val) {
+            this.setter.accept(val);
+        }
+
+        @Override
+        public String getStringValue() {
+            return String.valueOf(getDoubleValue());
+        }
+
+        @Override
+        public void setStringValue(String val) {
+            setDoubleValue(Double.parseDouble(val));
+        }
+
+        @Override
+        public Double getValue() {
+            return getDoubleValue();
+        }
+
+        @Override
+        public void setValue(Double value) {
+            setDoubleValue(value);
+        }
+
+        @Override
+        public Class<Double> getValueType() {
+            return Double.class;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/DynamicValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/DynamicValue.java
new file mode 100644
index 00000000000..8d761f92a91
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/DynamicValue.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * @deprecated use {@link ObjectValue.Dynamic} instead
+ */
+@Deprecated
+public class DynamicValue<T> implements IValue<T> {
+
+    private final Supplier<T> getter;
+    @Nullable
+    private final Consumer<T> setter;
+
+    public DynamicValue(Supplier<T> getter, @Nullable Consumer<T> setter) {
+        this.getter = getter;
+        this.setter = setter;
+    }
+
+    @Override
+    public T getValue() {
+        return this.getter.get();
+    }
+
+    @Override
+    public void setValue(T value) {
+        if (this.setter != null) {
+            this.setter.accept(value);
+        }
+    }
+
+    @Override
+    public Class<T> getValueType() {
+        return (Class<T>) this.getter.get().getClass();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/EnumValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/EnumValue.java
new file mode 100644
index 00000000000..4dbd5e3fc0b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/EnumValue.java
@@ -0,0 +1,82 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IEnumValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class EnumValue<T extends Enum<T>> implements IEnumValue<T>, IIntValue<T> {
+
+    public static <T extends Enum<T>> Dynamic<T> wrap(IEnumValue<T> val) {
+        return new Dynamic<>(val.getEnumClass(), val::getValue, val::setValue);
+    }
+
+    @Getter
+    protected final Class<T> enumClass;
+    @Getter
+    @Setter
+    protected T value;
+
+    public EnumValue(Class<T> enumClass, T value) {
+        this.enumClass = enumClass;
+        this.value = value;
+    }
+
+    @Override
+    public int getIntValue() {
+        return this.value.ordinal();
+    }
+
+    @Override
+    public void setIntValue(int val) {
+        setValue(this.enumClass.getEnumConstants()[val]);
+    }
+
+    @Override
+    public Class<T> getValueType() {
+        return this.enumClass;
+    }
+
+    public static class Dynamic<T extends Enum<T>> implements IEnumValue<T>, IIntValue<T> {
+
+        @Getter
+        protected final Class<T> enumClass;
+        protected final Supplier<T> getter;
+        protected final Consumer<T> setter;
+
+        public Dynamic(Class<T> enumClass, Supplier<T> getter, Consumer<T> setter) {
+            this.enumClass = enumClass;
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public int getIntValue() {
+            return getValue().ordinal();
+        }
+
+        @Override
+        public void setIntValue(int val) {
+            setValue(this.enumClass.getEnumConstants()[val]);
+        }
+
+        @Override
+        public T getValue() {
+            return this.getter.get();
+        }
+
+        @Override
+        public void setValue(T value) {
+            this.setter.accept(value);
+        }
+
+        @Override
+        public Class<T> getValueType() {
+            return this.enumClass;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/FloatValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/FloatValue.java
new file mode 100644
index 00000000000..d4b2fa42553
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/FloatValue.java
@@ -0,0 +1,127 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IDoubleValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IFloatValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+import com.gregtechceu.gtceu.utils.FloatConsumer;
+import com.gregtechceu.gtceu.utils.FloatSupplier;
+
+import com.google.common.util.concurrent.AtomicDouble;
+
+public class FloatValue implements IFloatValue<Float>, IDoubleValue<Float>, IStringValue<Float> {
+
+    public static Dynamic wrap(IFloatValue<?> val) {
+        return new Dynamic(val::getFloatValue, val::setFloatValue);
+    }
+
+    public static Dynamic wrapAtomic(AtomicDouble val) {
+        return new Dynamic(val::floatValue, val::set);
+    }
+
+    private float value;
+
+    public FloatValue(float value) {
+        this.value = value;
+    }
+
+    @Override
+    public Float getValue() {
+        return getFloatValue();
+    }
+
+    @Override
+    public float getFloatValue() {
+        return value;
+    }
+
+    @Override
+    public void setFloatValue(float val) {
+        this.value = val;
+    }
+
+    @Override
+    public void setValue(Float value) {
+        setDoubleValue(value);
+    }
+
+    @Override
+    public double getDoubleValue() {
+        return getFloatValue();
+    }
+
+    @Override
+    public void setDoubleValue(double val) {
+        setFloatValue((float) val);
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(getFloatValue());
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setFloatValue(Float.parseFloat(val));
+    }
+
+    @Override
+    public Class<Float> getValueType() {
+        return Float.class;
+    }
+
+    public static class Dynamic implements IFloatValue<Float>, IDoubleValue<Float>, IStringValue<Float> {
+
+        private final FloatSupplier getter;
+        private final FloatConsumer setter;
+
+        public Dynamic(FloatSupplier getter, FloatConsumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public float getFloatValue() {
+            return this.getter.getAsFloat();
+        }
+
+        @Override
+        public void setFloatValue(float val) {
+            this.setter.accept(val);
+        }
+
+        @Override
+        public String getStringValue() {
+            return String.valueOf(getFloatValue());
+        }
+
+        @Override
+        public void setStringValue(String val) {
+            setDoubleValue(Double.parseDouble(val));
+        }
+
+        @Override
+        public Float getValue() {
+            return getFloatValue();
+        }
+
+        @Override
+        public void setValue(Float value) {
+            setFloatValue(value);
+        }
+
+        @Override
+        public double getDoubleValue() {
+            return getFloatValue();
+        }
+
+        @Override
+        public void setDoubleValue(double val) {
+            setFloatValue((float) val);
+        }
+
+        @Override
+        public Class<Float> getValueType() {
+            return Float.class;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/IntValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/IntValue.java
new file mode 100644
index 00000000000..ea047eeb909
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/IntValue.java
@@ -0,0 +1,117 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IDoubleValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntConsumer;
+import java.util.function.IntSupplier;
+
+public class IntValue implements IIntValue<Integer>, IDoubleValue<Integer>, IStringValue<Integer> {
+
+    public static Dynamic wrap(IIntValue<?> val) {
+        return new Dynamic(val::getIntValue, val::setIntValue);
+    }
+
+    public static Dynamic wrapAtomic(AtomicInteger val) {
+        return new Dynamic(val::get, val::set);
+    }
+
+    private int value;
+
+    public IntValue(int value) {
+        this.value = value;
+    }
+
+    @Override
+    public Integer getValue() {
+        return getIntValue();
+    }
+
+    @Override
+    public void setValue(Integer value) {
+        setIntValue(value);
+    }
+
+    @Override
+    public int getIntValue() {
+        return this.value;
+    }
+
+    @Override
+    public void setIntValue(int val) {
+        this.value = val;
+    }
+
+    @Override
+    public double getDoubleValue() {
+        return getIntValue();
+    }
+
+    @Override
+    public void setDoubleValue(double val) {
+        setIntValue((int) val);
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.value);
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setIntValue(Integer.parseInt(val));
+    }
+
+    @Override
+    public Class<Integer> getValueType() {
+        return Integer.class;
+    }
+
+    public static class Dynamic implements IIntValue<Integer>, IStringValue<Integer> {
+
+        private final IntSupplier getter;
+        private final IntConsumer setter;
+
+        public Dynamic(IntSupplier getter, IntConsumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public int getIntValue() {
+            return this.getter.getAsInt();
+        }
+
+        @Override
+        public void setIntValue(int val) {
+            this.setter.accept(val);
+        }
+
+        @Override
+        public String getStringValue() {
+            return String.valueOf(getIntValue());
+        }
+
+        @Override
+        public void setStringValue(String val) {
+            setIntValue(Integer.parseInt(val));
+        }
+
+        @Override
+        public Integer getValue() {
+            return getIntValue();
+        }
+
+        @Override
+        public void setValue(Integer value) {
+            setIntValue(value);
+        }
+
+        @Override
+        public Class<Integer> getValueType() {
+            return Integer.class;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/LongValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/LongValue.java
new file mode 100644
index 00000000000..a37e3f3ed2b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/LongValue.java
@@ -0,0 +1,127 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+import com.gregtechceu.gtceu.api.mui.base.value.ILongValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongConsumer;
+import java.util.function.LongSupplier;
+
+public class LongValue implements ILongValue<Long>, IIntValue<Long>, IStringValue<Long> {
+
+    public static Dynamic wrap(ILongValue<?> val) {
+        return new Dynamic(val::getLongValue, val::setLongValue);
+    }
+
+    public static Dynamic wrapAtomic(AtomicLong val) {
+        return new Dynamic(val::get, val::set);
+    }
+
+    private long value;
+
+    public LongValue(long value) {
+        this.value = value;
+    }
+
+    @Override
+    public Long getValue() {
+        return getLongValue();
+    }
+
+    @Override
+    public void setValue(Long value) {
+        setLongValue(value);
+    }
+
+    @Override
+    public long getLongValue() {
+        return this.value;
+    }
+
+    @Override
+    public void setLongValue(long val) {
+        this.value = val;
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.value);
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setLongValue(Long.parseLong(val));
+    }
+
+    @Override
+    public int getIntValue() {
+        return (int) this.value;
+    }
+
+    @Override
+    public void setIntValue(int val) {
+        setLongValue(val);
+    }
+
+    @Override
+    public Class<Long> getValueType() {
+        return Long.class;
+    }
+
+    public static class Dynamic implements ILongValue<Long>, IIntValue<Long>, IStringValue<Long> {
+
+        private final LongSupplier getter;
+        private final LongConsumer setter;
+
+        public Dynamic(LongSupplier getter, LongConsumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public long getLongValue() {
+            return this.getter.getAsLong();
+        }
+
+        @Override
+        public void setLongValue(long val) {
+            this.setter.accept(val);
+        }
+
+        @Override
+        public String getStringValue() {
+            return String.valueOf(getLongValue());
+        }
+
+        @Override
+        public void setStringValue(String val) {
+            setLongValue(Long.parseLong(val));
+        }
+
+        @Override
+        public Long getValue() {
+            return getLongValue();
+        }
+
+        @Override
+        public void setValue(Long value) {
+            setLongValue(value);
+        }
+
+        @Override
+        public int getIntValue() {
+            return (int) getLongValue();
+        }
+
+        @Override
+        public void setIntValue(int val) {
+            setLongValue(val);
+        }
+
+        @Override
+        public Class<Long> getValueType() {
+            return Long.class;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/ObjectValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/ObjectValue.java
new file mode 100644
index 00000000000..32cfbbe5c06
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/ObjectValue.java
@@ -0,0 +1,83 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class ObjectValue<T> implements IValue<T> {
+
+    public static <T> Dynamic<T> wrap(IValue<T> val) {
+        return new Dynamic<>(val::getValue, val::setValue);
+    }
+
+    public static <T> Dynamic<T> wrapAtomic(AtomicReference<T> val) {
+        return new Dynamic<>(val::get, val::set);
+    }
+
+    private final Class<T> type;
+    private T value;
+
+    public ObjectValue(Class<T> type, T value) {
+        this.type = type;
+        this.value = value;
+    }
+
+    @Deprecated
+    public ObjectValue(T value) {
+        this.type = value != null ? (Class<T>) value.getClass() : null;
+        this.value = value;
+    }
+
+    @Override
+    public T getValue() {
+        return value;
+    }
+
+    @Override
+    public void setValue(T value) {
+        this.value = value;
+    }
+
+    @Override
+    public Class<T> getValueType() {
+        return this.type != null ? this.type : (Class<T>) this.value.getClass();
+    }
+
+    public static class Dynamic<T> implements IValue<T> {
+
+        private final Class<T> type;
+        private final Supplier<T> getter;
+        private final Consumer<T> setter;
+
+        public Dynamic(Class<T> type, Supplier<T> getter, Consumer<T> setter) {
+            this.type = type;
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Deprecated
+        public Dynamic(Supplier<T> getter, Consumer<T> setter) {
+            this.getter = getter;
+            this.setter = setter;
+            T value = getter.get();
+            this.type = value != null ? (Class<T>) value.getClass() : null;
+        }
+
+        @Override
+        public T getValue() {
+            return this.getter.get();
+        }
+
+        @Override
+        public void setValue(T value) {
+            this.setter.accept(value);
+        }
+
+        @Override
+        public Class<T> getValueType() {
+            return this.type != null ? this.type : (Class<T>) this.getter.get().getClass();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/StringValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/StringValue.java
new file mode 100644
index 00000000000..0cd823a111d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/StringValue.java
@@ -0,0 +1,46 @@
+package com.gregtechceu.gtceu.api.mui.value;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class StringValue extends ObjectValue<String> implements IStringValue<String> {
+
+    public static Dynamic wrap(IStringValue<?> val) {
+        return new Dynamic(val::getStringValue, val::setStringValue);
+    }
+
+    public StringValue(String value) {
+        super(String.class, value);
+    }
+
+    @Override
+    public String getStringValue() {
+        return getValue();
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setValue(val);
+    }
+
+    public static class Dynamic extends ObjectValue.Dynamic<String> implements IStringValue<String> {
+
+        public Dynamic(Supplier<String> getter, @Nullable Consumer<String> setter) {
+            super(String.class, getter, setter);
+        }
+
+        @Override
+        public String getStringValue() {
+            return getValue();
+        }
+
+        @Override
+        public void setStringValue(String val) {
+            setValue(val);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/AbstractGenericSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/AbstractGenericSyncValue.java
new file mode 100644
index 00000000000..844b9ed10c1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/AbstractGenericSyncValue.java
@@ -0,0 +1,156 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public abstract class AbstractGenericSyncValue<T> extends ValueSyncHandler<T> {
+
+    private final Class<T> type;
+    private final Supplier<T> getter;
+    private final Consumer<T> setter;
+    private T cache;
+
+    protected AbstractGenericSyncValue(Class<T> type, Supplier<T> getter, Consumer<T> setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.get();
+        if (type == null) {
+            if (this.cache == null) {
+                throw new IllegalArgumentException(
+                        "If the value class is not give, then the getter must return a non null value!");
+            }
+            type = (Class<T>) this.cache.getClass();
+        }
+        this.type = type;
+    }
+
+    @Contract("_, null, _, null, _ -> fail")
+    protected AbstractGenericSyncValue(Class<T> type, @Nullable Supplier<T> clientGetter,
+                                       @Nullable Consumer<T> clientSetter,
+                                       @Nullable Supplier<T> serverGetter, @Nullable Consumer<T> serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.get();
+        if (type == null) {
+            if (this.cache == null) {
+                throw new IllegalArgumentException(
+                        "If the value class is not give, then the getter must return a non null value!");
+            }
+            type = (Class<T>) this.cache.getClass();
+        }
+        this.type = type;
+    }
+
+    protected abstract T createDeepCopyOf(T value);
+
+    protected abstract boolean areEqual(T a, T b);
+
+    protected abstract void serialize(FriendlyByteBuf buffer, T value);
+
+    protected abstract T deserialize(FriendlyByteBuf buffer);
+
+    @Override
+    public T getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(T value, boolean setSource, boolean sync) {
+        this.cache = createDeepCopyOf(value);
+        onSetCache(setSource, sync);
+    }
+
+    protected void onSetCache(boolean setSource, boolean sync) {
+        if (setSource && this.setter != null) {
+            this.setter.accept(this.cache);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (this.getter == null) return false;
+        T t = this.getter.get();
+        if (isFirstSync || !areEqual(this.cache, t)) {
+            setValue(t, false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        if (this.getter == null) throw new NullPointerException("Can't notify sync handler with null getter.");
+        setValue(this.getter.get(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        serialize(buffer, this.cache);
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setValue(deserialize(buffer), true, false);
+    }
+
+    @Override
+    public Class<T> getValueType() {
+        return type;
+    }
+
+    @Override
+    public boolean isValueOfType(Class<?> expectedType) {
+        Class<T> type = getValueType();
+        if (type == null) {
+            throw new IllegalStateException("Could not infer type of GenericSyncValue since value is null!");
+        }
+        return expectedType.isAssignableFrom(type);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <V> AbstractGenericSyncValue<V> cast() {
+        return (AbstractGenericSyncValue<V>) this;
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method forces a sync after the modification.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(Consumer<T> consumer) {
+        modifyValue(true, true, consumer);
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method can automatically sync the cache after the modification. Be careful with potential issues when the
+     * sync arg is false.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(boolean setSource, boolean sync, Consumer<T> consumer) {
+        consumer.accept(this.cache);
+        onSetCache(setSource, sync);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BigDecimalSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BigDecimalSyncValue.java
new file mode 100644
index 00000000000..3022b9dab7f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BigDecimalSyncValue.java
@@ -0,0 +1,34 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.math.BigDecimal;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class BigDecimalSyncValue extends GenericSyncValue<BigDecimal> implements IStringValue<BigDecimal> {
+
+    public BigDecimalSyncValue(@NotNull Supplier<BigDecimal> getter, @Nullable Consumer<BigDecimal> setter) {
+        this(getter, setter, false);
+    }
+
+    public BigDecimalSyncValue(@NotNull Supplier<BigDecimal> getter, @Nullable Consumer<BigDecimal> setter,
+                               boolean nullable) {
+        super(BigDecimal.class, getter, setter, ByteBufAdapters.BIG_DECIMAL, ICopy.immutable(), nullable);
+    }
+
+    @Override
+    public String getStringValue() {
+        return getValue().toString();
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setValue(new BigDecimal(val));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BigIntegerSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BigIntegerSyncValue.java
new file mode 100644
index 00000000000..eac4f46a92f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BigIntegerSyncValue.java
@@ -0,0 +1,34 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.math.BigInteger;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class BigIntegerSyncValue extends GenericSyncValue<BigInteger> implements IStringValue<BigInteger> {
+
+    public BigIntegerSyncValue(@NotNull Supplier<BigInteger> getter, @Nullable Consumer<BigInteger> setter) {
+        this(getter, setter, false);
+    }
+
+    public BigIntegerSyncValue(@NotNull Supplier<BigInteger> getter, @Nullable Consumer<BigInteger> setter,
+                               boolean nullable) {
+        super(BigInteger.class, getter, setter, ByteBufAdapters.BIG_INT, ICopy.immutable(), nullable);
+    }
+
+    @Override
+    public String getStringValue() {
+        return getValue().toString();
+    }
+
+    @Override
+    public void setStringValue(String val) {
+        setValue(new BigInteger(val));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BinaryEnumSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BinaryEnumSyncValue.java
new file mode 100644
index 00000000000..a2921dd0e53
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BinaryEnumSyncValue.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IBoolSyncValue;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * Accepts enums which have exactly two elements. Can act as {@link IBoolSyncValue}.
+ */
+public class BinaryEnumSyncValue<T extends Enum<T>> extends EnumSyncValue<T> implements IBoolSyncValue<T> {
+
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter, @Nullable Consumer<T> setter) {
+        super(enumClass, getter, setter);
+        if (enumClass.getEnumConstants().length != 2) {
+            throw new IllegalArgumentException("Enum class must have exactly two elements");
+        }
+    }
+
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter) {
+        this(enumClass, getter, (Consumer<T>) null);
+    }
+
+    @Contract("_, null, _, null, _ -> fail")
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass,
+                               @Nullable Supplier<T> clientGetter, @Nullable Consumer<T> clientSetter,
+                               @Nullable Supplier<T> serverGetter, @Nullable Consumer<T> serverSetter) {
+        super(enumClass, clientGetter, clientSetter, serverGetter, serverSetter);
+        if (enumClass.getEnumConstants().length != 2) {
+            throw new IllegalArgumentException("Enum class must have exactly two elements");
+        }
+    }
+
+    @Contract("_, null, null -> fail")
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass,
+                               @Nullable Supplier<T> clientGetter,
+                               @Nullable Supplier<T> serverGetter) {
+        this(enumClass, clientGetter, null, serverGetter, null);
+    }
+
+    @Override
+    public boolean getBoolValue() {
+        return this.cache.ordinal() == 1;
+    }
+
+    @Override
+    public void setBoolValue(boolean value, boolean setSource, boolean sync) {
+        setValue(this.enumClass.getEnumConstants()[value ? 1 : 0], setSource, sync);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BooleanSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BooleanSyncValue.java
new file mode 100644
index 00000000000..d11a9f1c85c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/BooleanSyncValue.java
@@ -0,0 +1,119 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IBoolSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IStringSyncValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.BooleanSupplier;
+
+public class BooleanSyncValue extends ValueSyncHandler<Boolean>
+                              implements IBoolSyncValue<Boolean>, IStringSyncValue<Boolean> {
+
+    private final BooleanSupplier getter;
+    private final BooleanConsumer setter;
+    private boolean cache;
+
+    public BooleanSyncValue(@NotNull BooleanSupplier getter, @Nullable BooleanConsumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getAsBoolean();
+    }
+
+    public BooleanSyncValue(@NotNull BooleanSupplier getter) {
+        this(getter, (BooleanConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public BooleanSyncValue(@Nullable BooleanSupplier clientGetter,
+                            @Nullable BooleanSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public BooleanSyncValue(@Nullable BooleanSupplier clientGetter, @Nullable BooleanConsumer clientSetter,
+                            @Nullable BooleanSupplier serverGetter, @Nullable BooleanConsumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getAsBoolean();
+    }
+
+    @Override
+    public Boolean getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public boolean getBoolValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(@NotNull Boolean value, boolean setSource, boolean sync) {
+        setBoolValue(value, setSource, sync);
+    }
+
+    @Override
+    public void setBoolValue(boolean value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.accept(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getAsBoolean() != this.cache) {
+            setBoolValue(this.getter.getAsBoolean(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setBoolValue(this.getter.getAsBoolean(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeBoolean(getBoolValue());
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setBoolValue(buffer.readBoolean(), true, false);
+    }
+
+    @Override
+    public void setStringValue(String value, boolean setSource, boolean sync) {
+        setBoolValue(Boolean.getBoolean(value), setSource, sync);
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.cache);
+    }
+
+    @Override
+    public Class<Boolean> getValueType() {
+        return Boolean.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ByteArraySyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ByteArraySyncValue.java
new file mode 100644
index 00000000000..b16ea50fdec
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ByteArraySyncValue.java
@@ -0,0 +1,20 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class ByteArraySyncValue extends GenericSyncValue<byte[]> {
+
+    public ByteArraySyncValue(@NotNull Supplier<byte[]> getter, @Nullable Consumer<byte[]> setter) {
+        this(getter, setter, false);
+    }
+
+    public ByteArraySyncValue(@NotNull Supplier<byte[]> getter, @Nullable Consumer<byte[]> setter, boolean nullable) {
+        super(byte[].class, getter, setter, ByteBufAdapters.BYTE_ARR, byte[]::clone, nullable);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ByteSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ByteSyncValue.java
new file mode 100644
index 00000000000..56024bfddf1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ByteSyncValue.java
@@ -0,0 +1,105 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IByteSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.ByteValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class ByteSyncValue extends ValueSyncHandler<Byte> implements IByteSyncValue<Byte> {
+
+    private byte cache;
+    private final ByteValue.Supplier getter;
+    private final ByteValue.Consumer setter;
+
+    public ByteSyncValue(@NotNull ByteValue.Supplier getter) {
+        this(getter, (ByteValue.Consumer) null);
+    }
+
+    public ByteSyncValue(@NotNull ByteValue.Supplier getter, @Nullable ByteValue.Consumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getByte();
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public ByteSyncValue(@Nullable ByteValue.Supplier clientGetter, @Nullable ByteValue.Consumer clientSetter,
+                         @Nullable ByteValue.Supplier serverGetter, @Nullable ByteValue.Consumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getByte();
+    }
+
+    public ByteSyncValue(@Nullable ByteValue.Supplier clientGetter,
+                         @Nullable ByteValue.Supplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Override
+    public void setValue(Byte value, boolean setSource, boolean sync) {
+        setByteValue(value, setSource, sync);
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getByte() != this.cache) {
+            setByteValue(this.getter.getByte(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setByteValue(this.getter.getByte(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeByte(getByteValue());
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setByteValue(buffer.readByte(), true, false);
+    }
+
+    @Override
+    public Byte getValue() {
+        return getByteValue();
+    }
+
+    @Override
+    public void setByteValue(byte value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.setByte(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public byte getByteValue() {
+        return this.cache;
+    }
+
+    @Override
+    public Class<Byte> getValueType() {
+        return Byte.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/CursorSlotSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/CursorSlotSyncHandler.java
new file mode 100644
index 00000000000..9305400db65
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/CursorSlotSyncHandler.java
@@ -0,0 +1,20 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+public class CursorSlotSyncHandler extends SyncHandler {
+
+    public void sync() {
+        sync(0, buffer -> buffer.writeItem(getSyncManager().getPlayer().containerMenu.getCarried()));
+    }
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        getSyncManager().getPlayer().containerMenu.setCarried(buf.readItem());
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        getSyncManager().getPlayer().containerMenu.setCarried(buf.readItem());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DoubleSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DoubleSyncValue.java
new file mode 100644
index 00000000000..8c519afea1b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DoubleSyncValue.java
@@ -0,0 +1,130 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IDoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IFloatSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IStringSyncValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleSupplier;
+
+public class DoubleSyncValue extends ValueSyncHandler<Double>
+                             implements IDoubleSyncValue<Double>, IFloatSyncValue<Double>, IStringSyncValue<Double> {
+
+    private final DoubleSupplier getter;
+    private final DoubleConsumer setter;
+    private double cache;
+
+    public DoubleSyncValue(@NotNull DoubleSupplier getter, @Nullable DoubleConsumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getAsDouble();
+    }
+
+    public DoubleSyncValue(@NotNull DoubleSupplier getter) {
+        this(getter, (DoubleConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public DoubleSyncValue(@Nullable DoubleSupplier clientGetter,
+                           @Nullable DoubleSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public DoubleSyncValue(@Nullable DoubleSupplier clientGetter, @Nullable DoubleConsumer clientSetter,
+                           @Nullable DoubleSupplier serverGetter, @Nullable DoubleConsumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getAsDouble();
+    }
+
+    @Override
+    public Double getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public double getDoubleValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(@NotNull Double value, boolean setSource, boolean sync) {
+        setDoubleValue(value, setSource, sync);
+    }
+
+    @Override
+    public void setDoubleValue(double value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.accept(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getAsDouble() != this.cache) {
+            setDoubleValue(this.getter.getAsDouble(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setDoubleValue(this.getter.getAsDouble(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeDouble(getDoubleValue());
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setDoubleValue(buffer.readDouble(), true, false);
+    }
+
+    @Override
+    public void setStringValue(String value, boolean setSource, boolean sync) {
+        setDoubleValue(Double.parseDouble(value), setSource, sync);
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.cache);
+    }
+
+    @Override
+    public float getFloatValue() {
+        return (float) getDoubleValue();
+    }
+
+    @Override
+    public void setFloatValue(float value, boolean setSource, boolean sync) {
+        setDoubleValue(value, setSource, sync);
+    }
+
+    @Override
+    public Class<Double> getValueType() {
+        return Double.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DynamicLinkedSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DynamicLinkedSyncHandler.java
new file mode 100644
index 00000000000..c9c12f4bfdf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DynamicLinkedSyncHandler.java
@@ -0,0 +1,136 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class DynamicLinkedSyncHandler<S extends ValueSyncHandler<?>> extends SyncHandler
+                                     implements IDynamicSyncNotifiable {
+
+    private IWidgetProvider<S> widgetProvider;
+    private Consumer<IWidget> onWidgetUpdate;
+
+    private IWidget lastRejectedWidget;
+
+    private final S linkedValue;
+
+    public DynamicLinkedSyncHandler(S linkedValue) {
+        this.linkedValue = linkedValue;
+        linkedValue.setChangeListener(() -> notifyUpdate(false));
+    }
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        if (id == 0) {
+            updateWidget(parseWidget());
+        }
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        if (id == 0) {
+            // do nothing with the widget on server side
+            parseWidget();
+        }
+    }
+
+    @Override
+    public void init(String key, PanelSyncManager syncManager) {
+        super.init(key, syncManager);
+        notifyUpdate(false);
+    }
+
+    private IWidget parseWidget() {
+        getSyncManager().allowTemporarySyncHandlerRegistration(true);
+        IWidget widget = this.widgetProvider.createWidget(getSyncManager(), this.linkedValue);
+        getSyncManager().allowTemporarySyncHandlerRegistration(false);
+        // collects any unregistered sync handlers
+        // since the sync manager is currently locked and we no longer allow bypassing the lock it will crash if it
+        // finds any
+        int unregistered = WidgetTree.countUnregisteredSyncHandlers(getSyncManager(), widget);
+        if (unregistered > 0) {
+            throw new IllegalStateException(
+                    "Widgets created by DynamicSyncHandler can't have implicitly registered sync handlers. All" +
+                            "sync handlers must be registered with a variant of 'PanelSyncManager#getOrCreateSyncHandler(...)'.");
+        }
+        return widget;
+    }
+
+    private void updateWidget(IWidget widget) {
+        if (this.onWidgetUpdate == null) {
+            // no dynamic widget is yet attached
+            // store for later
+            // also ignore previous stored widget
+            this.lastRejectedWidget = widget;
+        } else {
+            this.onWidgetUpdate.accept(widget);
+        }
+    }
+
+    /**
+     * Notifies the sync handler to create a new widget. It is allowed to call this method before this sync handler is
+     * initialised.
+     * The packet will be cached until the sync handler is initialised. Only the last call of this method, while this
+     * sync handler is not
+     * initialised is effective.
+     */
+    private void notifyUpdate(boolean sync) {
+        if (!isValid()) return;
+        IWidget widget = parseWidget();
+        if (getSyncManager().isClient()) {
+            updateWidget(widget);
+        }
+        if (sync) sync(0, b -> {});
+    }
+
+    /**
+     * Sets a widget creator which is called on client and server. {@link SyncHandler}s can be created here using
+     * {@link PanelSyncManager#getOrCreateSyncHandler(String, int, Class, Supplier)}. Returning null in the function
+     * will not update the widget.
+     * On client side the result is handed over to a linked
+     * {@link com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget}.
+     *
+     * @param widgetProvider the widget creator function
+     * @return this
+     * @see IWidgetProvider
+     */
+    public DynamicLinkedSyncHandler<S> widgetProvider(IWidgetProvider<S> widgetProvider) {
+        this.widgetProvider = widgetProvider;
+        return this;
+    }
+
+    /**
+     * An internal function which is used to link the {@link com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget}.
+     */
+    @ApiStatus.Internal
+    @Override
+    public void attachDynamicWidgetListener(Consumer<IWidget> onWidgetUpdate) {
+        this.onWidgetUpdate = onWidgetUpdate;
+        if (this.onWidgetUpdate != null && this.lastRejectedWidget != null) {
+            this.onWidgetUpdate.accept(this.lastRejectedWidget);
+            this.lastRejectedWidget = null;
+        }
+    }
+
+    public interface IWidgetProvider<S extends ValueSyncHandler<?>> {
+
+        /**
+         * This is the function which creates a widget on client and server.
+         * In this method sync handlers can only be registered with
+         * {@link PanelSyncManager#getOrCreateSyncHandler(String, int, Class, Supplier)}.
+         *
+         * @param syncManager the sync manager of the current panel
+         * @param value       the linked sync value
+         * @return a new widget or null if widget shouldn't be updated
+         */
+        @Nullable
+        IWidget createWidget(PanelSyncManager syncManager, S value);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DynamicSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DynamicSyncHandler.java
new file mode 100644
index 00000000000..f931cc20e2c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/DynamicSyncHandler.java
@@ -0,0 +1,152 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.IPacketWriter;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * This sync handler is used to update a widget dynamically. The update can be called from client and server side.
+ * To use it add a widget provider with {@link #widgetProvider(IWidgetProvider)} and link this sync handler to a
+ * {@link com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget DynamicSyncedWidget}. When you want the widget to be
+ * updated call
+ * {@link #notifyUpdate(IPacketWriter)}. The passed in packed writer will write a packet, which can the be read inside
+ * the widget provider.
+ * The widget provider as ran on both sides. Inside the provider sync handlers can be registered with variants of
+ * {@link ISyncRegistrar#getOrCreateSyncHandler(String, int, Class, Supplier)}.
+ */
+@ApiStatus.Obsolete
+public class DynamicSyncHandler extends SyncHandler implements IDynamicSyncNotifiable {
+
+    private IWidgetProvider widgetProvider;
+    private Consumer<IWidget> onWidgetUpdate;
+
+    private IPacketWriter lastRejectedPacket;
+    private IWidget lastRejectedWidget;
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        if (id == 0) {
+            updateWidget(parseWidget(buf));
+        }
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        if (id == 0) {
+            // do nothing with the widget on server side
+            parseWidget(buf);
+        }
+    }
+
+    @Override
+    public void init(String key, PanelSyncManager syncManager) {
+        super.init(key, syncManager);
+        if (this.lastRejectedPacket != null) {
+            notifyUpdate(this.lastRejectedPacket);
+            this.lastRejectedPacket = null;
+        }
+    }
+
+    private IWidget parseWidget(FriendlyByteBuf buf) {
+        getSyncManager().allowTemporarySyncHandlerRegistration(true);
+        IWidget widget = this.widgetProvider.createWidget(getSyncManager(), buf);
+        getSyncManager().allowTemporarySyncHandlerRegistration(false);
+        // collects any unregistered sync handlers
+        // since the sync manager is currently locked and we no longer allow bypassing the lock it will crash if it
+        // finds any
+        int unregistered = WidgetTree.countUnregisteredSyncHandlers(getSyncManager(), widget);
+        if (unregistered > 0) {
+            throw new IllegalStateException(
+                    "Widgets created by DynamicSyncHandler can't have implicitly registered sync" +
+                            " handlers. All sync handlers must be regisered witha  variant of 'PanelSyncManager#getOrCreateSyncHandler(...)'.");
+        }
+        return widget;
+    }
+
+    private void updateWidget(IWidget widget) {
+        if (this.onWidgetUpdate == null) {
+            // no dynamic widget is yet attached
+            // store for later
+            // also ignore previous stored widget
+            this.lastRejectedWidget = widget;
+        } else {
+            this.onWidgetUpdate.accept(widget);
+        }
+    }
+
+    /**
+     * Notifies the sync handler to create a new widget. It is allowed to call this method before this sync handler is
+     * initialised.
+     * The packet will be cached until the sync handler is initialised. Only the last call of this method, while this
+     * sync handler is not
+     * initialised is effective.
+     *
+     * @param packetWriter data to pass to the function
+     */
+    public void notifyUpdate(IPacketWriter packetWriter) {
+        if (!isValid()) {
+            // sync handler not yet initialised
+            // store for later
+            // also ignore previous stored packet
+            this.lastRejectedPacket = packetWriter;
+            return;
+        }
+        IWidget widget = parseWidget(packetWriter.toPacket());
+        if (getSyncManager().isClient()) {
+            updateWidget(widget);
+        }
+        sync(0, packetWriter);
+    }
+
+    /**
+     * Sets a widget creator which is called on client and server. {@link SyncHandler}s can be created here using
+     * {@link PanelSyncManager#getOrCreateSyncHandler(String, int, Class, Supplier)}. Returning null in the function
+     * will not update the widget.
+     * On client side the result is handed over to a linked
+     * {@link com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget}.
+     *
+     * @param widgetProvider the widget creator function
+     * @return this
+     * @see IWidgetProvider
+     */
+    public DynamicSyncHandler widgetProvider(IWidgetProvider widgetProvider) {
+        this.widgetProvider = widgetProvider;
+        return this;
+    }
+
+    /**
+     * An internal function which is used to link the {@link com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget}.
+     */
+    @ApiStatus.Internal
+    @Override
+    public void attachDynamicWidgetListener(Consumer<IWidget> onWidgetUpdate) {
+        this.onWidgetUpdate = onWidgetUpdate;
+        if (this.onWidgetUpdate != null && this.lastRejectedWidget != null) {
+            this.onWidgetUpdate.accept(this.lastRejectedWidget);
+            this.lastRejectedWidget = null;
+        }
+    }
+
+    public interface IWidgetProvider {
+
+        /**
+         * This is the function which creates a widget on client and server.
+         * In this method sync handlers can only be registered with
+         * {@link PanelSyncManager#getOrCreateSyncHandler(String, int, Class, Supplier)}.
+         *
+         * @param syncManager the sync manager of the current panel
+         * @param buf         data which was passed in the notify method
+         * @return a new widget or null if widget shouldn't be updated
+         */
+        @Nullable
+        IWidget createWidget(PanelSyncManager syncManager, FriendlyByteBuf buf);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/EnumSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/EnumSyncValue.java
new file mode 100644
index 00000000000..9637aa3b380
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/EnumSyncValue.java
@@ -0,0 +1,114 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.IEnumValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IIntSyncValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class EnumSyncValue<T extends Enum<T>> extends ValueSyncHandler<T> implements IEnumValue<T>, IIntSyncValue<T> {
+
+    @Getter
+    protected final Class<T> enumClass;
+    private final Supplier<T> getter;
+    private final Consumer<T> setter;
+    protected T cache;
+
+    public EnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter, @Nullable Consumer<T> setter) {
+        this.enumClass = Objects.requireNonNull(enumClass);
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.get();
+    }
+
+    public EnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter) {
+        this(enumClass, getter, (Consumer<T>) null);
+    }
+
+    @Contract("_, null, null -> fail")
+    public EnumSyncValue(Class<T> enumClass,
+                         @Nullable Supplier<T> clientGetter,
+                         @Nullable Supplier<T> serverGetter) {
+        this(enumClass, clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("_, null, _, null, _ -> fail")
+    public EnumSyncValue(Class<T> enumClass, @Nullable Supplier<T> clientGetter, @Nullable Consumer<T> clientSetter,
+                         @Nullable Supplier<T> serverGetter, @Nullable Consumer<T> serverSetter) {
+        this.enumClass = enumClass;
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.get();
+    }
+
+    @Override
+    public T getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(T value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.accept(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.get() != this.cache) {
+            setValue(this.getter.get(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setValue(this.getter.get(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeEnum(getValue());
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setValue(buffer.readEnum(this.enumClass), true, false);
+    }
+
+    @Override
+    public void setIntValue(int value, boolean setSource, boolean sync) {
+        setValue(this.enumClass.getEnumConstants()[value], setSource, sync);
+    }
+
+    @Override
+    public int getIntValue() {
+        return this.cache.ordinal();
+    }
+
+    @Override
+    public Class<T> getValueType() {
+        return this.enumClass;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/FloatSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/FloatSyncValue.java
new file mode 100644
index 00000000000..68e634c39a1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/FloatSyncValue.java
@@ -0,0 +1,130 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IDoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IFloatSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IStringSyncValue;
+import com.gregtechceu.gtceu.utils.FloatConsumer;
+import com.gregtechceu.gtceu.utils.FloatSupplier;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class FloatSyncValue extends ValueSyncHandler<Float> implements
+                            IFloatSyncValue<Float>, IDoubleSyncValue<Float>, IStringSyncValue<Float> {
+
+    private final FloatSupplier getter;
+    private final FloatConsumer setter;
+    private float cache;
+
+    public FloatSyncValue(@NotNull FloatSupplier getter, @Nullable FloatConsumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getAsFloat();
+    }
+
+    public FloatSyncValue(@NotNull FloatSupplier getter) {
+        this(getter, (FloatConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public FloatSyncValue(@Nullable FloatSupplier clientGetter,
+                          @Nullable FloatSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public FloatSyncValue(@Nullable FloatSupplier clientGetter, @Nullable FloatConsumer clientSetter,
+                          @Nullable FloatSupplier serverGetter, @Nullable FloatConsumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getAsFloat();
+    }
+
+    @Override
+    public Float getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(@NotNull Float value, boolean setSource, boolean sync) {
+        setFloatValue(value, setSource, sync);
+    }
+
+    @Override
+    public float getFloatValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setFloatValue(float value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.accept(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getAsFloat() != this.cache) {
+            setFloatValue(this.getter.getAsFloat(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setFloatValue(this.getter.getAsFloat(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeFloat(getFloatValue());
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setFloatValue(buffer.readFloat(), true, false);
+    }
+
+    @Override
+    public void setStringValue(String value, boolean setSource, boolean sync) {
+        setFloatValue(Float.parseFloat(value), setSource, sync);
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.cache);
+    }
+
+    @Override
+    public double getDoubleValue() {
+        return getFloatValue();
+    }
+
+    @Override
+    public void setDoubleValue(double value, boolean setSource, boolean sync) {
+        setFloatValue((float) value, setSource, sync);
+    }
+
+    @Override
+    public Class<Float> getValueType() {
+        return Float.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/FluidSlotSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/FluidSlotSyncHandler.java
new file mode 100644
index 00000000000..5ca2d972872
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/FluidSlotSyncHandler.java
@@ -0,0 +1,299 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.misc.forge.FluidTankHandler;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+
+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.minecraftforge.common.SoundAction;
+import net.minecraftforge.common.SoundActions;
+import net.minecraftforge.common.capabilities.ForgeCapabilities;
+import net.minecraftforge.fluids.*;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandlerItem;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@Accessors(fluent = true, chain = true)
+public class FluidSlotSyncHandler extends ValueSyncHandler<FluidStack> {
+
+    public static final int SYNC_CLICK = 1;
+    public static final int SYNC_SCROLL = 2;
+    public static final int SYNC_CONTROLS_AMOUNT = 3;
+
+    private @NotNull FluidStack cache = FluidStack.EMPTY;
+    @Getter
+    private final IFluidTank fluidTank;
+    private final IFluidHandler fluidHandler;
+    @Getter
+    @Setter
+    private boolean canFillSlot = true, canDrainSlot = true, phantom = false;
+    @Getter
+    private boolean controlsAmount = true;
+    @Nullable
+    private FluidStack lastStoredPhantomFluid;
+
+    public FluidSlotSyncHandler(IFluidTank fluidTank) {
+        this.fluidTank = fluidTank;
+        this.fluidHandler = FluidTankHandler.getTankFluidHandler(fluidTank);
+    }
+
+    @Nullable
+    @Override
+    public FluidStack getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(@NotNull FluidStack value, boolean setSource, boolean sync) {
+        this.cache = value.copy();
+        if (setSource) {
+            this.fluidTank.drain(Integer.MAX_VALUE, IFluidHandler.FluidAction.EXECUTE);
+            if (!value.isEmpty()) {
+                this.fluidTank.fill(value.copy(), IFluidHandler.FluidAction.EXECUTE);
+            }
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    public boolean needsSync() {
+        FluidStack current = this.fluidTank.getFluid();
+        if (current == this.cache) return false;
+        if (current.isEmpty() && this.cache.isEmpty()) return true;
+        return !current.isFluidStackIdentical(this.cache);
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || needsSync()) {
+            setValue(this.fluidTank.getFluid(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public Class<FluidStack> getValueType() {
+        return FluidStack.class;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setValue(this.fluidTank.getFluid(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        this.cache.writeToPacket(buffer);
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setValue(FluidStack.readFromPacket(buffer), true, false);
+    }
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_VALUE) {
+            read(buf);
+        } else if (id == SYNC_CONTROLS_AMOUNT) {
+            this.controlsAmount = buf.readBoolean();
+        }
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_VALUE) {
+            if (this.phantom) {
+                read(buf);
+            }
+        } else if (id == SYNC_CLICK) {
+            if (this.phantom) {
+                tryClickPhantom(MouseData.readPacket(buf));
+            } else {
+                tryClickContainer(MouseData.readPacket(buf));
+            }
+        } else if (id == SYNC_SCROLL) {
+            if (this.phantom) {
+                tryScrollPhantom(MouseData.readPacket(buf));
+            }
+        } else if (id == SYNC_CONTROLS_AMOUNT) {
+            this.controlsAmount = buf.readBoolean();
+        }
+    }
+
+    private void tryClickContainer(MouseData mouseData) {
+        Player player = getSyncManager().getPlayer();
+        ItemStack currentStack = player.containerMenu.getCarried();
+        if (!currentStack.getCapability(ForgeCapabilities.FLUID_HANDLER_ITEM, null).isPresent()) {
+            return;
+        }
+        int maxAttempts = mouseData.shift() ? currentStack.getCount() : 1;
+        if (mouseData.mouseButton() == InputConstants.MOUSE_BUTTON_RIGHT && this.canFillSlot) {
+            boolean performedTransfer = false;
+            for (int i = 0; i < maxAttempts; i++) {
+                FluidActionResult result = FluidUtil.tryEmptyContainer(currentStack, this.fluidHandler,
+                        Integer.MAX_VALUE, null, false);
+                ItemStack remainingStack = result.getResult();
+                if (!result.isSuccess() || (currentStack.getCount() > 1 && !remainingStack.isEmpty() &&
+                        !player.getInventory().add(remainingStack))) {
+                    player.drop(remainingStack, true);
+                    break; // do not continue if we can't add resulting container into inventory
+                }
+
+                remainingStack = FluidUtil.tryEmptyContainer(currentStack, this.fluidHandler, Integer.MAX_VALUE, null,
+                        true).result;
+                if (currentStack.getCount() == 1) {
+                    currentStack = remainingStack;
+                } else {
+                    currentStack.shrink(1);
+                }
+                performedTransfer = true;
+                if (currentStack.isEmpty()) {
+                    break;
+                }
+            }
+            FluidStack fluid = this.fluidTank.getFluid();
+            if (performedTransfer && !fluid.isEmpty()) {
+                playSound(fluid, SoundActions.BUCKET_EMPTY);
+                getSyncManager().setCursorItem(currentStack);
+            }
+            return;
+        }
+        FluidStack currentFluid = this.fluidTank.getFluid();
+        if (mouseData.mouseButton() == InputConstants.MOUSE_BUTTON_LEFT && this.canDrainSlot &&
+                !currentFluid.isEmpty()) {
+            boolean performedTransfer = false;
+            for (int i = 0; i < maxAttempts; i++) {
+                FluidActionResult result = FluidUtil.tryFillContainer(currentStack, this.fluidHandler,
+                        Integer.MAX_VALUE, null, false);
+                ItemStack remainingStack = result.getResult();
+                if (!result.isSuccess() || (currentStack.getCount() > 1 && !remainingStack.isEmpty() &&
+                        !player.getInventory().add(remainingStack))) {
+                    break; // do not continue if we can't add resulting container into inventory
+                }
+
+                remainingStack = FluidUtil.tryFillContainer(currentStack, this.fluidHandler, Integer.MAX_VALUE, player,
+                        true).result;
+                if (currentStack.getCount() == 1) {
+                    currentStack = remainingStack;
+                } else {
+                    currentStack.shrink(1);
+                }
+                performedTransfer = true;
+                if (currentStack.isEmpty()) {
+                    break;
+                }
+            }
+            if (performedTransfer) {
+                playSound(currentFluid, SoundActions.BUCKET_FILL);
+                getSyncManager().setCursorItem(currentStack);
+            }
+        }
+    }
+
+    public void tryClickPhantom(MouseData mouseData) {
+        Player player = getSyncManager().getPlayer();
+        ItemStack currentStack = player.containerMenu.getCarried();
+        FluidStack currentFluid = this.fluidTank.getFluid();
+        IFluidHandlerItem fluidHandlerItem = currentStack.getCapability(ForgeCapabilities.FLUID_HANDLER_ITEM, null)
+                .resolve().orElse(null);
+
+        if (mouseData.mouseButton() == 0) {
+            if (currentStack.isEmpty() || fluidHandlerItem == null) {
+                if (this.canDrainSlot) {
+                    this.fluidTank.drain(mouseData.shift() ? Integer.MAX_VALUE : 1000,
+                            IFluidHandler.FluidAction.EXECUTE);
+                }
+            } else {
+                FluidStack cellFluid = fluidHandlerItem.drain(Integer.MAX_VALUE, IFluidHandler.FluidAction.SIMULATE);
+                if ((this.controlsAmount || currentFluid.isEmpty()) && !cellFluid.isEmpty()) {
+                    if (this.canFillSlot) {
+                        if (!this.controlsAmount) {
+                            cellFluid.setAmount(1);
+                        }
+                        if (this.fluidTank.fill(cellFluid, IFluidHandler.FluidAction.EXECUTE) > 0) {
+                            this.lastStoredPhantomFluid = cellFluid.copy();
+                        }
+                    }
+                } else {
+                    if (this.canDrainSlot) {
+                        this.fluidTank.drain(mouseData.shift() ? Integer.MAX_VALUE : FluidType.BUCKET_VOLUME,
+                                IFluidHandler.FluidAction.EXECUTE);
+                    }
+                }
+            }
+        } else if (mouseData.mouseButton() == 1) {
+            if (this.canFillSlot) {
+                if (!currentFluid.isEmpty()) {
+                    if (this.controlsAmount) {
+                        FluidStack toFill = currentFluid.copy();
+                        toFill.setAmount(FluidType.BUCKET_VOLUME);
+                        this.fluidTank.fill(toFill, IFluidHandler.FluidAction.EXECUTE);
+                    }
+                } else if (this.lastStoredPhantomFluid != null) {
+                    FluidStack toFill = this.lastStoredPhantomFluid.copy();
+                    toFill.setAmount(this.controlsAmount ? FluidType.BUCKET_VOLUME : 1);
+                    this.fluidTank.fill(toFill, IFluidHandler.FluidAction.EXECUTE);
+                }
+            }
+        } else if (mouseData.mouseButton() == 2 && !currentFluid.isEmpty() && this.canDrainSlot) {
+            this.fluidTank.drain(mouseData.shift() ? Integer.MAX_VALUE : FluidType.BUCKET_VOLUME,
+                    IFluidHandler.FluidAction.EXECUTE);
+        }
+    }
+
+    public void tryScrollPhantom(MouseData mouseData) {
+        FluidStack currentFluid = this.fluidTank.getFluid();
+        int amount = mouseData.mouseButton();
+        if (mouseData.shift()) {
+            amount *= 10;
+        }
+        if (mouseData.ctrl()) {
+            amount *= 100;
+        }
+        if (mouseData.alt()) {
+            amount *= 1000;
+        }
+        if (currentFluid.isEmpty()) {
+            if (amount > 0 && this.lastStoredPhantomFluid != null) {
+                FluidStack toFill = this.lastStoredPhantomFluid.copy();
+                toFill.setAmount(this.controlsAmount ? amount : 1);
+                this.fluidTank.fill(toFill, IFluidHandler.FluidAction.EXECUTE);
+            }
+            return;
+        }
+        if (amount > 0 && this.controlsAmount) {
+            FluidStack toFill = currentFluid.copy();
+            toFill.setAmount(amount);
+            this.fluidTank.fill(toFill, IFluidHandler.FluidAction.EXECUTE);
+        } else if (amount < 0) {
+            this.fluidTank.drain(-amount, IFluidHandler.FluidAction.EXECUTE);
+        }
+    }
+
+    private void playSound(FluidStack fluid, SoundAction action) {
+        Player player = getSyncManager().getPlayer();
+        SoundEvent sound = fluid.getFluid().getFluidType().getSound(fluid, action);
+        if (sound == null) return;
+        player.level().playSound(null, player.getX(), player.getY() + 0.5, player.getZ(), sound, SoundSource.BLOCKS,
+                1.0F, 1.0F);
+    }
+
+    public FluidSlotSyncHandler controlsAmount(boolean controlsAmount) {
+        this.controlsAmount = controlsAmount;
+        if (isValid()) {
+            sync(SYNC_CONTROLS_AMOUNT, buffer -> buffer.writeBoolean(controlsAmount));
+        }
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericCollectionSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericCollectionSyncHandler.java
new file mode 100644
index 00000000000..7221ba2e727
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericCollectionSyncHandler.java
@@ -0,0 +1,151 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.utils.EqualityTest;
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufAdapter;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufDeserializer;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufSerializer;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public abstract class GenericCollectionSyncHandler<T, C extends Collection<T>> extends ValueSyncHandler<C> {
+
+    private final Supplier<C> getter;
+    private final Consumer<C> setter;
+    private final IByteBufDeserializer<T> deserializer;
+    private final IByteBufSerializer<T> serializer;
+    private final EqualityTest<T> equals;
+    private final ICopy<T> copy;
+
+    protected GenericCollectionSyncHandler(@NotNull Supplier<C> getter,
+                                           @Nullable Consumer<C> setter,
+                                           @NotNull IByteBufDeserializer<T> deserializer,
+                                           @NotNull IByteBufSerializer<T> serializer,
+                                           @Nullable EqualityTest<T> equals,
+                                           @Nullable ICopy<T> copy) {
+        this.getter = getter;
+        this.setter = setter;
+        this.deserializer = deserializer;
+        this.serializer = serializer;
+        this.equals = equals != null ? EqualityTest.wrapNullSafe(equals) : Objects::equals;
+        this.copy = copy != null ? copy : ICopy.ofSerializer(serializer, deserializer);
+    }
+
+    @Override
+    public void setValue(C value, boolean setSource, boolean sync) {
+        setCache(value);
+        onSetCache(setSource, sync);
+    }
+
+    protected abstract void setCache(C value);
+
+    protected void onSetCache(boolean setSource, boolean sync) {
+        if (setSource && this.setter != null) {
+            this.setter.accept(getValue());
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        C c = this.getter.get();
+        if (isFirstSync || didValuesChange(c)) {
+            setValue(c, false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setValue(this.getter.get(), false, true);
+    }
+
+    protected abstract boolean didValuesChange(C newValues);
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        C c = getValue();
+        buffer.writeVarInt(c.size());
+        for (T t : c) {
+            this.serializer.serialize(buffer, t);
+        }
+    }
+
+    @Override
+    public abstract C getValue();
+
+    public boolean areValuesEqual(T a, T b) {
+        return this.equals.areEqual(a, b);
+    }
+
+    protected T deserializeValue(FriendlyByteBuf buffer) {
+        return this.deserializer.deserialize(buffer);
+    }
+
+    protected T copyValue(T value) {
+        return this.copy.createDeepCopy(value);
+    }
+
+    public static class Builder<T, C extends Collection<T>, B extends Builder<T, C, B>> {
+
+        protected Supplier<C> getter;
+        protected Consumer<C> setter;
+        protected IByteBufDeserializer<T> deserializer;
+        protected IByteBufSerializer<T> serializer;
+        protected EqualityTest<T> equals;
+        protected ICopy<T> copy;
+
+        public B getter(Supplier<C> getter) {
+            this.getter = getter;
+            return getSelf();
+        }
+
+        public B setter(Consumer<C> setter) {
+            this.setter = setter;
+            return getSelf();
+        }
+
+        public B deserializer(IByteBufDeserializer<T> deserializer) {
+            this.deserializer = deserializer;
+            return getSelf();
+        }
+
+        public B serializer(IByteBufSerializer<T> serializer) {
+            this.serializer = serializer;
+            return getSelf();
+        }
+
+        // protected, because for sets the objects equals and hash code is used
+        protected B equals(EqualityTest<T> equals) {
+            this.equals = equals;
+            return getSelf();
+        }
+
+        public B adapter(IByteBufAdapter<T> adapter) {
+            return deserializer(adapter).serializer(adapter).equals(adapter);
+        }
+
+        public B copy(ICopy<T> copy) {
+            this.copy = copy;
+            return getSelf();
+        }
+
+        public B immutableCopy() {
+            return copy(ICopy.immutable());
+        }
+
+        protected B getSelf() {
+            return (B) this;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericListSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericListSyncHandler.java
new file mode 100644
index 00000000000..400a964a0f8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericListSyncHandler.java
@@ -0,0 +1,132 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.utils.ObjectList;
+import com.gregtechceu.gtceu.utils.EqualityTest;
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufAdapter;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufDeserializer;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufSerializer;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.IntFunction;
+import java.util.function.Supplier;
+
+public class GenericListSyncHandler<T> extends GenericCollectionSyncHandler<T, List<T>> {
+
+    private final ObjectList<T> cache = ObjectList.create();
+
+    public GenericListSyncHandler(@NotNull Supplier<List<T>> getter, @Nullable Consumer<List<T>> setter,
+                                  @NotNull IByteBufDeserializer<T> deserializer,
+                                  @NotNull IByteBufSerializer<T> serializer, @Nullable EqualityTest<T> equals,
+                                  @Nullable ICopy<T> copy) {
+        super(getter, setter, deserializer, serializer, equals, copy);
+    }
+
+    public GenericListSyncHandler(@NotNull Supplier<List<T>> getter, @Nullable Consumer<List<T>> setter,
+                                  IByteBufAdapter<T> adapter) {
+        this(getter, setter, adapter, adapter, adapter, null);
+    }
+
+    @Override
+    protected void setCache(List<T> value) {
+        this.cache.clear();
+        for (T item : value) {
+            this.cache.add(copyValue(item));
+        }
+    }
+
+    @Override
+    protected boolean didValuesChange(List<T> newValues) {
+        if (this.cache.size() != newValues.size()) return true;
+        for (int i = 0; i < this.cache.size(); i++) {
+            if (!areValuesEqual(this.cache.get(i), newValues.get(i))) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public List<T> getValue() {
+        return Collections.unmodifiableList(this.cache);
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        this.cache.clear();
+        int size = buffer.readVarInt();
+        for (int i = 0; i < size; i++) {
+            this.cache.add(deserializeValue(buffer));
+        }
+        onSetCache(true, false);
+    }
+
+    @Override
+    public Class<List<T>> getValueType() {
+        return (Class<List<T>>) (Object) List.class;
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method forces a sync after the modification.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(Consumer<List<T>> consumer) {
+        modifyValue(true, true, consumer);
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method can automatically sync the cache after the modification. Be careful with potential issues when the
+     * sync arg is false.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(boolean setSource, boolean sync, Consumer<List<T>> consumer) {
+        consumer.accept(this.cache);
+        onSetCache(setSource, sync);
+    }
+
+    public static <T> Builder<T> builder() {
+        return new Builder<>();
+    }
+
+    public static class Builder<T> extends GenericCollectionSyncHandler.Builder<T, List<T>, Builder<T>> {
+
+        public Builder<T> getterArray(Supplier<T[]> getter) {
+            getter(() -> Arrays.asList(getter.get()));
+            return this;
+        }
+
+        public Builder<T> setterArray(Consumer<T[]> setter, IntFunction<T[]> arrayFactory) {
+            setter(c -> setter.accept(c.toArray(arrayFactory.apply(c.size()))));
+            return this;
+        }
+
+        @Override
+        public Builder<T> equals(EqualityTest<T> equals) {
+            super.equals(equals);
+            return this;
+        }
+
+        public GenericListSyncHandler<T> build() {
+            if (this.getter == null)
+                throw new NullPointerException("Getter in GenericListSyncHandler must not be null");
+            if (this.deserializer == null)
+                throw new NullPointerException("Deserializer in GenericListSyncHandler must not be null");
+            if (this.serializer == null)
+                throw new NullPointerException("Serializer in GenericListSyncHandler must not be null");
+            return new GenericListSyncHandler<>(this.getter, this.setter, this.deserializer, this.serializer,
+                    this.equals, this.copy);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericMapSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericMapSyncHandler.java
new file mode 100644
index 00000000000..df9fa89318f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericMapSyncHandler.java
@@ -0,0 +1,241 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.utils.EqualityTest;
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufAdapter;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufDeserializer;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufSerializer;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class GenericMapSyncHandler<K, V> extends ValueSyncHandler<Map<K, V>> {
+
+    private final Supplier<Map<K, V>> getter;
+    private final Consumer<Map<K, V>> setter;
+    private final IByteBufDeserializer<K> keyDeserializer;
+    private final IByteBufDeserializer<V> valueDeserializer;
+    private final IByteBufSerializer<K> keySerializer;
+    private final IByteBufSerializer<V> valueSerializer;
+    private final EqualityTest<V> equals;
+    private final ICopy<K> keyCopy;
+    private final ICopy<V> valueCopy;
+    private final Map<K, V> cache = new Object2ObjectOpenHashMap<>();
+
+    public GenericMapSyncHandler(Supplier<Map<K, V>> getter,
+                                 Consumer<Map<K, V>> setter,
+                                 IByteBufDeserializer<K> keyDeserializer,
+                                 IByteBufDeserializer<V> valueDeserializer,
+                                 IByteBufSerializer<K> keySerializer,
+                                 IByteBufSerializer<V> valueSerializer,
+                                 EqualityTest<V> equals,
+                                 ICopy<K> keyCopy,
+                                 ICopy<V> valueCopy) {
+        this.getter = getter;
+        this.setter = setter;
+        this.keyDeserializer = keyDeserializer;
+        this.valueDeserializer = valueDeserializer;
+        this.keySerializer = keySerializer;
+        this.valueSerializer = valueSerializer;
+        this.equals = equals != null ? EqualityTest.wrapNullSafe(equals) : Objects::equals;
+        this.keyCopy = keyCopy != null ? keyCopy : ICopy.ofSerializer(keySerializer, keyDeserializer);
+        this.valueCopy = valueCopy != null ? valueCopy : ICopy.ofSerializer(valueSerializer, valueDeserializer);
+        setCache(this.getter.get());
+    }
+
+    @Override
+    public void setValue(Map<K, V> value, boolean setSource, boolean sync) {
+        setCache(value);
+        onSetCache(setSource, sync);
+    }
+
+    protected void setCache(Map<K, V> value) {
+        this.cache.clear();
+        for (Map.Entry<K, V> entry : value.entrySet()) {
+            this.cache.put(this.keyCopy.createDeepCopy(entry.getKey()),
+                    this.valueCopy.createDeepCopy(entry.getValue()));
+        }
+    }
+
+    protected void onSetCache(boolean setSource, boolean sync) {
+        if (setSource && this.setter != null) {
+            this.setter.accept(getValue());
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        Map<K, V> map = this.getter.get();
+        if (isFirstSync || didValuesChange(map)) {
+            setValue(map, false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setValue(this.getter.get(), false, true);
+    }
+
+    protected boolean didValuesChange(Map<K, V> value) {
+        if (this.cache.size() != value.size()) return true;
+        for (Map.Entry<K, V> entry : this.cache.entrySet()) {
+            if (!value.containsKey(entry.getKey())) return true;
+            V v = value.get(entry.getKey());
+            if (!this.equals.areEqual(entry.getValue(), v)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(this.cache.size());
+        for (Map.Entry<K, V> entry : this.cache.entrySet()) {
+            this.keySerializer.serialize(buffer, entry.getKey());
+            this.valueSerializer.serialize(buffer, entry.getValue());
+        }
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        this.cache.clear();
+        int size = buffer.readVarInt();
+        for (int i = 0; i < size; i++) {
+            this.cache.put(this.keyDeserializer.deserialize(buffer), this.valueDeserializer.deserialize(buffer));
+        }
+        onSetCache(true, false);
+    }
+
+    @Override
+    public Map<K, V> getValue() {
+        return Collections.unmodifiableMap(this.cache);
+    }
+
+    @Override
+    public Class<Map<K, V>> getValueType() {
+        return (Class<Map<K, V>>) (Object) Map.class;
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method forces a sync after the modification.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(Consumer<Map<K, V>> consumer) {
+        modifyValue(true, true, consumer);
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method can automatically sync the cache after the modification. Be careful with potential issues when the
+     * sync arg is false.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(boolean setSource, boolean sync, Consumer<Map<K, V>> consumer) {
+        consumer.accept(this.cache);
+        onSetCache(setSource, sync);
+    }
+
+    public static class Builder<K, V> {
+
+        private Supplier<Map<K, V>> getter;
+        private Consumer<Map<K, V>> setter;
+        private IByteBufDeserializer<K> keyDeserializer;
+        private IByteBufDeserializer<V> valueDeserializer;
+        private IByteBufSerializer<K> keySerializer;
+        private IByteBufSerializer<V> valueSerializer;
+        private EqualityTest<V> equals;
+        private ICopy<K> keyCopy;
+        private ICopy<V> valueCopy;
+
+        public Builder<K, V> getter(Supplier<Map<K, V>> getter) {
+            this.getter = getter;
+            return this;
+        }
+
+        public Builder<K, V> setter(Consumer<Map<K, V>> setter) {
+            this.setter = setter;
+            return this;
+        }
+
+        public Builder<K, V> keyDeserializer(IByteBufDeserializer<K> keyDeserializer) {
+            this.keyDeserializer = keyDeserializer;
+            return this;
+        }
+
+        public Builder<K, V> valueDeserializer(IByteBufDeserializer<V> valueDeserializer) {
+            this.valueDeserializer = valueDeserializer;
+            return this;
+        }
+
+        public Builder<K, V> keySerializer(IByteBufSerializer<K> keySerializer) {
+            this.keySerializer = keySerializer;
+            return this;
+        }
+
+        public Builder<K, V> valueSerializer(IByteBufSerializer<V> valueSerializer) {
+            this.valueSerializer = valueSerializer;
+            return this;
+        }
+
+        public Builder<K, V> keyAdapter(IByteBufAdapter<K> adapter) {
+            return keyDeserializer(adapter).keySerializer(adapter);
+        }
+
+        public Builder<K, V> valueAdapter(IByteBufAdapter<V> adapter) {
+            return valueDeserializer(adapter).valueSerializer(adapter).equals(adapter);
+        }
+
+        public Builder<K, V> equals(EqualityTest<V> equals) {
+            this.equals = equals;
+            return this;
+        }
+
+        public Builder<K, V> keyCopy(ICopy<K> keyCopy) {
+            this.keyCopy = keyCopy;
+            return this;
+        }
+
+        public Builder<K, V> immutableKey() {
+            return keyCopy(ICopy.immutable());
+        }
+
+        public Builder<K, V> valueCopy(ICopy<V> valueCopy) {
+            this.valueCopy = valueCopy;
+            return this;
+        }
+
+        public Builder<K, V> immutableValue() {
+            return valueCopy(ICopy.immutable());
+        }
+
+        public GenericMapSyncHandler<K, V> build() {
+            if (this.getter == null) throw new NullPointerException("Getter in GenericMapSyncHandler must not be null");
+            if (this.keyDeserializer == null)
+                throw new NullPointerException("Key deserializer in GenericMapSyncHandler must not be null");
+            if (this.valueDeserializer == null)
+                throw new NullPointerException("Value deserializer in GenericMapSyncHandler must not be null");
+            if (this.keySerializer == null)
+                throw new NullPointerException("Key serializer in GenericMapSyncHandler must not be null");
+            if (this.valueSerializer == null)
+                throw new NullPointerException("Value serializer in GenericMapSyncHandler must not be null");
+            return new GenericMapSyncHandler<>(this.getter, this.setter, this.keyDeserializer, this.valueDeserializer,
+                    this.keySerializer,
+                    this.valueSerializer, this.equals, this.keyCopy, this.valueCopy);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericSetSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericSetSyncHandler.java
new file mode 100644
index 00000000000..df2a78231b9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericSetSyncHandler.java
@@ -0,0 +1,103 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufDeserializer;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufSerializer;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class GenericSetSyncHandler<T> extends GenericCollectionSyncHandler<T, Set<T>> {
+
+    private final Set<T> cache = new ObjectOpenHashSet<T>();
+
+    public GenericSetSyncHandler(@NotNull Supplier<Set<T>> getter, @Nullable Consumer<Set<T>> setter,
+                                 @NotNull IByteBufDeserializer<T> deserializer,
+                                 @NotNull IByteBufSerializer<T> serializer,
+                                 @Nullable ICopy<T> copy) {
+        super(getter, setter, deserializer, serializer, null, copy);
+        setCache(getter.get());
+    }
+
+    @Override
+    protected void setCache(Set<T> value) {
+        this.cache.clear();
+        for (T item : value) {
+            this.cache.add(copyValue(item));
+        }
+    }
+
+    @Override
+    protected boolean didValuesChange(Set<T> newValues) {
+        if (this.cache.size() != newValues.size()) return true;
+        return cache.containsAll(newValues);
+    }
+
+    @Override
+    public Set<T> getValue() {
+        return Collections.unmodifiableSet(this.cache);
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        this.cache.clear();
+        int size = buffer.readVarInt();
+        for (int i = 0; i < size; i++) {
+            this.cache.add(deserializeValue(buffer));
+        }
+        onSetCache(true, false);
+    }
+
+    @Override
+    public Class<Set<T>> getValueType() {
+        return (Class<Set<T>>) (Object) Set.class;
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method forces a sync after the modification.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(Consumer<Set<T>> consumer) {
+        modifyValue(true, true, consumer);
+    }
+
+    /**
+     * Allows safe modification of the cached value. Normally modifying the cached value can cause the value to never be
+     * synced.
+     * This method can automatically sync the cache after the modification. Be careful with potential issues when the
+     * sync arg is false.
+     *
+     * @param consumer function that operates on the current cached value
+     */
+    public void modifyValue(boolean setSource, boolean sync, Consumer<Set<T>> consumer) {
+        consumer.accept(this.cache);
+        onSetCache(setSource, sync);
+    }
+
+    public static <T> Builder<T> builder() {
+        return new Builder<>();
+    }
+
+    public static class Builder<T> extends GenericCollectionSyncHandler.Builder<T, Set<T>, Builder<T>> {
+
+        public GenericSetSyncHandler<T> build() {
+            if (this.getter == null) throw new NullPointerException("Getter in GenericSetSyncHandler must not be null");
+            if (this.deserializer == null)
+                throw new NullPointerException("Deserializer in GenericSetSyncHandler must not be null");
+            if (this.serializer == null)
+                throw new NullPointerException("Serializer in GenericSetSyncHandler must not be null");
+            return new GenericSetSyncHandler<>(this.getter, this.setter, this.deserializer, this.serializer, this.copy);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericSyncValue.java
new file mode 100644
index 00000000000..d60b3c1710e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/GenericSyncValue.java
@@ -0,0 +1,376 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.utils.EqualityTest;
+import com.gregtechceu.gtceu.utils.ICopy;
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufAdapter;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufDeserializer;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufSerializer;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * A highly configurable value sync handler for any type. The constructors are obsolete in favor of the builder.
+ * Create a builder with {@link #builder(Class)}, {@link #rawTypeBuilder(Class)} or {@link #notNullBuilder()}.
+ * Each of these methods has its uses, however you should always try to use the {@link #builder(Class)} method.
+ * <p>
+ * Example:
+ * <code>GenericSyncValue.builder(ItemStack.class)</code>
+ * <p>
+ * When you work with types which themselves have generic types, then your IDE will likely yell at you. In this case you
+ * can use
+ * {@link #rawTypeBuilder(Class)}. Only use this if you have to, since you can technically put any class inside there
+ * without ModularUI be
+ * able to verify it. Since you can't specify the type {@link T} with the type here you need to use the diamond
+ * operator.
+ * <p>
+ * Example: <code>GenericSyncValue.&lt;List&lt;ItemStack&gt;&gt;rawTypeBuilder(List.class)</code>
+ * <br>
+ * Note that you wouldn't actually use {@link java.util.List List} here. It's just an example for a type with a generic
+ * parameter.
+ * <p>
+ * If the value is never null you can also use {@link #notNullBuilder()}. This will infer the type with the value
+ * supplier.
+ * <p>
+ * Example: <code>GenericSyncValue.&lt;ItemStack&gt;notNullBuilder()</code>
+ * <p>
+ * <p>
+ * For collections, it is highly recommended to use {@link GenericListSyncHandler}, {@link GenericSetSyncHandler} or
+ * {@link GenericMapSyncHandler}. For custom collections {@link GenericCollectionSyncHandler} can be helpful.
+ *
+ * @param <T> type of the value to sync
+ */
+public class GenericSyncValue<T> extends AbstractGenericSyncValue<T> {
+
+    public static GenericSyncValue<ItemStack> forItem(@NotNull Supplier<ItemStack> getter,
+                                                      @Nullable Consumer<ItemStack> setter) {
+        return new GenericSyncValue<>(ItemStack.class, getter, setter, ByteBufAdapters.ITEM_STACK);
+    }
+
+    public static GenericSyncValue<FluidStack> forFluid(@NotNull Supplier<FluidStack> getter,
+                                                        @Nullable Consumer<FluidStack> setter) {
+        return new GenericSyncValue<>(FluidStack.class, getter, setter, ByteBufAdapters.FLUID_STACK);
+    }
+
+    private final IByteBufDeserializer<T> deserializer;
+    private final IByteBufSerializer<T> serializer;
+    private final EqualityTest<T> equals;
+    private final ICopy<T> copy;
+
+    @ApiStatus.Obsolete
+    public GenericSyncValue(@NotNull Class<T> type,
+                            @NotNull Supplier<T> getter,
+                            @Nullable Consumer<T> setter,
+                            @NotNull IByteBufAdapter<T> adapter,
+                            @Nullable ICopy<T> copy,
+                            boolean nullable) {
+        this(type, getter, setter, adapter, adapter, adapter, copy, nullable);
+    }
+
+    @ApiStatus.Obsolete
+    public GenericSyncValue(@NotNull Class<T> type,
+                            @NotNull Supplier<T> getter,
+                            @Nullable Consumer<T> setter,
+                            @NotNull IByteBufAdapter<T> adapter) {
+        this(type, getter, setter, adapter, adapter, adapter, null, false);
+    }
+
+    @ApiStatus.Obsolete
+    public GenericSyncValue(@NotNull Class<T> type,
+                            @NotNull Supplier<T> getter,
+                            @Nullable Consumer<T> setter,
+                            @NotNull IByteBufDeserializer<T> deserializer,
+                            @NotNull IByteBufSerializer<T> serializer,
+                            @Nullable EqualityTest<T> equals,
+                            @Nullable ICopy<T> copy,
+                            boolean nullable) {
+        super(type, getter, setter);
+        Objects.requireNonNull(deserializer);
+        Objects.requireNonNull(serializer);
+        this.deserializer = nullable ? IByteBufDeserializer.wrapNullSafe(deserializer) : deserializer;
+        this.serializer = nullable ? IByteBufSerializer.wrapNullSafe(serializer) : serializer;
+        if (equals == null) equals = EqualityTest.defaultTester();
+        this.equals = nullable ? EqualityTest.wrapNullSafe(equals) : equals;
+        if (copy == null) copy = ICopy.ofSerializer(serializer, deserializer);
+        this.copy = copy; // null check in createDeepCopyOf()
+    }
+
+    @Override
+    protected T createDeepCopyOf(T value) {
+        return value == null ? null : this.copy.createDeepCopy(value);
+    }
+
+    @Override
+    protected boolean areEqual(T a, T b) {
+        return this.equals.areEqual(a, b);
+    }
+
+    @Override
+    protected void serialize(FriendlyByteBuf buffer, T value) {
+        this.serializer.serialize(buffer, value);
+    }
+
+    @Override
+    protected T deserialize(FriendlyByteBuf buffer) {
+        return this.deserializer.deserialize(buffer);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <V> GenericSyncValue<V> cast() {
+        return (GenericSyncValue<V>) this;
+    }
+
+    /**
+     * Creates a builder for a generic sync value. This is the recommended builder method.
+     * The other builder methods are for when type has generic parameters.
+     *
+     * @param type Class of the value to sync. This is used to verify synced value types.
+     * @param <T>  type of the value to sync
+     * @return builder
+     */
+    public static <T> Builder<T> builder(Class<T> type) {
+        return new Builder<>(type);
+    }
+
+    /**
+     * Creates a builder for a generic sync value. This method should only be used if the type has generic parameters.
+     * The downside of this method is that the compiler can't verify the passed in class. Technically any class can be
+     * passed on,
+     * but issues will arise later down the line.
+     *
+     * @param type Class of the value to sync. This is used to verify synced value types.
+     * @param <T>  type of the value to sync
+     * @return builder
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> Builder<T> rawTypeBuilder(Class<?> type) {
+        return new Builder<T>((Class<T>) type);
+    }
+
+    /**
+     * Creates a builder for a generic sync value. This method should only be used if the value is never null.
+     * The class is inferred from the value of the value supplier once.
+     *
+     * @param <T> type of the value to sync
+     * @return builder
+     */
+    public static <T> Builder<T> notNullBuilder() {
+        return new Builder<>(null);
+    }
+
+    public static class Builder<T> {
+
+        private final Class<T> type;
+        private Supplier<T> getter;
+        private Consumer<T> setter;
+        private IByteBufDeserializer<T> deserializer;
+        private IByteBufSerializer<T> serializer;
+        private EqualityTest<T> equals;
+        private ICopy<T> copy;
+        private boolean nullable;
+
+        public Builder(Class<T> type) {
+            this.type = type;
+        }
+
+        /**
+         * Sets the getter for the sync value. Usually this returns a field in a
+         * {@link net.minecraft.world.level.block.entity.BlockEntity BlockEntity} or
+         * similar. On server side this is called every tick and compared to the sync values cache. If the values are
+         * different
+         * (determined by {@link #equals(EqualityTest)}), it is synced to the client.
+         * <p>
+         * <b>This setter is required!</b>
+         * </p>
+         *
+         * @param getter function that returns the current value that may be synced
+         * @return this builder
+         */
+        public Builder<T> getter(Supplier<T> getter) {
+            this.getter = getter;
+            return this;
+        }
+
+        /**
+         * Sets the setter for the sync value. Usually this sets a field in a
+         * {@link net.minecraft.world.level.block.entity.BlockEntity BlockEntity} or
+         * similar. This is called when a value is synced in client or server. In many cases this can be null since the
+         * synced value is
+         * cached inside the sync handler.
+         * <p>
+         * <b>This setter is optional!</b>
+         * </p>
+         *
+         * @param setter function that updates the source of the value
+         * @return this builder
+         */
+        public Builder<T> setter(Consumer<T> setter) {
+            this.setter = setter;
+            return this;
+        }
+
+        /**
+         * Sets a function which writes the value to a {@link FriendlyByteBuf}. The function is called every time the
+         * value is synced to the
+         * other side.
+         * <p>
+         * <b>This setter is required!</b>
+         * </p>
+         *
+         * @param deserializer function that writes the value to a packet buffer
+         * @return this builder
+         */
+        public Builder<T> deserializer(IByteBufDeserializer<T> deserializer) {
+            this.deserializer = deserializer;
+            return this;
+        }
+
+        /**
+         * Sets a function which reads the value from a {@link FriendlyByteBuf}. The function is called every time the
+         * value is synced to the
+         * other side.
+         * <p>
+         * <b>This setter is required!</b>
+         * </p>
+         *
+         * @param serializer function that reads the value from a packet buffer
+         * @return this builder
+         */
+        public Builder<T> serializer(IByteBufSerializer<T> serializer) {
+            this.serializer = serializer;
+            return this;
+        }
+
+        /**
+         * Sets a function which tests two instances of the value for differences. This function is called every tick on
+         * server to determine
+         * if the value from {@link #getter(Supplier)} needs to be synced. By default, this uses
+         * {@link Objects#equals(Object, Object)}.
+         * If your value does not implement {@link Object#equals(Object)}, then this setter must be called in order for
+         * it to function
+         * properly. Otherwise {@link Objects#equals(Object, Object)} always returns false since the instances will
+         * always be different,
+         * which causes the value to be synced every tick.
+         * <p>
+         * <b>This setter is optional!</b>
+         * </p>
+         *
+         * @param equals function that determines if two instances of the value are equal
+         * @return this builder
+         */
+        public Builder<T> equals(EqualityTest<T> equals) {
+            this.equals = equals;
+            return this;
+        }
+
+        /**
+         * Sets the equals function to {@link Objects#equals(Object, Object)}, which is the default function.
+         *
+         * @return this builder
+         * @see #equals(EqualityTest)
+         */
+        public Builder<T> equalsDefault() {
+            return equals(EqualityTest.defaultTester());
+        }
+
+        /**
+         * Sets a function which creates a copy of the value. This is called every time the value cache is updated. This
+         * is to prevent
+         * accidental mutations of the cache value. For example if you called {@link #setValue(Object)}, but keep a
+         * reference to the new
+         * value and then modify your reference, then the cached value is also updated since it's the same object. If
+         * now the
+         * {@link #getter(Supplier)} function happens to return exactly that reference, then the
+         * {@link #equals(EqualityTest)} function always
+         * compares its cache to itself (since it compare the cache to the getter value, which are the same in this
+         * case). This causes
+         * the value to be never synced from server to client.
+         * <p>
+         * By default, the {@link #serializer(IByteBufSerializer)} and {@link #deserializer(IByteBufDeserializer)}
+         * function are called to
+         * create a new instance. If these functions are implemented properly, it is always guaranteed to create a new
+         * instance of the
+         * value. However, it is still recommended to provide your own proper copy method.
+         * <p>
+         * If you know, that your values is immutable (can't be modified once created), then you can use
+         * {@link #copyImmutable()}.
+         * That function won't copy the value, but just return the value.
+         * <p>
+         * <b>This setter is optional!</b>
+         * </p>
+         *
+         * @param copy function that creates a new exact copy of the value
+         * @return this builder
+         */
+        public Builder<T> copy(ICopy<T> copy) {
+            this.copy = copy;
+            return this;
+        }
+
+        /**
+         * Sets a {@link #copy(ICopy)} function which assumes the values are always immutable. This should only be used
+         * if the value is
+         * always immutable (can't be modified once created). See {@link #copy(ICopy)} for more info.
+         *
+         * @return this builder
+         * @see #copy(ICopy)
+         */
+        public Builder<T> copyImmutable() {
+            return copy(ICopy.immutable());
+        }
+
+        /**
+         * Sets an adapter. This combines {@link #deserializer(IByteBufDeserializer)},
+         * {@link #serializer(IByteBufSerializer)} and
+         * {@link #equals(EqualityTest)} into one method.
+         *
+         * @param adapter byte buf adapter
+         * @return this builder
+         * @see #deserializer(IByteBufDeserializer)
+         * @see #serializer(IByteBufSerializer)
+         * @see #equals(EqualityTest)
+         */
+        public Builder<T> adapter(IByteBufAdapter<T> adapter) {
+            return deserializer(adapter)
+                    .serializer(adapter)
+                    .equals(adapter);
+        }
+
+        /**
+         * Sets the value to be nullable. This wraps all the used functions into null safe variants. This only for
+         * convenience.
+         * Manually having to consider nullability inside all the function is cumbersome. This setter is a shortcut.
+         * It is opt-in since, it creates a very minor overhead in the serializer and deserializer.
+         * <p>
+         * <b>This setter is optional!</b>
+         * </p>
+         *
+         * @return this builder
+         */
+        public Builder<T> nullable() {
+            this.nullable = true;
+            return this;
+        }
+
+        /**
+         * Creates the sync value from this builder.
+         *
+         * @return new sync value handler
+         * @throws NullPointerException     if the getter, serializer or deserializer is null
+         * @throws IllegalArgumentException if the value type is null and the getter returns null
+         */
+        public GenericSyncValue<T> build() {
+            return new GenericSyncValue<>(type, getter, setter, deserializer, serializer, equals, copy, nullable);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/IDynamicSyncNotifiable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/IDynamicSyncNotifiable.java
new file mode 100644
index 00000000000..41a42103254
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/IDynamicSyncNotifiable.java
@@ -0,0 +1,16 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.Consumer;
+
+public interface IDynamicSyncNotifiable {
+
+    /**
+     * An internal function which is used to link the {@link com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget}.
+     */
+    @ApiStatus.Internal
+    void attachDynamicWidgetListener(Consumer<IWidget> onWidgetUpdate);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ISyncRegistrar.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ISyncRegistrar.java
new file mode 100644
index 00000000000..c7980dcf4a0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ISyncRegistrar.java
@@ -0,0 +1,197 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.ISyncedAction;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.PlayerSlotGroup;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+
+import net.minecraft.world.entity.player.Player;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.items.wrapper.PlayerMainInvWrapper;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.NoSuchElementException;
+import java.util.function.Supplier;
+
+public interface ISyncRegistrar<S extends ISyncRegistrar<S>> {
+
+    boolean hasSyncHandler(SyncHandler syncHandler);
+
+    default S syncValue(String name, SyncHandler syncHandler) {
+        return syncValue(name, 0, syncHandler);
+    }
+
+    S syncValue(String name, int id, SyncHandler syncHandler);
+
+    default S syncValue(int id, SyncHandler syncHandler) {
+        return syncValue("_", id, syncHandler);
+    }
+
+    default S itemSlot(String key, ModularSlot slot) {
+        return itemSlot(key, 0, slot);
+    }
+
+    default S itemSlot(String key, int id, ModularSlot slot) {
+        return syncValue(key, id, new ItemSlotSyncHandler(slot));
+    }
+
+    default S itemSlot(int id, ModularSlot slot) {
+        return itemSlot("_", id, slot);
+    }
+
+    default DynamicSyncHandler dynamicSyncHandler(String key, DynamicSyncHandler.IWidgetProvider widgetProvider) {
+        return dynamicSyncHandler(key, 0, widgetProvider);
+    }
+
+    default DynamicSyncHandler dynamicSyncHandler(String key, int id,
+                                                  DynamicSyncHandler.IWidgetProvider widgetProvider) {
+        DynamicSyncHandler syncHandler = new DynamicSyncHandler().widgetProvider(widgetProvider);
+        syncValue(key, id, syncHandler);
+        return syncHandler;
+    }
+
+    IPanelHandler syncedPanel(String key, boolean subPanel, PanelSyncHandler.IPanelBuilder panelBuilder);
+
+    @Nullable
+    IPanelHandler findPanelHandlerNullable(String key);
+
+    default @NotNull IPanelHandler findPanelHandler(String key) {
+        IPanelHandler panelHandler = findPanelHandlerNullable(key);
+        if (panelHandler == null) {
+            throw new NoSuchElementException(
+                    "Expected to find panel sync handler with key '" + key + "', but none was found.");
+        }
+        return panelHandler;
+    }
+
+    S registerSlotGroup(SlotGroup slotGroup);
+
+    default S registerSlotGroup(String name, int rowSize, int shiftClickPriority) {
+        return registerSlotGroup(new SlotGroup(name, rowSize, shiftClickPriority, true));
+    }
+
+    default S registerSlotGroup(String name, int rowSize, boolean allowShiftTransfer) {
+        return registerSlotGroup(new SlotGroup(name, rowSize, 100, allowShiftTransfer));
+    }
+
+    default S registerSlotGroup(String name, int rowSize) {
+        return registerSlotGroup(new SlotGroup(name, rowSize, 100, true));
+    }
+
+    default S bindPlayerInventory(Player player) {
+        return bindPlayerInventory(player, ModularSlot::new);
+    }
+
+    default S bindPlayerInventory(Player player, @NotNull PanelSyncManager.SlotFunction slotFunction) {
+        if (getSlotGroup(PlayerSlotGroup.NAME) != null) {
+            throw new IllegalStateException("The player slot group is already registered!");
+        }
+        PlayerMainInvWrapper playerInventory = new PlayerMainInvWrapper(player.getInventory());
+        String key = "player";
+        for (int i = 0; i < 36; i++) {
+            itemSlot(key, i, slotFunction.apply(playerInventory, i).slotGroup(PlayerSlotGroup.NAME));
+        }
+        // player inv sorting is handled by bogosorter
+        registerSlotGroup(new PlayerSlotGroup(PlayerSlotGroup.NAME));
+        return (S) this;
+    }
+
+    default S registerSyncedAction(String mapKey, ISyncedAction action) {
+        return registerSyncedAction(mapKey, true, true, action);
+    }
+
+    default S registerSyncedAction(String mapKey, Side side, ISyncedAction action) {
+        return registerSyncedAction(mapKey, side.isClient(), side.isServer(), action);
+    }
+
+    default S registerClientSyncedAction(String mapKey, ISyncedAction action) {
+        return registerSyncedAction(mapKey, true, false, action);
+    }
+
+    default S registerServerSyncedAction(String mapKey, ISyncedAction action) {
+        return registerSyncedAction(mapKey, false, true, action);
+    }
+
+    S registerSyncedAction(String mapKey, boolean executeClient, boolean executeServer, ISyncedAction action);
+
+    default <T extends SyncHandler> T getOrCreateSyncHandler(String name, Class<T> clazz, Supplier<T> supplier) {
+        return getOrCreateSyncHandler(name, 0, clazz, supplier);
+    }
+
+    <T extends SyncHandler> T getOrCreateSyncHandler(String name, int id, Class<T> clazz, Supplier<T> supplier);
+
+    default <T extends SyncHandler> T getOrCreateSH(String name, Class<T> clazz, Supplier<T> supplier) {
+        return getOrCreateSyncHandler(name, 0, clazz, supplier);
+    }
+
+    default <T extends SyncHandler> T getOrCreateSH(String name, int id, Class<T> clazz, Supplier<T> supplier) {
+        return getOrCreateSyncHandler(name, id, clazz, supplier);
+    }
+
+    default ItemSlotSyncHandler getOrCreateSlot(String name, Supplier<ModularSlot> slotSupplier) {
+        return getOrCreateSlot(name, 0, slotSupplier);
+    }
+
+    default ItemSlotSyncHandler getOrCreateSlot(String name, int id, Supplier<ModularSlot> slotSupplier) {
+        return getOrCreateSyncHandler(name, id, ItemSlotSyncHandler.class,
+                () -> new ItemSlotSyncHandler(slotSupplier.get()));
+    }
+
+    @Nullable
+    SyncHandler findSyncHandlerNullable(String name, int id);
+
+    default @Nullable SyncHandler findSyncHandlerNullable(String name) {
+        return findSyncHandlerNullable(name, 0);
+    }
+
+    default @NotNull SyncHandler findSyncHandler(String name, int id) {
+        SyncHandler syncHandler = findSyncHandlerNullable(name, id);
+        if (syncHandler == null) {
+            throw new NoSuchElementException(
+                    "Expected to find sync handler with key '" + makeSyncKey(name, id) + "', but none was found.");
+        }
+        return syncHandler;
+    }
+
+    default @NotNull SyncHandler findSyncHandler(String name) {
+        return findSyncHandler(name, 0);
+    }
+
+    default <T extends SyncHandler> @Nullable T findSyncHandlerNullable(String name, int id, Class<T> type) {
+        SyncHandler syncHandler = findSyncHandlerNullable(name, id);
+        if (syncHandler != null && type.isAssignableFrom(syncHandler.getClass())) {
+            return type.cast(syncHandler);
+        }
+        return null;
+    }
+
+    default <T extends SyncHandler> @Nullable T findSyncHandlerNullable(String name, Class<T> type) {
+        return findSyncHandlerNullable(name, 0, type);
+    }
+
+    default <T extends SyncHandler> @NotNull T findSyncHandler(String name, int id, Class<T> type) {
+        SyncHandler syncHandler = findSyncHandlerNullable(name, id);
+        if (syncHandler == null) {
+            throw new NoSuchElementException(
+                    "Expected to find sync handler with key '" + makeSyncKey(name, id) + "', but none was found.");
+        }
+        if (!type.isAssignableFrom(syncHandler.getClass())) {
+            throw new ClassCastException("Expected to find sync handler with key '" + makeSyncKey(name, id) +
+                    "' of type '" + type.getName() + "', but found type '" + syncHandler.getClass().getName() + "'.");
+        }
+        return type.cast(syncHandler);
+    }
+
+    default <T extends SyncHandler> @NotNull T findSyncHandler(String name, Class<T> type) {
+        return findSyncHandler(name, 0, type);
+    }
+
+    SlotGroup getSlotGroup(String name);
+
+    static String makeSyncKey(String name, int id) {
+        return name + ":" + id;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/IntSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/IntSyncValue.java
new file mode 100644
index 00000000000..01fba34865d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/IntSyncValue.java
@@ -0,0 +1,130 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IDoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IIntSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IStringSyncValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.IntConsumer;
+import java.util.function.IntSupplier;
+
+public class IntSyncValue extends ValueSyncHandler<Integer>
+                          implements IIntSyncValue<Integer>, IDoubleSyncValue<Integer>, IStringSyncValue<Integer> {
+
+    private int cache;
+    private final IntSupplier getter;
+    private final IntConsumer setter;
+
+    public IntSyncValue(@NotNull IntSupplier getter, @Nullable IntConsumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getAsInt();
+    }
+
+    public IntSyncValue(@NotNull IntSupplier getter) {
+        this(getter, (IntConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public IntSyncValue(@Nullable IntSupplier clientGetter,
+                        @Nullable IntSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public IntSyncValue(@Nullable IntSupplier clientGetter, @Nullable IntConsumer clientSetter,
+                        @Nullable IntSupplier serverGetter, @Nullable IntConsumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getAsInt();
+    }
+
+    @Override
+    public Integer getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public int getIntValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(Integer value, boolean setSource, boolean sync) {
+        setIntValue(value, setSource, sync);
+    }
+
+    @Override
+    public void setIntValue(int value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.accept(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public void setDoubleValue(double value, boolean setSource, boolean sync) {
+        setIntValue((int) value, setSource, sync);
+    }
+
+    @Override
+    public double getDoubleValue() {
+        return cache;
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getAsInt() != this.cache) {
+            setIntValue(this.getter.getAsInt(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setIntValue(this.getter.getAsInt(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(this.cache);
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setIntValue(buffer.readVarInt(), true, false);
+    }
+
+    @Override
+    public void setStringValue(String value, boolean setSource, boolean sync) {
+        setIntValue(Integer.parseInt(value), setSource, sync);
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.cache);
+    }
+
+    @Override
+    public Class<Integer> getValueType() {
+        return Integer.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/InteractionSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/InteractionSyncHandler.java
new file mode 100644
index 00000000000..bd2439c4f29
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/InteractionSyncHandler.java
@@ -0,0 +1,168 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IServerKeyboardAction;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IServerMouseAction;
+import com.gregtechceu.gtceu.api.mui.utils.KeyboardData;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+public class InteractionSyncHandler extends SyncHandler {
+
+    private IServerMouseAction mousePressed;
+    private IServerMouseAction mouseReleased;
+    private IServerMouseAction mouseTapped;
+    private IServerMouseAction mouseScroll;
+    private IServerKeyboardAction keyPressed;
+    private IServerKeyboardAction keyReleased;
+    private IServerKeyboardAction keyTapped;
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {}
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        if (id < 10) {
+            MouseData mouseData = MouseData.readPacket(buf);
+            switch (id) {
+                case 1: {
+                    if (this.mousePressed != null) {
+                        this.mousePressed.onServerMouseAction(mouseData);
+                    }
+                    break;
+                }
+                case 2: {
+                    if (this.mouseReleased != null) {
+                        this.mouseReleased.onServerMouseAction(mouseData);
+                    }
+                    break;
+                }
+                case 3: {
+                    if (this.mouseTapped != null) {
+                        this.mouseTapped.onServerMouseAction(mouseData);
+                    }
+                    break;
+                }
+                case 4: {
+                    if (this.mouseScroll != null) {
+                        this.mouseScroll.onServerMouseAction(mouseData);
+                    }
+                    break;
+                }
+            }
+        } else if (id > 10) {
+            KeyboardData keyboardData = KeyboardData.readPacket(buf);
+            switch (id) {
+                case 11: {
+                    if (this.keyPressed != null) {
+                        this.keyPressed.onServerKeyboardAction(keyboardData);
+                    }
+                    break;
+                }
+                case 12: {
+                    if (this.keyReleased != null) {
+                        this.keyReleased.onServerKeyboardAction(keyboardData);
+                    }
+                    break;
+                }
+                case 13: {
+                    if (this.keyTapped != null) {
+                        this.keyTapped.onServerKeyboardAction(keyboardData);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    public boolean onMousePressed(int button) {
+        if (this.mousePressed == null) return false;
+        MouseData mouseData = MouseData.create(button);
+        this.mousePressed.onServerMouseAction(mouseData);
+        syncToServer(1, mouseData::writeToPacket);
+        return true;
+    }
+
+    public boolean onMouseReleased(int button) {
+        if (this.mouseReleased == null) return false;
+        MouseData mouseData = MouseData.create(button);
+        this.mouseReleased.onServerMouseAction(mouseData);
+        syncToServer(2, mouseData::writeToPacket);
+        return true;
+    }
+
+    public boolean onMouseTapped(int button) {
+        if (this.mouseTapped == null) return false;
+        MouseData mouseData = MouseData.create(button);
+        this.mouseTapped.onServerMouseAction(mouseData);
+        syncToServer(3, mouseData::writeToPacket);
+        return true;
+    }
+
+    public boolean onMouseScroll(int scroll) {
+        if (this.mouseScroll == null) return false;
+        MouseData mouseData = MouseData.create(scroll);
+        this.mouseScroll.onServerMouseAction(mouseData);
+        syncToServer(4, mouseData::writeToPacket);
+        return true;
+    }
+
+    public boolean onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        if (this.keyPressed == null) return false;
+        KeyboardData keyboardData = KeyboardData.create(keyCode, scanCode, modifiers);
+        this.keyPressed.onServerKeyboardAction(keyboardData);
+        syncToServer(11, keyboardData::writeToPacket);
+        return true;
+    }
+
+    public boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        if (this.keyReleased == null) return false;
+        KeyboardData keyboardData = KeyboardData.create(keyCode, scanCode, modifiers);
+        this.keyReleased.onServerKeyboardAction(keyboardData);
+        syncToServer(12, keyboardData::writeToPacket);
+        return true;
+    }
+
+    public boolean onKeyTapped(int keyCode, int scanCode, int modifiers) {
+        if (this.keyTapped == null) return false;
+        KeyboardData keyboardData = KeyboardData.create(keyCode, scanCode, modifiers);
+        this.keyTapped.onServerKeyboardAction(keyboardData);
+        syncToServer(13, keyboardData::writeToPacket);
+        return true;
+    }
+
+    public InteractionSyncHandler setOnMousePressed(IServerMouseAction mouseAction) {
+        this.mousePressed = mouseAction;
+        return this;
+    }
+
+    public InteractionSyncHandler setOnMouseReleased(IServerMouseAction mouseAction) {
+        this.mouseReleased = mouseAction;
+        return this;
+    }
+
+    public InteractionSyncHandler setOnMouseTapped(IServerMouseAction mouseAction) {
+        this.mouseTapped = mouseAction;
+        return this;
+    }
+
+    public InteractionSyncHandler setOnMouseScroll(IServerMouseAction mouseAction) {
+        this.mouseScroll = mouseAction;
+        return this;
+    }
+
+    public InteractionSyncHandler setOnKeyPressed(IServerKeyboardAction keyboardAction) {
+        this.keyPressed = keyboardAction;
+        return this;
+    }
+
+    public InteractionSyncHandler setOnKeyReleased(IServerKeyboardAction keyboardAction) {
+        this.keyReleased = keyboardAction;
+        return this;
+    }
+
+    public InteractionSyncHandler setOnKeyTapped(IServerKeyboardAction keyboardAction) {
+        this.keyTapped = keyboardAction;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ItemSlotSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ItemSlotSyncHandler.java
new file mode 100644
index 00000000000..3998f85ad8b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ItemSlotSyncHandler.java
@@ -0,0 +1,150 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.PlayerSlotType;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.ItemHandlerHelper;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Wraps a slot and handles interactions for phantom slots.
+ * Use {@link ModularSlot} directly.
+ */
+public class ItemSlotSyncHandler extends SyncHandler {
+
+    public static final int SYNC_ITEM = 0;
+    public static final int SYNC_ENABLED = 1;
+
+    @Getter
+    private final ModularSlot slot;
+    @Nullable
+    @Getter
+    private final PlayerSlotType playerSlotType;
+    private ItemStack lastStoredItem;
+    private boolean registered = false;
+
+    public ItemSlotSyncHandler(ModularSlot slot) {
+        this.slot = slot;
+        this.playerSlotType = PlayerSlotType.getPlayerSlotType(slot);
+    }
+
+    @Override
+    public void init(String key, PanelSyncManager syncHandler) {
+        super.init(key, syncHandler);
+        if (!registered) {
+            this.slot.initialize(this, isPhantom());
+            getSyncManager().getContainer().registerSlot(getSyncManager().getPanelName(), this.slot);
+            this.registered = true;
+        }
+        this.lastStoredItem = getSlot().getItem().copy();
+    }
+
+    @Override
+    public void dispose() {
+        super.dispose();
+        this.slot.dispose();
+    }
+
+    @Override
+    public void detectAndSendChanges(boolean init) {
+        checkUpdate(init);
+    }
+
+    public void checkUpdate() {
+        checkUpdate(false);
+    }
+
+    private void checkUpdate(boolean init) {
+        if (!isValid() || getSyncManager().isClient()) return;
+        ItemStack itemStack = getSlot().getItem();
+        if (itemStack.isEmpty() && this.lastStoredItem.isEmpty()) return;
+        boolean onlyAmountChanged = false;
+        if (init ||
+                !ItemHandlerHelper.canItemStacksStack(this.lastStoredItem, itemStack) ||
+                (onlyAmountChanged = itemStack.getCount() != this.lastStoredItem.getCount())) {
+            onSlotUpdate(itemStack, onlyAmountChanged, false, init);
+            if (onlyAmountChanged) {
+                this.lastStoredItem.setCount(itemStack.getCount());
+            } else {
+                this.lastStoredItem = itemStack.isEmpty() ? ItemStack.EMPTY : itemStack.copy();
+            }
+            final boolean finalOnlyAmountChanged = onlyAmountChanged;
+            final boolean forceSync = false;
+            syncToClient(SYNC_ITEM, buffer -> {
+                buffer.writeBoolean(finalOnlyAmountChanged);
+                buffer.writeItem(itemStack);
+                buffer.writeBoolean(init);
+                buffer.writeBoolean(forceSync);
+            });
+        }
+    }
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_ITEM) {
+            boolean onlyAmountChanged = buf.readBoolean();
+            this.lastStoredItem = buf.readItem();
+            onSlotUpdate(this.lastStoredItem, onlyAmountChanged, true, buf.readBoolean());
+            if (buf.readBoolean()) {
+                // force sync
+                this.slot.set(this.lastStoredItem);
+            }
+        } else if (id == SYNC_ENABLED) {
+            setEnabled(buf.readBoolean(), false);
+        }
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_ENABLED) {
+            setEnabled(buf.readBoolean(), false);
+        }
+    }
+
+    protected void onSlotUpdate(ItemStack stack, boolean onlyAmountChanged, boolean client, boolean init) {
+        getSlot().onSlotChangedReal(stack, onlyAmountChanged, client, init);
+    }
+
+    public void setEnabled(boolean enabled, boolean sync) {
+        this.slot.setEnabled(enabled);
+        if (sync) {
+            sync(SYNC_ENABLED, buffer -> buffer.writeBoolean(enabled));
+        }
+    }
+
+    public void forceSyncItem() {
+        boolean onlyAmountChanged = false;
+        ItemStack stack = slot.getItem();
+        boolean init = false;
+        boolean forceSync = true;
+        onSlotUpdate(stack, onlyAmountChanged, getSyncManager().isClient(), init);
+        this.lastStoredItem = stack.isEmpty() ? ItemStack.EMPTY : stack;
+        syncToClient(SYNC_ITEM, buffer -> {
+            buffer.writeBoolean(onlyAmountChanged);
+            buffer.writeItem(stack);
+            buffer.writeBoolean(init);
+            buffer.writeBoolean(forceSync);
+        });
+    }
+
+    public boolean isItemValid(ItemStack itemStack) {
+        return getSlot().mayPlace(itemStack);
+    }
+
+    public boolean isPhantom() {
+        return false;
+    }
+
+    public boolean isPlayerSlot() {
+        return playerSlotType != null;
+    }
+
+    @Nullable
+    public String getSlotGroup() {
+        return this.slot.getSlotGroupName();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/LongArraySyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/LongArraySyncValue.java
new file mode 100644
index 00000000000..2320ff41055
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/LongArraySyncValue.java
@@ -0,0 +1,20 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class LongArraySyncValue extends GenericSyncValue<long[]> {
+
+    public LongArraySyncValue(@NotNull Supplier<long[]> getter, @Nullable Consumer<long[]> setter) {
+        this(getter, setter, false);
+    }
+
+    public LongArraySyncValue(@NotNull Supplier<long[]> getter, @Nullable Consumer<long[]> setter, boolean nullable) {
+        super(long[].class, getter, setter, ByteBufAdapters.LONG_ARR, long[]::clone, nullable);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/LongSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/LongSyncValue.java
new file mode 100644
index 00000000000..0696cd13cd8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/LongSyncValue.java
@@ -0,0 +1,130 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IIntSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.ILongSyncValue;
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IStringSyncValue;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.LongConsumer;
+import java.util.function.LongSupplier;
+
+public class LongSyncValue extends ValueSyncHandler<Long>
+                           implements ILongSyncValue<Long>, IIntSyncValue<Long>, IStringSyncValue<Long> {
+
+    private final LongSupplier getter;
+    private final LongConsumer setter;
+    private long cache;
+
+    public LongSyncValue(@NotNull LongSupplier getter, @Nullable LongConsumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getAsLong();
+    }
+
+    public LongSyncValue(@NotNull LongSupplier getter) {
+        this(getter, (LongConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public LongSyncValue(@Nullable LongSupplier clientGetter,
+                         @Nullable LongSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public LongSyncValue(@Nullable LongSupplier clientGetter, @Nullable LongConsumer clientSetter,
+                         @Nullable LongSupplier serverGetter, @Nullable LongConsumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (GTCEu.isClientThread()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getAsLong();
+    }
+
+    @Override
+    public Long getValue() {
+        return this.cache;
+    }
+
+    @Override
+    public long getLongValue() {
+        return this.cache;
+    }
+
+    @Override
+    public void setValue(Long value, boolean setSource, boolean sync) {
+        setLongValue(value, setSource, sync);
+    }
+
+    @Override
+    public void setLongValue(long value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.accept(value);
+        }
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getAsLong() != this.cache) {
+            setLongValue(this.getter.getAsLong(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void notifyUpdate() {
+        setLongValue(this.getter.getAsLong(), false, true);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeVarLong(getLongValue());
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        setValue(buffer.readVarLong(), true, false);
+    }
+
+    @Override
+    public void setIntValue(int value, boolean setSource, boolean sync) {
+        setLongValue(value, setSource, sync);
+    }
+
+    @Override
+    public void setStringValue(String value, boolean setSource, boolean sync) {
+        setLongValue(Long.parseLong(value), setSource, sync);
+    }
+
+    @Override
+    public int getIntValue() {
+        return (int) this.cache;
+    }
+
+    @Override
+    public String getStringValue() {
+        return String.valueOf(this.cache);
+    }
+
+    @Override
+    public Class<Long> getValueType() {
+        return Long.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ModularSyncManager.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ModularSyncManager.java
new file mode 100644
index 00000000000..4f53a2ce07f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ModularSyncManager.java
@@ -0,0 +1,248 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.ISyncedAction;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.PlayerSlotGroup;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.SlotItemHandler;
+import net.minecraftforge.items.wrapper.PlayerInvWrapper;
+import net.minecraftforge.items.wrapper.PlayerMainInvWrapper;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+
+public class ModularSyncManager implements ISyncRegistrar<ModularSyncManager> {
+
+    public static final String AUTO_SYNC_PREFIX = "auto_sync:";
+    private static final String CURSOR_KEY = ISyncRegistrar.makeSyncKey("cursor_slot", 255255);
+
+    private final Map<String, PanelSyncManager> panelSyncManagerMap = new Object2ObjectOpenHashMap<>();
+    // A set of all panels which have been opened during the ui. May also contain closed panels.
+    // This is used to detect if
+    private final Set<String> panelHistory = new ObjectOpenHashSet<>();
+    @Getter
+    private PanelSyncManager mainPSM;
+    @Getter
+    private ModularContainerMenu menu;
+    private final CursorSlotSyncHandler cursorSlotSyncHandler = new CursorSlotSyncHandler();
+    @Getter
+    private final boolean client;
+    private State state = State.INIT;
+
+    public ModularSyncManager(boolean client) {
+        this.client = client;
+    }
+
+    void setMainPSM(PanelSyncManager mainPSM) {
+        this.mainPSM = mainPSM;
+    }
+
+    @ApiStatus.Internal
+    public void construct(ModularContainerMenu menu, String mainPanelName) {
+        this.menu = menu;
+        if (this.mainPSM.getSlotGroup(PlayerSlotGroup.NAME) == null) {
+            this.mainPSM.bindPlayerInventory(getPlayer());
+        }
+        this.mainPSM.syncValue(CURSOR_KEY, this.cursorSlotSyncHandler);
+        open(mainPanelName, this.mainPSM);
+    }
+
+    @ApiStatus.Internal
+    public void detectAndSendChanges(boolean init) {
+        this.panelSyncManagerMap.values().forEach(psm -> psm.detectAndSendChanges(init));
+    }
+
+    @ApiStatus.Internal
+    public void dispose() {
+        if (isDisposed()) return;
+        if (!isClosed()) throw new IllegalStateException("Sync manager must be closed before disposing!");
+        this.panelSyncManagerMap.values().forEach(PanelSyncManager::onClose);
+        this.panelSyncManagerMap.clear();
+        this.menu.disposed();
+        setState(State.DISPOSED);
+    }
+
+    @ApiStatus.Internal
+    public void onOpen() {
+        if (isOpen()) return;
+        if (isDisposed()) throw new IllegalStateException("Can't open sync manager after it has been disposed!");
+        if (this.menu == null) {
+            throw new IllegalStateException(
+                    "Sync Manager can't be opened when its not yet constructed. ModularContainer is null.");
+        }
+        setState(State.OPEN);
+        this.panelSyncManagerMap.values().forEach(PanelSyncManager::onOpen);
+        this.menu.opened();
+    }
+
+    @ApiStatus.Internal
+    public void onClose() {
+        if (!isOpen()) throw new IllegalStateException();
+        this.menu.closed();
+        setState(State.CLOSED);
+    }
+
+    public void onUpdate() {
+        this.panelSyncManagerMap.values().forEach(PanelSyncManager::onUpdate);
+    }
+
+    public PanelSyncManager getPanelSyncManager(String panelName) {
+        PanelSyncManager psm = this.panelSyncManagerMap.get(panelName);
+        if (psm != null) return psm;
+        throw new NullPointerException("No PanelSyncManager found for name '" + panelName + "'!");
+    }
+
+    @Nullable
+    public SyncHandler getSyncHandler(String panelName, String syncKey) {
+        return getPanelSyncManager(panelName).getSyncHandlerFromMapKey(syncKey);
+    }
+
+    public SlotGroup getSlotGroup(String panelName, String slotGroupName) {
+        return getPanelSyncManager(panelName).getSlotGroup(slotGroupName);
+    }
+
+    public ItemStack getCursorItem() {
+        return getPlayer().containerMenu.getCarried();
+    }
+
+    public void setCursorItem(ItemStack item) {
+        getPlayer().containerMenu.setCarried(item);
+        this.cursorSlotSyncHandler.sync();
+    }
+
+    @ApiStatus.Internal
+    public void open(String name, PanelSyncManager syncManager) {
+        this.panelSyncManagerMap.put(name, syncManager);
+        this.panelHistory.add(name);
+        syncManager.initialize(name);
+    }
+
+    @ApiStatus.Internal
+    public void close(String name) {
+        PanelSyncManager psm = this.panelSyncManagerMap.remove(name);
+        if (psm != null) psm.onClose();
+    }
+
+    public boolean isOpen(String panelName) {
+        return this.panelSyncManagerMap.containsKey(panelName);
+    }
+
+    @ApiStatus.Internal
+    public void receiveWidgetUpdate(String panelName, String mapKey, boolean action, int id, FriendlyByteBuf buf) {
+        PanelSyncManager psm = this.panelSyncManagerMap.get(panelName);
+        if (psm != null) {
+            psm.receiveWidgetUpdate(mapKey, action, id, buf);
+        } else if (!this.panelHistory.contains(panelName)) {
+            GTCEu.LOGGER.throwing(new IllegalStateException(
+                    "A packet was send to panel '\" + panelName + \"' which was not opened yet!"));
+        }
+        // else the panel was open at some point
+        // we simply discard the packet silently and assume the packet was correctly send, but the panel closed earlier
+    }
+
+    public Player getPlayer() {
+        return this.menu.getPlayer();
+    }
+
+    private static boolean isPlayerSlot(Slot slot) {
+        if (slot == null) return false;
+        if (slot.container instanceof Inventory) {
+            return slot.getSlotIndex() >= 0 && slot.getSlotIndex() < 36;
+        }
+        if (slot instanceof SlotItemHandler slotItemHandler) {
+            IItemHandler iItemHandler = slotItemHandler.getItemHandler();
+            if (iItemHandler instanceof PlayerMainInvWrapper || iItemHandler instanceof PlayerInvWrapper) {
+                return slot.getSlotIndex() >= 0 && slot.getSlotIndex() < 36;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean hasSyncHandler(SyncHandler syncHandler) {
+        return this.mainPSM.hasSyncHandler(syncHandler);
+    }
+
+    @Override
+    public ModularSyncManager syncValue(String name, int id, SyncHandler syncHandler) {
+        this.mainPSM.syncValue(name, id, syncHandler);
+        return this;
+    }
+
+    @Override
+    public IPanelHandler syncedPanel(String key, boolean subPanel, PanelSyncHandler.IPanelBuilder panelBuilder) {
+        return this.mainPSM.syncedPanel(key, subPanel, panelBuilder);
+    }
+
+    @Override
+    public @Nullable IPanelHandler findPanelHandlerNullable(String key) {
+        return this.mainPSM.findPanelHandlerNullable(key);
+    }
+
+    @Override
+    public ModularSyncManager registerSlotGroup(SlotGroup slotGroup) {
+        this.mainPSM.registerSlotGroup(slotGroup);
+        return this;
+    }
+
+    @Override
+    public ModularSyncManager registerSyncedAction(String mapKey, boolean executeClient, boolean executeServer,
+                                                   ISyncedAction action) {
+        this.mainPSM.registerSyncedAction(mapKey, executeClient, executeServer, action);
+        return this;
+    }
+
+    @Override
+    public <T extends SyncHandler> T getOrCreateSyncHandler(String name, int id, Class<T> clazz, Supplier<T> supplier) {
+        return this.mainPSM.getOrCreateSyncHandler(name, id, clazz, supplier);
+    }
+
+    @Override
+    public @Nullable SyncHandler findSyncHandlerNullable(String name, int id) {
+        return this.mainPSM.findSyncHandlerNullable(name, id);
+    }
+
+    @Override
+    public SlotGroup getSlotGroup(String name) {
+        return this.mainPSM.getSlotGroup(name);
+    }
+
+    public boolean isOpen() {
+        return this.state == State.OPEN;
+    }
+
+    public boolean isClosed() {
+        return this.state == State.CLOSED || this.state == State.DISPOSED;
+    }
+
+    public boolean isDisposed() {
+        return this.state == State.DISPOSED;
+    }
+
+    private void setState(State state) {
+        this.state = state;
+    }
+
+    enum State {
+        INIT,
+        OPEN,
+        CLOSED,
+        DISPOSED;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PanelSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PanelSyncHandler.java
new file mode 100644
index 00000000000..496989b2608
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PanelSyncHandler.java
@@ -0,0 +1,196 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.widget.ISynced;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * If you want another panel where some widgets may be able to sync data, you will need this.
+ * Register it in any {@link PanelSyncManager} (preferably the main one).
+ * Then you can call {@link #openPanel()} and {@link #closePanel()} from any side.
+ */
+public final class PanelSyncHandler extends SyncHandler implements IPanelHandler {
+
+    public static final int SYNC_NOTIFY_OPEN = 0;
+    public static final int SYNC_OPEN = 1;
+    public static final int SYNC_CLOSE = 2;
+    public static final int SYNC_DISPOSE = 3;
+
+    private final IPanelBuilder panelBuilder;
+    private final boolean subPanel;
+    private String panelName;
+    private ModularPanel openedPanel;
+    private PanelSyncManager syncManager;
+    private boolean open = false;
+
+    /**
+     * Creates a PanelSyncHandler
+     *
+     * @param panelBuilder a panel builder function
+     */
+    PanelSyncHandler(IPanelBuilder panelBuilder, boolean subPanel) {
+        this.panelBuilder = panelBuilder;
+        this.subPanel = subPanel;
+    }
+
+    public ModularPanel createUI(PanelSyncManager syncManager) {
+        return this.panelBuilder.buildUI(syncManager, this);
+    }
+
+    @Override
+    public void openPanel() {
+        openPanel(true);
+    }
+
+    private void openPanel(boolean syncToServer) {
+        if (isPanelOpen()) return;
+        boolean client = getSyncManager().isClient();
+        if (syncToServer && client) {
+            syncToServer(SYNC_NOTIFY_OPEN);
+            return;
+        }
+        if (this.syncManager != null &&
+                this.syncManager.getModularSyncManager() != getSyncManager().getModularSyncManager()) {
+            throw new IllegalStateException("Can't reopen synced panel in another screen!");
+        } else if (this.syncManager == null) {
+            this.syncManager = new PanelSyncManager(getSyncManager().getModularSyncManager(), false);
+            this.openedPanel = Objects.requireNonNull(createUI(this.syncManager));
+            this.panelName = this.openedPanel.getName();
+            this.openedPanel.setPanelSyncHandler(this);
+            WidgetTree.collectSyncValues(this.syncManager, this.openedPanel, false);
+            if (!client) {
+                this.openedPanel = null;
+            }
+        }
+        if (client) {
+            ModularScreen screen = getSyncManager().getContainer().getScreen();
+            if (!screen.isPanelOpen(this.openedPanel.getName())) {
+                openInModularSyncManager();
+                screen.getPanelManager().openPanel(this.openedPanel, this);
+            } else {
+                // this was not supposed to happen
+                // make sure server side also closes the panel
+                closePanelInternal();
+                return;
+            }
+        } else {
+            openInModularSyncManager();
+        }
+        this.open = true;
+    }
+
+    private void openInModularSyncManager() {
+        getSyncManager().getModularSyncManager().open(this.panelName, this.syncManager);
+    }
+
+    @Override
+    public void closePanel() {
+        if (getSyncManager().isClient()) {
+            if (this.openedPanel != null) {
+                this.openedPanel.closeIfOpen();
+            }
+        } else {
+            syncToClient(SYNC_CLOSE);
+        }
+    }
+
+    @Override
+    public void closeSubPanels() {
+        this.syncManager.closeSubPanels();
+    }
+
+    @ApiStatus.Internal
+    @Override
+    public void closePanelInternal() {
+        getSyncManager().getModularSyncManager().close(this.panelName);
+        this.open = false;
+        if (getSyncManager().isClient()) {
+            syncToServer(SYNC_CLOSE);
+        }
+    }
+
+    @Override
+    public void deleteCachedPanel() {
+        if (openedPanel == null || isPanelOpen()) return;
+        boolean canDispose = WidgetTree.foreachChild(openedPanel, iWidget -> {
+            if (iWidget instanceof ISynced<?> synced && synced.isSynced()) {
+                return !(synced.getSyncHandler() instanceof ItemSlotSyncHandler);
+            }
+            return true;
+        }, false);
+
+        // This is because we can't guarantee that the sync handlers of the new panel are the same.
+        // Dynamic sync handler changing is very error-prone.
+        if (!canDispose) {
+            throw new UnsupportedOperationException(
+                    "Can't delete cached panel if it's still open or has ItemSlot Sync Handlers!");
+        }
+        disposePanel();
+
+        sync(SYNC_DISPOSE);
+    }
+
+    private void disposePanel() {
+        this.panelName = null;
+        this.syncManager = null;
+        this.openedPanel = null;
+    }
+
+    @Override
+    public boolean isSubPanel() {
+        return subPanel;
+    }
+
+    @Override
+    public boolean isPanelOpen() {
+        return this.open;
+    }
+
+    @Override
+    public void readOnClient(int i, FriendlyByteBuf packetBuffer) {
+        if (i == SYNC_OPEN) {
+            openPanel(false);
+        } else if (i == SYNC_CLOSE) {
+            closePanel();
+        } else if (i == SYNC_DISPOSE) {
+            disposePanel();
+        }
+    }
+
+    @Override
+    public void readOnServer(int i, FriendlyByteBuf packetBuffer) {
+        if (i == SYNC_NOTIFY_OPEN) {
+            openPanel(false);
+            syncToClient(SYNC_OPEN);
+        } else if (i == SYNC_CLOSE) {
+            closePanelInternal();
+        } else if (i == SYNC_DISPOSE) {
+            disposePanel();
+        }
+    }
+
+    /**
+     * A function which creates a secondary {@link ModularPanel}
+     */
+    public interface IPanelBuilder {
+
+        /**
+         * Creates a {@link ModularPanel}. It must NOT return null or the main panel.
+         *
+         * @param syncManager the sync manager for this panel
+         * @param syncHandler the sync handler that sync opening and closing of this panel
+         * @return the created panel
+         */
+        @NotNull
+        ModularPanel buildUI(@NotNull PanelSyncManager syncManager, @NotNull IPanelHandler syncHandler);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PanelSyncManager.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PanelSyncManager.java
new file mode 100644
index 00000000000..5ab90e838fc
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PanelSyncManager.java
@@ -0,0 +1,396 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.ISyncedAction;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.wrapper.PlayerMainInvWrapper;
+
+import io.netty.buffer.Unpooled;
+import it.unimi.dsi.fastutil.objects.*;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class PanelSyncManager implements ISyncRegistrar<PanelSyncManager> {
+
+    private final Map<String, SyncHandler> syncHandlers = new Object2ReferenceLinkedOpenHashMap<>();
+    private final Map<String, SlotGroup> slotGroups = new Object2ReferenceOpenHashMap<>();
+    private final Map<SyncHandler, String> reverseSyncHandlers = new Object2ReferenceOpenHashMap<>();
+    private final Map<String, SyncedAction> syncedActions = new Object2ReferenceOpenHashMap<>();
+    private final Map<String, PanelSyncHandler> subPanels = new Object2ReferenceArrayMap<>();
+    @Getter
+    private final ModularSyncManager modularSyncManager;
+    @Getter
+    private String panelName;
+    private boolean init = true;
+    @Getter
+    private boolean locked = false;
+    private boolean allowSyncHandlerRegistration = false;
+    @Getter
+    private final boolean client;
+
+    private final List<Consumer<Player>> openListener = new ArrayList<>();
+    private final List<Consumer<Player>> closeListener = new ArrayList<>();
+    private final List<Runnable> tickListener = new ArrayList<>();
+
+    @ApiStatus.Internal
+    public PanelSyncManager(ModularSyncManager msm, boolean main) {
+        this.modularSyncManager = msm;
+        this.client = msm.isClient();
+        if (main) msm.setMainPSM(this);
+    }
+
+    @ApiStatus.Internal
+    public void initialize(String panelName) {
+        this.panelName = panelName;
+        this.syncHandlers.forEach((mapKey, syncHandler) -> syncHandler.init(mapKey, this));
+        this.locked = true;
+        this.init = true;
+        this.subPanels.forEach(
+                (s, syncHandler) -> this.modularSyncManager.getMainPSM().registerPanelSyncHandler(s, syncHandler));
+    }
+
+    private void registerPanelSyncHandler(String name, SyncHandler syncHandler) {
+        // only called on main psm
+        SyncHandler currentSh = this.syncHandlers.get(name);
+        if (currentSh != null && currentSh != syncHandler) {
+            throw new IllegalStateException("Failed to register panel sync handler during initialization. " +
+                    "There already exists a sync handler for the name '" + name + "'.");
+        }
+        String currentName = this.reverseSyncHandlers.get(syncHandler);
+        if (currentName != null && !name.equals(currentName)) {
+            throw new IllegalStateException(
+                    "Failed to register panel sync handler for name '" + name + "' during initialization. " +
+                            "The panel sync handler is already registered under the name '" + currentName + "'.");
+        }
+        this.syncHandlers.put(name, syncHandler);
+        this.reverseSyncHandlers.put(syncHandler, name);
+        syncHandler.init(name, this);
+    }
+
+    void closeSubPanels() {
+        this.subPanels.values().forEach(syncHandler -> {
+            if (syncHandler.isSubPanel()) {
+                syncHandler.closePanel();
+            }
+        });
+    }
+
+    @ApiStatus.Internal
+    public void onOpen() {
+        this.openListener.forEach(listener -> listener.accept(getPlayer()));
+    }
+
+    @ApiStatus.Internal
+    public void onClose() {
+        this.closeListener.forEach(listener -> listener.accept(getPlayer()));
+        this.syncHandlers.values().forEach(SyncHandler::dispose);
+        // previously panel sync handlers were removed from the main psm, however this problematic if the screen will be
+        // reopened at some point.
+        // we can just not remove the sync handlers since mui has proper checks for re-registering panels
+    }
+
+    public boolean isInitialised() {
+        return this.panelName != null;
+    }
+
+    void detectAndSendChanges(boolean init) {
+        if (!isClient()) {
+            for (SyncHandler syncHandler : this.syncHandlers.values()) {
+                syncHandler.detectAndSendChanges(init || this.init);
+            }
+        }
+        this.init = false;
+    }
+
+    void onUpdate() {
+        this.tickListener.forEach(Runnable::run);
+    }
+
+    @ApiStatus.Internal
+    public void receiveWidgetUpdate(String mapKey, boolean action, int id, FriendlyByteBuf buf) {
+        if (action) {
+            invokeSyncedAction(mapKey, buf);
+            return;
+        }
+
+        if (!this.syncHandlers.containsKey(mapKey)) {
+            GTCEu.LOGGER.warn("SyncHandler '{}' does not exist for panel '{}'! ID was {}.", mapKey, panelName, id);
+            return;
+        }
+        SyncHandler syncHandler = this.syncHandlers.get(mapKey);
+        if (isClient()) {
+            syncHandler.readOnClient(id, buf);
+        } else {
+            syncHandler.readOnServer(id, buf);
+        }
+    }
+
+    private boolean invokeSyncedAction(String mapKey, FriendlyByteBuf buf) {
+        SyncedAction syncedAction = this.syncedActions.get(mapKey);
+        if (syncedAction == null) {
+            GTCEu.LOGGER.warn("SyncAction '{}' does not exist for panel '{}'!.", mapKey, panelName);
+            return false;
+        }
+        if (!isLocked() || this.allowSyncHandlerRegistration || !syncedAction.isExecuteClient() ||
+                !syncedAction.isExecuteServer()) {
+            syncedAction.invoke(this.client, buf);
+        } else {
+            // only allow sync handler registration if it is executed on client and server
+            allowTemporarySyncHandlerRegistration(true);
+            syncedAction.invoke(this.client, buf);
+            allowTemporarySyncHandlerRegistration(false);
+        }
+        // true if the action should be executed on the other side
+        return syncedAction.isExecute(!this.client);
+    }
+
+    public ItemStack getCursorItem() {
+        return getModularSyncManager().getCursorItem();
+    }
+
+    public void setCursorItem(ItemStack stack) {
+        getModularSyncManager().setCursorItem(stack);
+    }
+
+    @Override
+    public boolean hasSyncHandler(SyncHandler syncHandler) {
+        if (this.reverseSyncHandlers.containsKey(syncHandler)) return true;
+        return this != getHyperVisor() && getHyperVisor().hasSyncHandler(syncHandler);
+    }
+
+    private void putSyncValue(String name, int id, SyncHandler syncHandler) {
+        if (isLocked()) {
+            // registration of sync handlers forbidden
+            if (this.allowSyncHandlerRegistration) {
+                // lock can be bypassed currently, but it wasn't used
+                throw new IllegalStateException(
+                        "SyncHandlers must be registered during panel building. Please use getOrCreateSyncHandler() inside DynamicSyncHandler!");
+            } else {
+                throw new IllegalStateException(
+                        "SyncHandlers must be registered during panel building. The only exceptions is via a DynamicSyncHandler and sync functions!");
+            }
+        }
+        String key = makeSyncKey(name, id);
+        String currentKey = this.reverseSyncHandlers.get(syncHandler);
+        if (currentKey != null) {
+            if (!currentKey.equals(key)) {
+                boolean auto = name.startsWith(ModularSyncManager.AUTO_SYNC_PREFIX);
+                if (auto != currentKey.startsWith(ModularSyncManager.AUTO_SYNC_PREFIX)) {
+                    throw new IllegalStateException(
+                            "Old and new sync handler must both be either not auto or auto! (old key = \"%s\", new key = \"%s\""
+                                    .formatted(currentKey, key));
+                }
+                if (auto && !currentKey.startsWith(name)) {
+                    throw new IllegalStateException("Sync Handler was previously added with a different panel!");
+                }
+            }
+            this.syncHandlers.remove(currentKey);
+        }
+        this.syncHandlers.put(key, syncHandler);
+        this.reverseSyncHandlers.put(syncHandler, key);
+        if (isInitialised()) {
+            syncHandler.init(key, this);
+        }
+    }
+
+    @Override
+    public PanelSyncManager syncValue(String name, int id, SyncHandler syncHandler) {
+        Objects.requireNonNull(name, "Name must not be null");
+        Objects.requireNonNull(syncHandler, "Sync Handler must not be null");
+        putSyncValue(name, id, syncHandler);
+        return this;
+    }
+
+    /**
+     * Creates a synced panel handler. This can be used to automatically handle syncing for synced panels.
+     * Synced panels do not need to be synced themselves, but contain at least one widget which is synced.
+     * <p>
+     * <b>NOTE</b>
+     * </p>
+     * A panel sync handler is only created once. If one was already registered, that one will be returned.
+     * (This is only relevant for nested sub panels.) Furthermore, the panel handler has to be created on client and
+     * server with the same
+     * key. Like any other sync handler, the panel sync handler has to be created before the panel opened. The only
+     * exception is inside
+     * dynamic sync handlers.
+     *
+     * @param key          the key used for syncing
+     * @param subPanel     true if this panel should close when its parent closes (the parent is defined by <i>this</i>
+     *                     {@link PanelSyncManager})
+     * @param panelBuilder the panel builder, that will create the new panel. It must not return null or any existing
+     *                     panels.
+     * @return a synced panel handler.
+     * @throws NullPointerException     if the build panel of the builder is null
+     * @throws IllegalArgumentException if the build panel of the builder is the main panel
+     * @throws IllegalStateException    if this method was called too late
+     */
+    @Override
+    public IPanelHandler syncedPanel(String key, boolean subPanel, PanelSyncHandler.IPanelBuilder panelBuilder) {
+        IPanelHandler ph = findPanelHandlerNullable(key);
+        if (ph != null) return ph;
+        if (isLocked() && !this.allowSyncHandlerRegistration) {
+            // registration of sync handlers forbidden
+            throw new IllegalStateException(
+                    "Synced panels must be registered during panel building. The only exceptions is via a DynamicSyncHandler and sync functions!");
+        }
+        PanelSyncHandler syncHandler = new PanelSyncHandler(panelBuilder, subPanel);
+        this.subPanels.put(key, syncHandler);
+        if (isInitialised() && (this == this.modularSyncManager.getMainPSM() ||
+                this.modularSyncManager.getMainPSM().findSyncHandlerNullable(this.panelName, PanelSyncHandler.class) ==
+                        null)) {
+            // current panel is open
+            this.modularSyncManager.getMainPSM().registerPanelSyncHandler(key, syncHandler);
+        }
+        return syncHandler;
+    }
+
+    @Override
+    public @Nullable IPanelHandler findPanelHandlerNullable(String key) {
+        return this.subPanels.get(key);
+    }
+
+    @Override
+    public PanelSyncManager registerSlotGroup(SlotGroup slotGroup) {
+        if (!slotGroup.isSingleton()) {
+            this.slotGroups.put(slotGroup.getName(), slotGroup);
+        }
+        return this;
+    }
+
+    public interface SlotFunction {
+
+        @NotNull
+        ModularSlot apply(@NotNull PlayerMainInvWrapper playerInv, int index);
+    }
+
+    public PanelSyncManager addOpenListener(Consumer<Player> listener) {
+        this.openListener.add(listener);
+        return this;
+    }
+
+    public PanelSyncManager addCloseListener(Consumer<Player> listener) {
+        this.closeListener.add(listener);
+        return this;
+    }
+
+    public PanelSyncManager onClientTick(Runnable runnable) {
+        if (this.client) {
+            this.tickListener.add(runnable);
+        }
+        return this;
+    }
+
+    public PanelSyncManager onServerTick(Runnable runnable) {
+        if (!this.client) {
+            this.tickListener.add(runnable);
+        }
+        return this;
+    }
+
+    public PanelSyncManager onCommonTick(Runnable runnable) {
+        this.tickListener.add(runnable);
+        return this;
+    }
+
+    @Override
+    public PanelSyncManager registerSyncedAction(String mapKey, boolean executeClient, boolean executeServer,
+                                                 ISyncedAction action) {
+        if (executeClient || executeServer) {
+            this.syncedActions.put(mapKey, new SyncedAction(action, executeClient, executeServer));
+        }
+        return this;
+    }
+
+    public void callSyncedAction(String mapKey, FriendlyByteBuf packet) {
+        if (invokeSyncedAction(mapKey, packet)) {
+            ModularNetwork.get(isClient()).sendActionPacket(getModularSyncManager(), this.panelName, mapKey, packet,
+                    getPlayer());
+        }
+    }
+
+    public void callSyncedAction(String mapKey, Consumer<FriendlyByteBuf> packetBuilder) {
+        FriendlyByteBuf packet = new FriendlyByteBuf(Unpooled.buffer());
+        packetBuilder.accept(packet);
+        callSyncedAction(mapKey, packet);
+    }
+
+    public void callSyncedAction(String mapKey) {
+        callSyncedAction(mapKey, new FriendlyByteBuf(Unpooled.buffer(0)));
+    }
+
+    @Override
+    public <T extends SyncHandler> T getOrCreateSyncHandler(String name, int id, Class<T> clazz, Supplier<T> supplier) {
+        SyncHandler syncHandler = findSyncHandlerNullable(name, id);
+        if (syncHandler == null) {
+            if (isLocked() && !this.allowSyncHandlerRegistration) {
+                // registration is locked, and we don't have permission to temporarily bypass lock
+                throw new IllegalStateException(
+                        "SyncHandlers must be registered during panel building. The only exceptions is via a DynamicSyncHandler and sync functions!");
+            }
+            T t = supplier.get();
+            boolean l = this.locked;
+            this.locked = false; // bypass possible lock
+            putSyncValue(name, id, t);
+            this.locked = l;
+            return t;
+        }
+
+        if (clazz.isAssignableFrom(syncHandler.getClass())) {
+            return clazz.cast(syncHandler);
+        }
+        throw new IllegalStateException("SyncHandler for key " + makeSyncKey(name, id) + " is of type " +
+                syncHandler.getClass() + ", but type " + clazz + " was expected!");
+    }
+
+    @Override
+    public SlotGroup getSlotGroup(String name) {
+        return this.slotGroups.get(name);
+    }
+
+    public Collection<SlotGroup> getSlotGroups() {
+        return this.slotGroups.values();
+    }
+
+    public @Nullable SyncHandler getSyncHandlerFromMapKey(String mapKey) {
+        return this.syncHandlers.get(mapKey);
+    }
+
+    @Override
+    public @Nullable SyncHandler findSyncHandlerNullable(String name, int id) {
+        return this.syncHandlers.get(makeSyncKey(name, id));
+    }
+
+    public Player getPlayer() {
+        return getModularSyncManager().getPlayer();
+    }
+
+    public ISyncRegistrar<?> getHyperVisor() {
+        return this.modularSyncManager.getMainPSM();
+    }
+
+    public ModularContainerMenu getContainer() {
+        return getModularSyncManager().getMenu();
+    }
+
+    void allowTemporarySyncHandlerRegistration(boolean allow) {
+        this.allowSyncHandlerRegistration = allow;
+    }
+
+    public static String makeSyncKey(String name, int id) {
+        return name + ":" + id;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PhantomItemSlotSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PhantomItemSlotSyncHandler.java
new file mode 100644
index 00000000000..bff3949be63
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/PhantomItemSlotSyncHandler.java
@@ -0,0 +1,161 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.items.ItemHandlerHelper;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Wraps a slot and handles interactions for phantom slots.
+ * Use {@link ModularSlot} directly.
+ */
+public class PhantomItemSlotSyncHandler extends ItemSlotSyncHandler {
+
+    public static final int SYNC_CLICK = 100;
+    public static final int SYNC_SCROLL = 101;
+    public static final int SYNC_ITEM_SIMPLE = 102;
+
+    private ItemStack lastStoredPhantomItem = ItemStack.EMPTY;
+
+    @ApiStatus.Internal
+    public PhantomItemSlotSyncHandler(ModularSlot slot) {
+        super(slot);
+        ((Slot) slot).index = -1;
+    }
+
+    @Override
+    public void init(String key, PanelSyncManager syncHandler) {
+        super.init(key, syncHandler);
+        if (isPhantom() && !getSlot().getItem().isEmpty()) {
+            this.lastStoredPhantomItem = getSlot().getItem().copy();
+            this.lastStoredPhantomItem.setCount(1);
+        }
+    }
+
+    @Override
+    protected void onSlotUpdate(ItemStack stack, boolean onlyAmountChanged, boolean client, boolean init) {
+        getSlot().set(stack);
+        if (!onlyAmountChanged && !stack.isEmpty()) {
+            // store last non-empty stack for later
+            this.lastStoredPhantomItem = stack.copy();
+            this.lastStoredPhantomItem.setCount(1);
+        }
+        super.onSlotUpdate(stack, onlyAmountChanged, client, init);
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        super.readOnServer(id, buf);
+        if (id == SYNC_CLICK) {
+            phantomClick(MouseData.readPacket(buf));
+        } else if (id == SYNC_SCROLL) {
+            phantomScroll(MouseData.readPacket(buf));
+        } else if (id == SYNC_ITEM_SIMPLE) {
+            if (!isPhantom()) return;
+            phantomClick(new MouseData(Dist.DEDICATED_SERVER, 0, false, false, false), buf.readItem());
+        }
+    }
+
+    public void updateFromClient(ItemStack stack) {
+        syncToServer(SYNC_ITEM_SIMPLE, buf -> buf.writeItem(stack));
+    }
+
+    protected void phantomClick(MouseData mouseData) {
+        phantomClick(mouseData, getSyncManager().getCursorItem());
+    }
+
+    protected void phantomClick(MouseData mouseData, ItemStack cursorStack) {
+        ItemStack slotStack = getSlot().getItem();
+        ItemStack stackToPut;
+        if (!cursorStack.isEmpty() && !slotStack.isEmpty() &&
+                !ItemHandlerHelper.canItemStacksStack(cursorStack, slotStack)) {
+            if (!isItemValid(cursorStack)) return;
+            stackToPut = cursorStack.copy();
+            if (mouseData.mouseButton() == 1) {
+                stackToPut.setCount(1);
+            }
+            stackToPut.setCount(Math.min(stackToPut.getCount(), getSlot().getMaxStackSize(stackToPut)));
+            getSlot().set(stackToPut);
+            this.lastStoredPhantomItem = stackToPut.copy();
+        } else if (slotStack.isEmpty()) {
+            if (cursorStack.isEmpty()) {
+                if (mouseData.mouseButton() == 1 && !this.lastStoredPhantomItem.isEmpty()) {
+                    stackToPut = this.lastStoredPhantomItem.copy();
+                } else {
+                    return;
+                }
+            } else {
+                if (!isItemValid(cursorStack)) return;
+                stackToPut = cursorStack.copy();
+            }
+            if (mouseData.mouseButton() == 1) {
+                stackToPut.setCount(1);
+            }
+            stackToPut.setCount(Math.min(stackToPut.getCount(), getSlot().getMaxStackSize(stackToPut)));
+            getSlot().set(stackToPut);
+            this.lastStoredPhantomItem = stackToPut.copy();
+        } else {
+            if (mouseData.mouseButton() == 0) {
+                if (mouseData.shift()) {
+                    getSlot().set(ItemStack.EMPTY);
+                } else {
+                    incrementStackCount(-1);
+                }
+            } else if (mouseData.mouseButton() == 1) {
+                incrementStackCount(1);
+            }
+        }
+    }
+
+    protected void phantomScroll(MouseData mouseData) {
+        ItemStack currentItem = getSlot().getItem();
+        int amount = mouseData.mouseButton();
+        if (mouseData.shift()) amount *= 4;
+        if (mouseData.ctrl()) amount *= 16;
+        if (mouseData.alt()) amount *= 64;
+        if (amount > 0 && currentItem.isEmpty() && !this.lastStoredPhantomItem.isEmpty()) {
+            ItemStack stackToPut = this.lastStoredPhantomItem.copy();
+            stackToPut.setCount(amount);
+            getSlot().set(stackToPut);
+        } else {
+            incrementStackCount(amount);
+        }
+    }
+
+    public void incrementStackCount(int amount) {
+        ItemStack stack = getSlot().getItem();
+        if (stack.isEmpty()) {
+            return;
+        }
+        int oldAmount = stack.getCount();
+        if (amount < 0) {
+            amount = Math.max(0, oldAmount + amount);
+        } else {
+            if (Integer.MAX_VALUE - amount < oldAmount) {
+                amount = Integer.MAX_VALUE;
+            } else {
+                int maxSize = getSlot().getMaxStackSize();
+                if (!getSlot().isIgnoreMaxStackSize() && stack.getMaxStackSize() < maxSize) {
+                    maxSize = stack.getMaxStackSize();
+                }
+                amount = Math.min(oldAmount + amount, maxSize);
+            }
+        }
+        if (oldAmount != amount) {
+            stack = stack.copy();
+            stack.setCount(amount);
+            getSlot().set(stack);
+        }
+    }
+
+    @Override
+    public boolean isPhantom() {
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/StringSyncValue.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/StringSyncValue.java
new file mode 100644
index 00000000000..1e59df14920
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/StringSyncValue.java
@@ -0,0 +1,67 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IStringSyncValue;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class StringSyncValue extends AbstractGenericSyncValue<String> implements IStringSyncValue<String> {
+
+    public StringSyncValue(Supplier<String> getter, Consumer<String> setter) {
+        super(String.class, getter, setter);
+    }
+
+    public StringSyncValue(@NotNull Supplier<String> getter) {
+        this(getter, (Consumer<String>) null);
+    }
+
+    @Contract("null, null -> fail")
+    public StringSyncValue(@Nullable Supplier<String> clientGetter,
+                           @Nullable Supplier<String> serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public StringSyncValue(@Nullable Supplier<String> clientGetter, @Nullable Consumer<String> clientSetter,
+                           @Nullable Supplier<String> serverGetter, @Nullable Consumer<String> serverSetter) {
+        super(String.class, clientGetter, clientSetter, serverGetter, serverSetter);
+    }
+
+    @Override
+    protected String createDeepCopyOf(String value) {
+        return value;
+    }
+
+    @Override
+    protected boolean areEqual(String a, String b) {
+        return Objects.equals(a, b);
+    }
+
+    @Override
+    protected void serialize(FriendlyByteBuf buffer, String value) {
+        NetworkUtils.writeStringSafe(buffer, value, Short.MAX_VALUE - 74);
+    }
+
+    @Override
+    protected String deserialize(FriendlyByteBuf buffer) {
+        return NetworkUtils.readStringSafe(buffer);
+    }
+
+    @Override
+    public String getStringValue() {
+        return getValue();
+    }
+
+    @Override
+    public void setStringValue(String value, boolean setSource, boolean sync) {
+        setValue(value, setSource, sync);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncHandler.java
new file mode 100644
index 00000000000..6150cbbb246
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncHandler.java
@@ -0,0 +1,191 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.IPacketWriter;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+import com.gregtechceu.gtceu.common.network.ModularNetworkSide;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import io.netty.buffer.Unpooled;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.MustBeInvokedByOverriders;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * Base class for handling syncing of widgets.
+ * A sync handler must exist on client and server.
+ * It must be configured exactly the same to avoid issues.
+ */
+public abstract class SyncHandler implements ISyncOrValue {
+
+    private PanelSyncManager syncManager;
+    /**
+     * the key that belongs to this sync handler
+     */
+    @Getter
+    private String key;
+
+    @ApiStatus.OverrideOnly
+    @MustBeInvokedByOverriders
+    public void init(String key, PanelSyncManager syncManager) {
+        this.key = key;
+        this.syncManager = syncManager;
+    }
+
+    @ApiStatus.OverrideOnly
+    @MustBeInvokedByOverriders
+    public void dispose() {
+        this.key = null;
+        this.syncManager = null;
+    }
+
+    /**
+     * Syncs a custom packet to the client
+     *
+     * @param id             an internal denominator to identify this package
+     * @param bufferConsumer the package builder
+     */
+    public final void syncToClient(int id, @NotNull IPacketWriter bufferConsumer) {
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        buffer.writeVarInt(id);
+        bufferConsumer.write(buffer);
+        sendToClient(getSyncManager().getPanelName(), buffer, this);
+    }
+
+    /**
+     * Syncs a custom packet to the server
+     *
+     * @param id             an internal denominator to identify this package
+     * @param bufferConsumer the package builder
+     */
+    @OnlyIn(Dist.CLIENT)
+    public final void syncToServer(int id, @NotNull IPacketWriter bufferConsumer) {
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        buffer.writeVarInt(id);
+        bufferConsumer.write(buffer);
+        sendToServer(getSyncManager().getPanelName(), buffer, this);
+    }
+
+    /**
+     * Sync a custom packet to the other side.
+     *
+     * @param id             an internal denominator to identify this package
+     * @param bufferConsumer the package builder
+     */
+    public final void sync(int id, @NotNull IPacketWriter bufferConsumer) {
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        buffer.writeVarInt(id);
+        bufferConsumer.write(buffer);
+        send(ModularNetwork.get(getSyncManager().isClient()), getSyncManager().getPanelName(), buffer, this);
+    }
+
+    /**
+     * Sends an empty packet to the client with an id.
+     *
+     * @param id identifier
+     */
+    public final void syncToClient(int id) {
+        syncToClient(id, buf -> {});
+    }
+
+    /**
+     * Sends an empty packet to the server with an id.
+     *
+     * @param id identifier
+     */
+    public final void syncToServer(int id) {
+        syncToServer(id, buf -> {});
+    }
+
+    /**
+     * Sends an empty packet to the other side with an id.
+     *
+     * @param id identifier
+     */
+    public final void sync(int id) {
+        sync(id, buf -> {});
+    }
+
+    /**
+     * Called when this sync handler receives a packet on client.
+     *
+     * @param id  an internal denominator to identify this package
+     * @param buf package
+     */
+    @ApiStatus.OverrideOnly
+    @OnlyIn(Dist.CLIENT)
+    public abstract void readOnClient(int id, FriendlyByteBuf buf);
+
+    /**
+     * Called when this sync handler receives a packet on server.
+     *
+     * @param id  an internal denominator to identify this package
+     * @param buf package
+     */
+    @ApiStatus.OverrideOnly
+    public abstract void readOnServer(int id, FriendlyByteBuf buf);
+
+    /**
+     * Called at least every tick. Use it to compare a cached value to its original and sync it.
+     * This is only called on the server side.
+     *
+     * @param init if this method is being called the first time.
+     */
+    public void detectAndSendChanges(boolean init) {}
+
+    /**
+     * @return is this sync handler has been initialised yet
+     */
+    public final boolean isValid() {
+        return this.key != null && this.syncManager != null;
+    }
+
+    /**
+     * @return the sync handler manager handling this sync handler
+     */
+    public PanelSyncManager getSyncManager() {
+        if (!isValid()) {
+            throw new IllegalStateException("Sync handler is not yet initialised!");
+        }
+        return this.syncManager;
+    }
+
+    public final boolean isRegistered(PanelSyncManager syncManager) {
+        if (isValid() && this.syncManager.hasSyncHandler(this)) {
+            return true;
+        }
+        return syncManager.hasSyncHandler(this);
+    }
+
+    @Override
+    public boolean isSyncHandler() {
+        return true;
+    }
+
+    private static void send(ModularNetworkSide network, String panel, FriendlyByteBuf buffer,
+                             SyncHandler syncHandler) {
+        Objects.requireNonNull(buffer);
+        Objects.requireNonNull(syncHandler);
+        if (!syncHandler.isValid()) {
+            throw new IllegalStateException("Not initialized sync handlers can't send packets!");
+        }
+        network.sendSyncHandlerPacket(panel, syncHandler, buffer, syncHandler.syncManager.getPlayer());
+    }
+
+    public static void sendToClient(String panel, FriendlyByteBuf buffer, SyncHandler syncHandler) {
+        send(ModularNetwork.SERVER, panel, buffer, syncHandler);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static void sendToServer(String panel, FriendlyByteBuf buffer, SyncHandler syncHandler) {
+        send(ModularNetwork.CLIENT, panel, buffer, syncHandler);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncHandlers.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncHandlers.java
new file mode 100644
index 00000000000..9a33c4146d1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncHandlers.java
@@ -0,0 +1,56 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.items.IItemHandlerModifiable;
+
+import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
+
+import java.util.function.*;
+
+public class SyncHandlers {
+
+    private SyncHandlers() {}
+
+    public static IntSyncValue intNumber(IntSupplier getter, IntConsumer setter) {
+        return new IntSyncValue(getter, setter);
+    }
+
+    public static LongSyncValue longNumber(LongSupplier getter, LongConsumer setter) {
+        return new LongSyncValue(getter, setter);
+    }
+
+    public static BooleanSyncValue bool(BooleanSupplier getter, BooleanConsumer setter) {
+        return new BooleanSyncValue(getter, setter);
+    }
+
+    public static DoubleSyncValue doubleNumber(DoubleSupplier getter, DoubleConsumer setter) {
+        return new DoubleSyncValue(getter, setter);
+    }
+
+    public static StringSyncValue string(Supplier<String> getter, Consumer<String> setter) {
+        return new StringSyncValue(getter, setter);
+    }
+
+    public static ModularSlot phantomItemSlot(IItemHandlerModifiable inventory, int index) {
+        return new ModularSlot(inventory, index, true);
+    }
+
+    public static ModularSlot itemSlot(IItemHandlerModifiable inventory, int index) {
+        return new ModularSlot(inventory, index);
+    }
+
+    public static FluidSlotSyncHandler fluidSlot(IFluidTank fluidTank) {
+        return new FluidSlotSyncHandler(fluidTank);
+    }
+
+    public static <T extends Enum<T>> EnumSyncValue<T> enumValue(Class<T> clazz, Supplier<T> getter,
+                                                                 Consumer<T> setter) {
+        return new EnumSyncValue<>(clazz, getter, setter);
+    }
+
+    public static <T> GenericSyncValue.Builder<T> generic(Class<T> type) {
+        return GenericSyncValue.builder(type);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncedAction.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncedAction.java
new file mode 100644
index 00000000000..3c6dc9f85c7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/SyncedAction.java
@@ -0,0 +1,35 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.ISyncedAction;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+public class SyncedAction {
+
+    private final ISyncedAction action;
+    @Getter
+    private final boolean executeClient;
+    @Getter
+    private final boolean executeServer;
+
+    public SyncedAction(ISyncedAction action, boolean executeClient, boolean executeServer) {
+        this.action = action;
+        this.executeClient = executeClient;
+        this.executeServer = executeServer;
+    }
+
+    public boolean invoke(boolean client, @NotNull FriendlyByteBuf packet) {
+        if (isExecute(client)) {
+            this.action.invoke(packet);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isExecute(boolean client) {
+        return (client && this.executeClient) || (!client && this.executeServer);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ValueSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ValueSyncHandler.java
new file mode 100644
index 00000000000..b70bd31a991
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/value/sync/ValueSyncHandler.java
@@ -0,0 +1,46 @@
+package com.gregtechceu.gtceu.api.mui.value.sync;
+
+import com.gregtechceu.gtceu.api.mui.base.value.sync.IValueSyncHandler;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public abstract class ValueSyncHandler<T> extends SyncHandler implements IValueSyncHandler<T> {
+
+    public static final int SYNC_VALUE = 0;
+
+    @Getter
+    @Setter
+    private Runnable changeListener;
+
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_VALUE) read(buf);
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_VALUE) read(buf);
+    }
+
+    protected void sync() {
+        sync(SYNC_VALUE, this::write);
+    }
+
+    @Override
+    public void detectAndSendChanges(boolean init) {
+        if (updateCacheFromSource(init)) sync();
+    }
+
+    /**
+     * Called when the cached value of this sync handler updates. Implementations need to call this inside
+     * {@link #setValue(Object, boolean, boolean)}.
+     */
+    protected void onValueChanged() {
+        if (this.changeListener != null) {
+            this.changeListener.run();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractParentWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractParentWidget.java
new file mode 100644
index 00000000000..220063d3cd3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractParentWidget.java
@@ -0,0 +1,140 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widgets.VoidWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A widget which can hold any amount of children.
+ *
+ * @param <I> type of children (in most cases just {@link IWidget}). Use {@link VoidWidget} if no children should be
+ *            added.
+ * @param <W> type of this widget
+ */
+public class AbstractParentWidget<I extends IWidget, W extends AbstractParentWidget<I, W>> extends Widget<W> {
+
+    private final List<I> children = new ArrayList<>();
+
+    /**
+     * A list of all children of this widget. The list is modifiable contrary to the annotation.
+     * This just means that you shouldn't carelessly modify the list. Adding to the list also requires initialising the
+     * new child.
+     * Removing requires disposing the old child.
+     *
+     * @return a view of all children.
+     */
+    @SuppressWarnings("unchecked")
+    @UnmodifiableView
+    @NotNull
+    @Override
+    public List<IWidget> getChildren() {
+        return (List<IWidget>) this.children;
+    }
+
+    /**
+     * A list of all children of this widget with the given children type {@link I}. The list is modifiable contrary to
+     * the annotation.
+     * This just means that you shouldn't carelessly modify the list. Adding to the list also requires initialising the
+     * new child.
+     * Removing requires disposing the old child.
+     *
+     * @return a view of all children.
+     */
+    @UnmodifiableView
+    public List<I> getTypeChildren() {
+        return children;
+    }
+
+    @Override
+    public boolean canHover() {
+        if (IDrawable.isVisible(getBackground()) ||
+                IDrawable.isVisible(getHoverBackground()) ||
+                IDrawable.isVisible(getHoverOverlay()) ||
+                getTooltip() != null)
+            return true;
+        WidgetThemeEntry<?> widgetTheme = getWidgetTheme(getPanel().getTheme());
+        if (getBackground() == null && IDrawable.isVisible(widgetTheme.getTheme().getBackground())) return true;
+        return getHoverBackground() == null && IDrawable.isVisible(widgetTheme.getHoverTheme().getBackground());
+    }
+
+    @Override
+    public boolean canClickThrough() {
+        return !canHover();
+    }
+
+    @Override
+    public boolean canHoverThrough() {
+        return !canHover();
+    }
+
+    protected boolean addChild(I child, int index) {
+        if (child == null || child == this || getChildren().contains(child)) {
+            return false;
+        }
+        if (child instanceof ModularPanel) {
+            throw new IllegalArgumentException(
+                    "ModularPanel should not be added as child widget; Use ModularScreen#openPanel instead");
+        }
+        if (!isChildValid(child)) {
+            throw new IllegalArgumentException("Child '" + child + "' is not valid for parent '" + this + "'!");
+        }
+        if (index < 0) {
+            index += getChildren().size() + 1;
+        }
+        this.children.add(index, child);
+        if (isValid()) {
+            child.initialise(this, true);
+        }
+        onChildAdd(child);
+        return true;
+    }
+
+    protected boolean remove(I child) {
+        if (this.children.remove(child)) {
+            if (isValid()) {
+                child.dispose();
+            }
+            onChildRemove(child);
+            return true;
+        }
+        return false;
+    }
+
+    protected boolean remove(int index) {
+        if (index < 0) {
+            index = getChildren().size() + index + 1;
+        }
+        I child = this.children.remove(index);
+        if (this.isChildValid(child)) {
+            child.dispose();
+        }
+        onChildRemove(child);
+        return true;
+    }
+
+    protected boolean removeAll() {
+        if (this.children.isEmpty()) return false;
+        for (I i : this.children) {
+            if (isValid()) i.dispose();
+            onChildRemove(i);
+        }
+        this.children.clear();
+        return true;
+    }
+
+    protected boolean isChildValid(I child) {
+        return true;
+    }
+
+    protected void onChildAdd(I child) {}
+
+    protected void onChildRemove(I child) {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractScrollWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractScrollWidget.java
new file mode 100644
index 00000000000..ed344b7a0fd
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractScrollWidget.java
@@ -0,0 +1,165 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IGuiAction;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.HoveredWidgetList;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.HorizontalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollArea;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A scrollable parent widget. Children can be added.
+ *
+ * @param <I> type of children (in most cases just {@link IWidget})
+ * @param <W> type of this widget
+ */
+public abstract class AbstractScrollWidget<I extends IWidget, W extends AbstractScrollWidget<I, W>>
+                                          extends AbstractParentWidget<I, W> implements IViewport, Interactable {
+
+    private final ScrollArea scroll = new ScrollArea();
+    private boolean scrollXActive, scrollYActive;
+    private IGuiAction.MouseScroll customMouseScroll;
+
+    public AbstractScrollWidget(@Nullable HorizontalScrollData x, @Nullable VerticalScrollData y) {
+        super();
+        this.scroll.setScrollX(x);
+        this.scroll.setScrollY(y);
+        listenGuiAction((IGuiAction.MouseReleased) (mouseX, mouseY, button) -> {
+            this.scroll.mouseReleased(getContext());
+            return false;
+        });
+    }
+
+    @Override
+    public Area getArea() {
+        return this.scroll;
+    }
+
+    public ScrollArea getScrollArea() {
+        return this.scroll;
+    }
+
+    @Override
+    public void transformChildren(IViewportStack stack) {
+        stack.translate(-getScrollX(), -getScrollY());
+    }
+
+    @Override
+    public void getWidgetsAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        // if 'widgets.peek() == this' is true, only then this widget is hovered
+        // we should require this since a stencil is applied to this widget
+        if (widgets.peek() == this && !getScrollArea().isInsideScrollbarArea(x, y)) {
+            IViewport.super.getWidgetsAt(stack, widgets, x, y);
+        }
+    }
+
+    public void beforeResize(boolean onOpen) {
+        super.beforeResize(onOpen);
+        this.scroll.applyWidgetTheme(getPanel().getTheme().getScrollbarTheme().getTheme(isHovering()));
+        checkScrollbarActive(false);
+        getScrollArea().getScrollPadding().scrollPaddingAll(0);
+        applyAdditionalOffset(this.scroll.getScrollX());
+        applyAdditionalOffset(this.scroll.getScrollY());
+    }
+
+    protected void checkScrollbarActive(boolean resizeOnChange) {
+        boolean scrollYActive = this.scroll.getScrollY() != null &&
+                this.scroll.getScrollY().isScrollBarActive(getScrollArea());
+        boolean scrollXActive = this.scroll.getScrollX() != null &&
+                this.scroll.getScrollX().isScrollBarActive(getScrollArea(), scrollYActive);
+        if (resizeOnChange && (scrollYActive != this.scrollYActive || scrollXActive != this.scrollXActive)) {
+            scheduleResize();
+        }
+        this.scrollXActive = scrollXActive;
+        this.scrollYActive = scrollYActive;
+    }
+
+    private void applyAdditionalOffset(ScrollData data) {
+        if (data != null && data.isScrollBarActive(getScrollArea())) {
+            getScrollArea().getScrollPadding().scrollPadding(data.getAxis().getOther(), data.isAxisStart(),
+                    data.getThickness());
+        }
+    }
+
+    @Override
+    public boolean canHover() {
+        return super.canHover() ||
+                this.scroll.isInsideScrollbarArea(getContext().getMouseX(), getContext().getMouseY());
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        ModularGuiContext context = getContext();
+        if (this.scroll.mouseClicked(context)) {
+            return Result.SUCCESS;
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        if (customMouseScroll != null) {
+            return customMouseScroll.scroll(mouseX, mouseY, delta);
+        }
+        return this.scroll.mouseScroll(getContext());
+    }
+
+    public W onMouseScrolled(IGuiAction.MouseScroll mouseScroll) {
+        this.customMouseScroll = mouseScroll;
+        return getThis();
+    }
+
+    @Override
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        this.scroll.mouseReleased(getContext());
+        return false;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        checkScrollbarActive(false);
+        this.scroll.drag(getContext().getMouseX(), getContext().getMouseY());
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        checkScrollbarActive(true);
+    }
+
+    @Override
+    public void preDraw(ModularGuiContext context, boolean transformed) {
+        if (!transformed) {
+            context.getStencil().pushAtZero(this.scroll);
+        }
+    }
+
+    @Override
+    public void postDraw(ModularGuiContext context, boolean transformed) {
+        if (!transformed) {
+            context.getStencil().pop();
+            WidgetThemeEntry<WidgetTheme> scrollbarTheme = getPanel().getTheme().getScrollbarTheme();
+            this.scroll.drawScrollbar(context, scrollbarTheme.getTheme(isHovering()),
+                    scrollbarTheme.getTheme().getBackground());
+        }
+    }
+
+    public int getScrollX() {
+        return this.scroll.getScrollX() != null ? this.scroll.getScrollX().getScroll() : 0;
+    }
+
+    public int getScrollY() {
+        return this.scroll.getScrollY() != null ? this.scroll.getScrollY().getScroll() : 0;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractWidget.java
new file mode 100644
index 00000000000..69b3b2fee3b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/AbstractWidget.java
@@ -0,0 +1,355 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IDelegatingWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.INotifyEnabled;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.StandardResizer;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.MustBeInvokedByOverriders;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+/**
+ * Very basic implementation of {@link IWidget}.
+ */
+public abstract class AbstractWidget implements IWidget {
+
+    // gui context
+    private boolean valid = false;
+    private IWidget parent = null;
+    private ModularPanel panel = null;
+    private ModularGuiContext context = null;
+
+    @Nullable
+    private String name;
+    private boolean enabled = true;
+    private int timeHovered = -1;
+    private int timeBelowMouse = -1;
+
+    private final Area area = new Area();
+    private StandardResizer resizer;
+
+    /**
+     * Returns the screen of the panel of this widget is being opened in.
+     *
+     * @return the screen of this widget
+     * @throws IllegalStateException if {@link #isValid()} returns false
+     */
+    @Override
+    public ModularScreen getScreen() {
+        return getPanel().getScreen();
+    }
+
+    @Override
+    public void scheduleResize() {
+        this.resizer.markDirty();
+    }
+
+    @Override
+    public boolean requiresResize() {
+        return this.resizer.requiresResize();
+    }
+
+    /**
+     * Called when a panel is opened. Use {@link #onInit()} and {@link #afterInit()} for custom logic.
+     *
+     * @param parent the parent this element belongs to
+     * @param late   true if this is called some time after the widget tree of the parent has been initialised
+     */
+    @ApiStatus.Internal
+    @Override
+    public final void initialise(@NotNull IWidget parent, boolean late) {
+        this.timeHovered = -1;
+        this.timeBelowMouse = -1;
+        if (this.resizer == null) {
+            throw new IllegalStateException(
+                    "Resizer must be set before the widget initializes! Affected widget: " + this);
+        }
+        if (!(this instanceof ModularPanel)) {
+            this.parent = parent;
+            this.panel = parent.getPanel();
+            this.context = parent.getContext();
+            getArea().z(parent.getArea().z() + 1);
+            if (parent instanceof AbstractWidget aw) {
+                this.resizer.initialize(aw.resizer, parent.getScreen().getResizeNode());
+            } else {
+                this.resizer.initialize(parent.resizer(), parent.getScreen().getResizeNode());
+            }
+        }
+        this.valid = true;
+        onInitInternal(late);
+        onInit();
+        if (hasChildren()) {
+            for (IWidget child : getChildren()) {
+                child.initialise(this, false);
+            }
+        }
+        afterInit();
+        onResized();
+    }
+
+    void onInitInternal(boolean late) {}
+
+    /**
+     * Called after this widget is initialised and before the children are initialised.
+     */
+    @ApiStatus.OverrideOnly
+    public void onInit() {}
+
+    /**
+     * Called after this widget is initialised and after the children are initialised.
+     */
+    @ApiStatus.OverrideOnly
+    public void afterInit() {}
+
+    /**
+     * Called when this widget is removed from the widget tree or after the panel is closed.
+     * Overriding this is fine, but super must be called.
+     */
+    @MustBeInvokedByOverriders
+    @Override
+    public void dispose() {
+        if (hasChildren()) {
+            for (IWidget child : getChildren()) {
+                child.dispose();
+            }
+        }
+        if (!(this instanceof ModularPanel)) {
+            this.panel = null;
+            this.parent = null;
+            this.context = null;
+        }
+        resizer().dispose();
+        this.timeHovered = -1;
+        this.timeBelowMouse = -1;
+        this.valid = false;
+    }
+
+    // -------------------
+    // === Gui context ===
+    // -------------------
+
+    /**
+     * Returns if this widget is currently part of an open panel. Only if this is true information about parent, panel
+     * and gui context can
+     * be obtained.
+     *
+     * @return true if this widget is part of an open panel
+     */
+    @Override
+    public boolean isValid() {
+        return valid;
+    }
+
+    @Override
+    public void onUpdate() {
+        if (isHovering()) this.timeHovered++;
+        if (isBelowMouse()) this.timeBelowMouse++;
+    }
+
+    @MustBeInvokedByOverriders
+    @Override
+    public void onMouseStartHover() {
+        this.timeHovered = 0;
+    }
+
+    @MustBeInvokedByOverriders
+    @Override
+    public void onMouseEndHover() {
+        this.timeHovered = -1;
+    }
+
+    @MustBeInvokedByOverriders
+    @Override
+    public void onMouseEnterArea() {
+        this.timeBelowMouse = 0;
+    }
+
+    @MustBeInvokedByOverriders
+    @Override
+    public void onMouseLeaveArea() {
+        this.timeBelowMouse = -1;
+    }
+
+    @Override
+    public boolean isHoveringFor(int ticks) {
+        return timeHovered >= ticks;
+    }
+
+    @Override
+    public boolean isBelowMouseFor(int ticks) {
+        return timeBelowMouse >= ticks;
+    }
+
+    public int getTicksHovered() {
+        return timeHovered;
+    }
+
+    public int getTicksBelowMouse() {
+        return timeBelowMouse;
+    }
+
+    /**
+     * Returns the area of this widget. This contains information such as position, size, relative position to parent,
+     * padding and margin.
+     * Even tho this is a mutable object, you should refrain from modifying the values.
+     *
+     * @return area of this widget
+     */
+    @Override
+    public Area getArea() {
+        return area;
+    }
+
+    /**
+     * Shortcut to get the area of the parent
+     *
+     * @return parent area
+     */
+    public Area getParentArea() {
+        IWidget parent = getParent();
+        while (parent instanceof IDelegatingWidget dw) {
+            parent = dw.getParent();
+        }
+        return parent.getArea();
+    }
+
+    /**
+     * Returns if this widget is currently enabled. Disabled widgets (and all its children) are not rendered and can't
+     * be interacted with.
+     *
+     * @return true if this widget is enabled.
+     */
+    @Override
+    public boolean isEnabled() {
+        return this.enabled;
+    }
+
+    /**
+     * Sets enabled state. Disabled widgets (and all its children) are not rendered and can't be interacted with.
+     *
+     * @param enabled enabled state
+     */
+    @Override
+    public void setEnabled(boolean enabled) {
+        if (this.enabled != enabled) {
+            this.enabled = enabled;
+            if (isValid() && getParent() instanceof INotifyEnabled notifyEnabled) {
+                notifyEnabled.onChildChangeEnabled(this, enabled);
+            }
+        }
+    }
+
+    /**
+     * Returns the parent of this widget. If this is a {@link ModularPanel} this will always return null contrary to the
+     * annotation.
+     *
+     * @return the screen of this widget
+     * @throws IllegalStateException if {@link #isValid()} returns false
+     */
+    @Override
+    public @NotNull IWidget getParent() {
+        if (!isValid()) {
+            throw new IllegalStateException(this + " is not in a valid state!");
+        }
+        return parent;
+    }
+
+    /**
+     * Returns the gui context of the screen this widget is part of.
+     *
+     * @return the screen of this widget
+     * @throws IllegalStateException if {@link #isValid()} returns false
+     */
+    @Override
+    public ModularGuiContext getContext() {
+        if (!isValid()) {
+            throw new IllegalStateException(this + " is not in a valid state!");
+        }
+        return context;
+    }
+
+    /**
+     * Used to set the gui context on panels internally.
+     */
+    @ApiStatus.Internal
+    protected final void setContext(ModularGuiContext context) {
+        this.context = context;
+    }
+
+    /**
+     * Returns the panel of this widget is being opened in.
+     *
+     * @return the screen of this widget
+     * @throws IllegalStateException if {@link #isValid()} returns false
+     */
+    @Override
+    public @NotNull ModularPanel getPanel() {
+        if (!isValid()) {
+            throw new IllegalStateException(this + " is not in a valid state!");
+        }
+        return panel;
+    }
+
+    @Override
+    public @NotNull StandardResizer resizer() {
+        return this.resizer;
+    }
+
+    protected final StandardResizer rawResizer() {
+        return this.resizer;
+    }
+
+    protected void resizer(StandardResizer resizer) {
+        Objects.requireNonNull(resizer);
+        if (this.resizer == resizer) return;
+        if (isValid() && this.resizer != null) {
+            resizer.replacementOf(this.resizer);
+        }
+        this.resizer = resizer;
+    }
+
+    @Override
+    public @Nullable String getName() {
+        return name;
+    }
+
+    protected void setName(String name) {
+        this.name = name;
+    }
+
+    public boolean isName(String name) {
+        return Objects.equals(name, this.name);
+    }
+
+    public boolean nameContains(String part) {
+        return this.name != null && this.name.contains(part);
+    }
+
+    /**
+     * This is only used in {@link #toString()}.
+     *
+     * @return the simple class name or other fitting name
+     */
+    protected String getTypeName() {
+        return getClass().getSimpleName();
+    }
+
+    /**
+     * @return the simple class plus the debug name if set
+     */
+    @Override
+    public String toString() {
+        if (getName() != null) {
+            return getTypeName() + "#" + getName();
+        }
+        return getTypeName();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DelegatingWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DelegatingWidget.java
new file mode 100644
index 00000000000..2e56eb8c750
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DelegatingWidget.java
@@ -0,0 +1,108 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IDelegatingWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.MutableSingletonList;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.StandardResizer;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class DelegatingWidget extends AbstractWidget implements IDelegatingWidget {
+
+    private final MutableSingletonList<IWidget> delegate = new MutableSingletonList<>();
+
+    public DelegatingWidget(IWidget delegate) {
+        this.delegate.set(delegate);
+        resizer(new StandardResizer(this));
+    }
+
+    protected void setDelegate(IWidget delegate) {
+        if (!this.delegate.isEmpty()) {
+            this.delegate.get().dispose();
+            this.delegate.remove();
+        }
+        if (delegate != null) {
+            this.delegate.set(delegate);
+            if (isValid()) {
+                initialise(getParent(), true);
+                delegate.scheduleResize();
+            }
+            onChangeDelegate(delegate);
+        }
+    }
+
+    protected void onChangeDelegate(IWidget delegate) {}
+
+    @Override
+    public @NotNull List<IWidget> getChildren() {
+        return this.delegate;
+    }
+
+    @Override
+    public void afterInit() {
+        super.resizer().setDefaultParent(null); // remove this widget from the resize node tree
+        if (hasChildren()) {
+            getDelegate().resizer().setDefaultParentIsDelegating(true);
+            getDelegate().resizer().relative(getParent()); // add the delegated widget at the place of this widget on
+                                                           // the resize node tree
+        }
+    }
+
+    @Override
+    public void postResize() {
+        super.postResize();
+        if (getDelegate() != null) {
+            Area childArea = getDelegate().getArea();
+            Area area = super.getArea();
+            area.set(childArea);
+            area.rx = childArea.rx;
+            area.ry = childArea.ry;
+            childArea.rx = 0;
+            childArea.ry = 0;
+        }
+    }
+
+    @Override
+    public @NotNull StandardResizer resizer() {
+        return getDelegate() != null ? getDelegate().resizer() : super.resizer();
+    }
+
+    @Override
+    public Area getArea() {
+        return getDelegate() != null ? getDelegate().getArea() : super.getArea();
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        stack.translate(super.getArea().rx, super.getArea().ry, 0);
+    }
+
+    @Override
+    public boolean canBeSeen(IViewportStack stack) {
+        return false;
+    }
+
+    @Override
+    public boolean requiresResize() {
+        return getDelegate() != null && getDelegate().requiresResize();
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return getDelegate() != null ? getDelegate().getDefaultWidth() : super.getDefaultWidth();
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return getDelegate() != null ? getDelegate().getDefaultHeight() : super.getDefaultHeight();
+    }
+
+    @Override
+    public IWidget getDelegate() {
+        return delegate.getOrNull();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DragHandle.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DragHandle.java
new file mode 100644
index 00000000000..07d059f1bd7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DragHandle.java
@@ -0,0 +1,114 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IDraggable;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.HoveredWidgetList;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.DraggablePanelWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+
+import org.jetbrains.annotations.Nullable;
+
+public class DragHandle extends Widget<DragHandle> implements IDraggable, IViewport {
+
+    private IDraggable parentDraggable;
+
+    @Override
+    public void onInit() {
+        IWidget parent = getParent();
+        while (!(parent instanceof ModularPanel)) {
+            if (parent instanceof IDraggable draggable) {
+                this.parentDraggable = draggable;
+                return;
+            }
+            parent = parent.getParent();
+        }
+        if (((ModularPanel) parent).isDraggable()) {
+            this.parentDraggable = new DraggablePanelWrapper((ModularPanel) parent);
+        }
+    }
+
+    @Override
+    public void drawMovingState(GuiGraphics graphics, ModularGuiContext context, float partialTicks) {
+        if (this.parentDraggable != null) {
+            this.parentDraggable.drawMovingState(graphics, context, partialTicks);
+        }
+    }
+
+    @Override
+    public boolean onDragStart(int button) {
+        return this.parentDraggable != null && this.parentDraggable.onDragStart(button);
+    }
+
+    @Override
+    public void onDragEnd(boolean successful) {
+        if (this.parentDraggable != null) {
+            this.parentDraggable.onDragEnd(successful);
+        }
+    }
+
+    @Override
+    public void onDrag(int mouseButton, double timeSinceLastClick) {
+        if (this.parentDraggable != null) {
+            this.parentDraggable.onDrag(mouseButton, timeSinceLastClick);
+        }
+    }
+
+    @Override
+    public boolean canDropHere(int x, int y, @Nullable IWidget widget) {
+        return this.parentDraggable != null && this.parentDraggable.canDropHere(x, y, widget);
+    }
+
+    @Override
+    public @Nullable Area getMovingArea() {
+        Area.SHARED.reset();
+        return this.parentDraggable != null ? this.parentDraggable.getMovingArea() : Area.SHARED;
+    }
+
+    @Override
+    public boolean isMoving() {
+        return this.parentDraggable != null && this.parentDraggable.isMoving();
+    }
+
+    @Override
+    public void setMoving(boolean moving) {
+        if (this.parentDraggable != null) {
+            this.parentDraggable.setMoving(moving);
+        }
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        super.transform(stack);
+    }
+
+    @Override
+    public void transformChildren(IViewportStack stack) {
+        if (this.parentDraggable instanceof IViewport viewport) {
+            viewport.transformChildren(stack);
+        }
+    }
+
+    @Override
+    public void getWidgetsAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        if (this.parentDraggable instanceof IViewport viewport) {
+            viewport.getWidgetsAt(stack, widgets, x, y);
+        } else {
+            IViewport.super.getWidgetsAt(stack, widgets, x, y);
+        }
+    }
+
+    @Override
+    public void getSelfAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        if (this.parentDraggable instanceof IViewport viewport) {
+            viewport.getSelfAt(stack, widgets, x, y);
+        } else {
+            IViewport.super.getSelfAt(stack, widgets, x, y);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DraggableWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DraggableWidget.java
new file mode 100644
index 00000000000..095b590fb10
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/DraggableWidget.java
@@ -0,0 +1,98 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IDraggable;
+import com.gregtechceu.gtceu.api.mui.utils.HoveredWidgetList;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+
+import lombok.Getter;
+
+/**
+ * A widget that can be picked up by the cursor.
+ * Might not work as expected when a parent is scaling or rotating itself.
+ */
+public class DraggableWidget<W extends DraggableWidget<W>> extends Widget<W> implements IDraggable, IViewport {
+
+    @Getter
+    private boolean moving = false;
+    private int relativeClickX, relativeClickY;
+    @Getter
+    private final Area movingArea;
+    private int realX, realY;
+
+    public DraggableWidget() {
+        this.movingArea = getArea().createCopy();
+    }
+
+    @Override
+    public void drawMovingState(GuiGraphics graphics, ModularGuiContext context, float partialTicks) {
+        WidgetTree.drawTree(this, context, true, true);
+    }
+
+    @Override
+    public boolean onDragStart(int mouseButton) {
+        if (mouseButton == 0) {
+            this.realX = getContext().transformX(0, 0) - getParentArea().x;
+            this.realY = getContext().transformY(0, 0) - getParentArea().y;
+            this.movingArea.x = this.realX;
+            this.movingArea.y = this.realY;
+            this.relativeClickX = getContext().getAbsMouseX() - this.realX;
+            this.relativeClickY = getContext().getAbsMouseY() - this.realY;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onDragEnd(boolean successful) {
+        if (successful) {
+            resizer().top(getContext().getAbsMouseY() - this.relativeClickY)
+                    .left(getContext().getAbsMouseX() - this.relativeClickX);
+            this.movingArea.x = getArea().x;
+            this.movingArea.y = getArea().y;
+            scheduleResize();
+        }
+    }
+
+    @Override
+    public void onDrag(int mouseButton, double timeSinceLastClick) {
+        this.movingArea.x = getContext().getAbsMouseX() - this.relativeClickX;
+        this.movingArea.y = getContext().getAbsMouseY() - this.relativeClickY;
+    }
+
+    @Override
+    public void setMoving(boolean moving) {
+        this.moving = moving;
+        setEnabled(!moving);
+    }
+
+    @Override
+    public void getSelfAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        if (!isMoving() && isInside(stack, x, y)) {
+            widgets.add(this, stack, getAdditionalHoverInfo(stack, x, y));
+        }
+    }
+
+    @Override
+    public void getWidgetsAt(IViewportStack stack, HoveredWidgetList widgets, int x, int y) {
+        if (!isMoving() && hasChildren()) {
+            IViewport.getChildrenAt(this, stack, widgets, x, y);
+        }
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        super.transform(stack);
+        if (isMoving()) {
+            // remove relative transformation
+            stack.translate(-getArea().rx, -getArea().ry);
+            // translate to current pos
+            stack.translate(-this.realX, -this.realY);
+            stack.translate(this.movingArea.x, this.movingArea.y);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/EmptyWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/EmptyWidget.java
new file mode 100644
index 00000000000..6151afdf30e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/EmptyWidget.java
@@ -0,0 +1,116 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.StandardResizer;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class EmptyWidget implements IWidget {
+
+    @Getter
+    private final Area area = new Area();
+    @Getter
+    private final StandardResizer resizer = new StandardResizer(this);
+    private boolean requiresResize = false;
+    @Setter
+    @Getter
+    public boolean enabled = true;
+    @Getter
+    private IWidget parent;
+
+    @Override
+    public ModularScreen getScreen() {
+        return null;
+    }
+
+    @Override
+    public void initialise(@NotNull IWidget parent, boolean late) {
+        this.parent = parent;
+        getArea().z(parent.getArea().z() + 1);
+    }
+
+    @Override
+    public void dispose() {
+        this.parent = null;
+    }
+
+    @Override
+    public boolean isValid() {
+        return this.parent != null;
+    }
+
+    @Override
+    public void drawBackground(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    @Override
+    public void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    @Override
+    public void drawForeground(ModularGuiContext context) {}
+
+    @Override
+    public void onUpdate() {}
+
+    @Override
+    public @NotNull ModularPanel getPanel() {
+        return this.parent.getPanel();
+    }
+
+    @Override
+    public void scheduleResize() {
+        this.requiresResize = true;
+    }
+
+    @Override
+    public boolean requiresResize() {
+        return this.requiresResize;
+    }
+
+    @Override
+    public void onResized() {
+        this.requiresResize = false;
+    }
+
+    @Override
+    public boolean canBeSeen(IViewportStack stack) {
+        return false;
+    }
+
+    @Override
+    public boolean canHover() {
+        return false;
+    }
+
+    @Override
+    public boolean canHoverThrough() {
+        return true;
+    }
+
+    @Override
+    public ModularGuiContext getContext() {
+        return this.parent.getContext();
+    }
+
+    @Override
+    public @NotNull StandardResizer resizer() {
+        return this.resizer;
+    }
+
+    @Nullable
+    @Override
+    public String getName() {
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/InternalWidgetTree.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/InternalWidgetTree.java
new file mode 100644
index 00000000000..0e75b036d61
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/InternalWidgetTree.java
@@ -0,0 +1,277 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.ResizeNode;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.IExpander;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+
+import com.google.common.base.Joiner;
+import com.mojang.blaze3d.systems.RenderSystem;
+import org.jetbrains.annotations.Contract;
+
+import java.util.*;
+
+public class InternalWidgetTree {
+
+    @Contract("_,_,_,_,false -> !null")
+    @SuppressWarnings("unchecked")
+    static <T extends IWidget> T findChildAt(IWidget parent, Class<T> type, String[] path, int index,
+                                             boolean nullable) {
+        String current = path[index];
+        boolean isLast = index == path.length - 1;
+        for (IWidget widget : parent.getChildren()) {
+            if (widget.isName(current)) {
+                if (isLast) {
+                    if (!widget.isType(type)) {
+                        throw new ClassCastException("Found widget at '" +
+                                Joiner.on('/').join(Arrays.copyOfRange(path, 0, index + 1)) + "' with type '" +
+                                widget.getClass().getName() + "', but expected type '" + type.getName() + "'.");
+                    }
+                    return (T) widget;
+                }
+                T result = findChildAt(widget, type, path, index + 1, nullable);
+                if (result != null) return result;
+            }
+        }
+        if (!nullable) {
+            throw new NoSuchElementException("Expected to find widget at '" +
+                    Joiner.on('/').join(Arrays.copyOfRange(path, 0, index + 1)) + "', but none was found.");
+        }
+        return null;
+    }
+
+    static void drawTree(IWidget parent, ModularGuiContext context, boolean ignoreEnabled,
+                         boolean shouldDrawBackground) {
+        if (!parent.isEnabled() && !ignoreEnabled) return;
+        if (parent.requiresResize()) {
+            WidgetTree.resizeInternal(parent.resizer(), false);
+        }
+
+        GuiGraphics graphics = context.getGraphics();
+        float alpha = parent.getPanel().getAlpha();
+        IViewport viewport = parent instanceof IViewport ? (IViewport) parent : null;
+
+        // transform stack according to the widget
+        context.pushMatrix();
+        parent.transform(context);
+
+        boolean canBeSeen = parent.canBeSeen(context);
+
+        // apply transformations to opengl
+        graphics.pose().pushPose();
+        context.applyTo(graphics.pose());
+
+        if (canBeSeen) {
+            // draw widget
+            graphics.setColor(1f, 1f, 1f, alpha);
+            WidgetThemeEntry<?> widgetTheme = parent.getWidgetTheme(parent.getPanel().getTheme());
+            if (shouldDrawBackground) parent.drawBackground(context, widgetTheme);
+            parent.draw(context, widgetTheme);
+            parent.drawOverlay(context, widgetTheme);
+        }
+
+        if (viewport != null) {
+            if (canBeSeen) {
+                // draw viewport without children transformation
+                graphics.setColor(1f, 1f, 1f, alpha);
+                viewport.preDraw(context, false);
+                graphics.pose().popPose();
+                // apply children transformation of the viewport
+                context.pushViewport(viewport, parent.getArea());
+                viewport.transformChildren(context);
+                // apply to opengl and draw with transformation
+                graphics.pose().pushPose();
+                context.applyTo(graphics.pose());
+                viewport.preDraw(context, true);
+            } else {
+                // only transform stack
+                context.pushViewport(viewport, parent.getArea());
+                viewport.transformChildren(context);
+            }
+        }
+        // remove all opengl transformations
+        graphics.pose().popPose();
+
+        // render all children if there are any
+        List<IWidget> children = parent.getChildren();
+        if (!children.isEmpty()) {
+            boolean backgroundSeparate = children.size() > 1;
+            // draw all backgrounds first if we have more than 1 child
+            // the whole reason this exists is because of the hover animation of items with NEA
+            // on hover the item scales up slightly, this causes the amount text to overlap nearby slots, but since the
+            // whole slot is drawn
+            // at once the backgrounds might draw on top of the text
+            // for now we'll apply this always without checking for NEA as it might be useful for other things
+            // maybe proper layer customization in the future?
+            if (backgroundSeparate) children.forEach(widget -> drawBackground(widget, context, ignoreEnabled));
+            children.forEach(widget -> drawTree(widget, context, false, !backgroundSeparate));
+        }
+
+        if (viewport != null) {
+            if (canBeSeen) {
+                // apply opengl transformations again and draw
+                graphics.setColor(1f, 1f, 1f, alpha);
+                graphics.pose().pushPose();
+                context.applyTo(graphics.pose());
+                viewport.postDraw(context, true);
+                // remove children transformation of this viewport
+                context.popViewport(viewport);
+                graphics.pose().popPose();
+                // apply transformation again to opengl and draw
+                graphics.pose().pushPose();
+                context.applyTo(graphics.pose());
+                viewport.postDraw(context, false);
+                graphics.pose().popPose();
+            } else {
+                // only remove transformation
+                context.popViewport(viewport);
+            }
+        }
+        // remove all widget transformations
+        context.popMatrix();
+    }
+
+    static void drawBackground(IWidget parent, ModularGuiContext context, boolean ignoreEnabled) {
+        if (!parent.isEnabled() && !ignoreEnabled) return;
+
+        GuiGraphics graphics = context.getGraphics();
+        float alpha = parent.getPanel().getAlpha();
+
+        // transform stack according to the widget
+        context.pushMatrix();
+        parent.transform(context);
+
+        boolean canBeSeen = parent.canBeSeen(context);
+        if (!canBeSeen) {
+            context.popMatrix();
+            return;
+        }
+
+        // apply transformations to opengl
+        graphics.pose().pushPose();
+        context.applyTo(graphics.pose());
+
+        // draw widget
+        graphics.setColor(1f, 1f, 1f, alpha);
+        WidgetThemeEntry<?> widgetTheme = parent.getWidgetTheme(parent.getPanel().getTheme());
+        parent.drawBackground(context, widgetTheme);
+
+        graphics.pose().popPose();
+        context.popMatrix();
+    }
+
+    static void drawTreeForeground(IWidget parent, ModularGuiContext context) {
+        IViewport viewport = parent instanceof IViewport viewport1 ? viewport1 : null;
+        context.pushMatrix();
+        parent.transform(context);
+
+        context.getGraphics().setColor(1, 1, 1, 1);
+        RenderSystem.enableBlend();
+        parent.drawForeground(context);
+
+        List<IWidget> children = parent.getChildren();
+        if (!children.isEmpty()) {
+            if (viewport != null) {
+                context.pushViewport(viewport, parent.getArea());
+                viewport.transformChildren(context);
+            }
+            children.forEach(widget -> drawTreeForeground(widget, context));
+            if (viewport != null) context.popViewport(viewport);
+        }
+        context.popMatrix();
+    }
+
+    static boolean resize(ResizeNode resizer, boolean init, boolean onOpen, boolean isParentLayout) {
+        boolean alreadyCalculated = false;
+        // first try to resize this widget
+        boolean isLayout = resizer.isLayout();
+        if (init) {
+            resizer.initResizing(onOpen);
+            if (!isLayout) resizer.setLayoutDone(true);
+        } else {
+            // if this is not the first time check if this widget is already resized
+            alreadyCalculated = resizer.isFullyCalculated(isParentLayout);
+        }
+        boolean selfFullyCalculated = resizer.isSelfFullyCalculated() || resizer.resize(isParentLayout);
+
+        GuiAxis expandAxis = resizer instanceof IExpander expander ? expander.getExpandAxis() : null;
+        // now resize all children and collect children which could not be fully calculated
+        List<ResizeNode> anotherResize = Collections.emptyList();
+        if (!resizer.areChildrenCalculated() && !resizer.getChildren().isEmpty()) {
+            anotherResize = new ArrayList<>();
+            for (ResizeNode child : resizer.getChildren()) {
+                if (init) child.checkExpanded(expandAxis);
+                if (!resize(child, init, onOpen, isLayout)) {
+                    anotherResize.add(child);
+                }
+            }
+        }
+
+        boolean shouldLayout = init || !resizer.areChildrenCalculated() || !resizer.isLayoutDone();
+        if (shouldLayout || !selfFullyCalculated) {
+            boolean layoutSuccessful = true;
+            // we need to keep track of which widgets are not yet fully calculated, so we can call onResized on those
+            // which later are fully calculated
+            BitSet state = getCalculatedState(anotherResize, isLayout);
+            if (isLayout && shouldLayout) {
+                layoutSuccessful = resizer.layoutChildren();
+            }
+
+            // post resize this widget if possible
+            resizer.postResize();
+
+            if (isLayout && shouldLayout) {
+                layoutSuccessful &= resizer.postLayoutChildren();
+                if (!selfFullyCalculated) resizer.postResize();
+            }
+            if (shouldLayout) resizer.setLayoutDone(layoutSuccessful);
+            checkFullyCalculated(anotherResize, state, isLayout);
+        }
+
+        // now fully resize all children which needs it
+        if (!anotherResize.isEmpty()) {
+            for (int i = 0; i < anotherResize.size(); i++) {
+                if (resize(anotherResize.get(i), false, onOpen, isLayout)) {
+                    anotherResize.remove(i--);
+                }
+            }
+        }
+        resizer.setChildrenResized(anotherResize.isEmpty());
+        selfFullyCalculated = resizer.isFullyCalculated(isParentLayout);
+
+        if (selfFullyCalculated && !alreadyCalculated) resizer.onResized();
+
+        return selfFullyCalculated;
+    }
+
+    private static BitSet getCalculatedState(List<ResizeNode> children, boolean isLayout) {
+        if (children.isEmpty()) return null;
+        BitSet state = new BitSet();
+        for (int i = 0; i < children.size(); i++) {
+            ResizeNode widget = children.get(i);
+            if (widget.isFullyCalculated(isLayout)) {
+                state.set(i);
+            }
+        }
+        return state;
+    }
+
+    private static void checkFullyCalculated(List<ResizeNode> children, BitSet state, boolean isLayout) {
+        if (children.isEmpty() || state == null) return;
+        int j = 0;
+        for (int i = 0; i < children.size(); i++) {
+            ResizeNode widget = children.get(i);
+            if (!state.get(j) && widget.isFullyCalculated(isLayout)) {
+                widget.onResized();
+                state.set(j);
+                children.remove(i--);
+            }
+            j++;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/ParentWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/ParentWidget.java
new file mode 100644
index 00000000000..8c4b58651a2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/ParentWidget.java
@@ -0,0 +1,32 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IParentWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+/**
+ * A widget which can hold any amount of children.
+ *
+ * @param <W> type of this widget
+ */
+public class ParentWidget<W extends ParentWidget<W>> extends AbstractParentWidget<IWidget, W>
+                         implements IParentWidget<IWidget, W> {
+
+    public boolean addChild(IWidget child, int index) {
+        return super.addChild(child, index);
+    }
+
+    @Override
+    public boolean remove(IWidget child) {
+        return super.remove(child);
+    }
+
+    @Override
+    public boolean remove(int index) {
+        return super.remove(index);
+    }
+
+    @Override
+    protected boolean removeAll() {
+        return super.removeAll();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/ScrollWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/ScrollWidget.java
new file mode 100644
index 00000000000..e30990edd10
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/ScrollWidget.java
@@ -0,0 +1,27 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IParentWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.HorizontalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+
+public class ScrollWidget<W extends ScrollWidget<W>> extends AbstractScrollWidget<IWidget, W>
+                         implements IParentWidget<IWidget, W> {
+
+    public ScrollWidget() {
+        super(null, null);
+    }
+
+    public ScrollWidget(VerticalScrollData data) {
+        super(null, data);
+    }
+
+    public ScrollWidget(HorizontalScrollData data) {
+        super(data, null);
+    }
+
+    @Override
+    public boolean addChild(IWidget child, int index) {
+        return super.addChild(child, index);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/SingleChildWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/SingleChildWidget.java
new file mode 100644
index 00000000000..5b9b446ebd2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/SingleChildWidget.java
@@ -0,0 +1,46 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class SingleChildWidget<W extends SingleChildWidget<W>> extends Widget<W> {
+
+    @Getter
+    private IWidget child;
+    private List<IWidget> list = Collections.emptyList();
+
+    @Override
+    public @NotNull List<IWidget> getChildren() {
+        return this.list;
+    }
+
+    private void updateList() {
+        this.list = this.child == null ? Collections.emptyList() : Collections.singletonList(this.child);
+    }
+
+    public W child(IWidget child) {
+        if (child == this || this.child == child) {
+            return getThis();
+        }
+
+        if (this.child != null) {
+            this.child.dispose();
+        }
+
+        this.child = child;
+        updateList();
+        if (child != null && isValid()) {
+            child.initialise(this, true);
+            scheduleResize();
+        }
+        onChildAdd(child);
+        return getThis();
+    }
+
+    protected void onChildAdd(IWidget child) {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/Widget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/Widget.java
new file mode 100644
index 00000000000..e7258b9d321
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/Widget.java
@@ -0,0 +1,709 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.*;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeKey;
+import com.gregtechceu.gtceu.api.mui.value.sync.ISyncRegistrar;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.ValueSyncHandler;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.StandardResizer;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.MustBeInvokedByOverriders;
+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;
+import java.util.function.Predicate;
+
+/**
+ * A very modular implementation of {@link IWidget}. This is the base class for almost all UI elements.
+ * This class is perfectly fine for displaying drawables (although {@link IDrawable.DrawableWidget DrawableWidget}
+ * is preferred) or even nothing.
+ * <p>
+ * References to widgets should not be stored after the screen closed. While the screen is open its usually fine to
+ * remove and a widget
+ * as many times as you want.
+ *
+ * @param <W> the type of this widget. This is used for proper return types in builder like methodsY
+ */
+public class Widget<W extends Widget<W>> extends AbstractWidget implements IPositioned<W>, ITooltip<W>, ISynced<W> {
+
+    // other
+    @Getter
+    private boolean excludeAreaInRecipeViewer = false;
+    // sizing
+    private BiConsumer<W, IViewportStack> transform;
+    // syncing
+    /**
+     * Returns the value handler of this widget. Value handlers can provide and update any kind of objects like numbers
+     * and strings.
+     * For example text fields uses this get the current set string and updates the string after it is unfocused.
+     */
+    @Getter
+    @Nullable
+    private IValue<?> value;
+    @Nullable
+    private String syncKey;
+    /**
+     * This is intended to only be used when building the main panel in methods like
+     * {@link IUIHolder#buildUI(GuiData, com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager, com.gregtechceu.gtceu.client.mui.screen.UISettings)}
+     * since it's called on server and client. Otherwise, this will not work.
+     */
+    @Nullable
+    private SyncHandler syncHandler;
+    // rendering
+    @Nullable
+    private IDrawable shadow = null;
+    /**
+     * The current set background. This is not an accurate representation of what is actually being displayed currently.
+     * Usually background is handled by the theme, which is when this is null.
+     * Backgrounds are drawn in {@link IWidget#drawBackground(ModularGuiContext, WidgetThemeEntry)}.
+     */
+    @Getter
+    @Nullable
+    private IDrawable background = null;
+    /**
+     * The current set overlay. This is used when the widget is not hovered or no hovered overlay is set.
+     * Overlays are drawn in {@link IWidget#drawOverlay(ModularGuiContext, WidgetThemeEntry)}.
+     */
+    @Getter
+    @Nullable
+    private IDrawable overlay = null;
+    /**
+     * The current set hover background. Usually this is handled by the theme.
+     */
+    @Getter
+    @Nullable
+    private IDrawable hoverBackground = null;
+    /**
+     * The current set hover overlay.
+     */
+    @Getter
+    @Nullable
+    private IDrawable hoverOverlay = null;
+    @Getter
+    @Nullable
+    private RichTooltip tooltip;
+    @Getter
+    @Nullable
+    private WidgetThemeKey<?> widgetThemeOverride = null;
+    // listener
+    @Nullable
+    private List<IGuiAction> guiActionListeners; // TODO replace with proper event system
+    @Getter
+    @Nullable
+    private Consumer<W> onUpdateListener;
+
+    public Widget() {
+        resizer(new StandardResizer(this));
+    }
+
+    // -----------------
+    // === Lifecycle ===
+    // -----------------
+
+    @Override
+    void onInitInternal(boolean late) {
+        if (this.guiActionListeners != null) {
+            for (IGuiAction action : this.guiActionListeners) {
+                getContext().getScreen().registerGuiActionListener(action);
+            }
+        }
+
+        if (this.value != null && this.syncKey != null) {
+            throw new IllegalStateException(
+                    "Widget has a value and a sync key for a synced value. This is not allowed!");
+        }
+        if (!getScreen().isClientOnly()) {
+            initialiseSyncHandler(getScreen().getSyncManager(), late);
+        }
+        if (isExcludeAreaInRecipeViewer()) {
+            getContext().getRecipeViewerSettings().addExclusionArea(this);
+        }
+    }
+
+    /**
+     * Retrieves, verifies and initialises a linked sync handler.
+     * Custom logic should be handled in {@link #setSyncOrValue(ISyncOrValue)}.
+     */
+    @Override
+    public void initialiseSyncHandler(ModularSyncManager syncManager, boolean late) {
+        SyncHandler handler = this.syncHandler;
+        if (handler == null && this.syncKey != null) {
+            handler = syncManager.getSyncHandler(getPanel().getName(), this.syncKey);
+            if (handler == null && !syncManager.getMainPSM().getPanelName().equals(getPanel().getName())) {
+                handler = syncManager.getMainPSM().getSyncHandlerFromMapKey(this.syncKey);
+            }
+        }
+        if (handler != null) setSyncOrValue(handler);
+        if (this.syncHandler instanceof ValueSyncHandler<?> valueSyncHandler &&
+                valueSyncHandler.getChangeListener() == null) {
+            valueSyncHandler.setChangeListener(this::markTooltipDirty);
+        }
+    }
+
+    /**
+     * Called when this widget is removed from the widget tree or after the panel is closed.
+     * Overriding this is fine, but super must be called.
+     */
+    @MustBeInvokedByOverriders
+    @Override
+    public void dispose() {
+        if (isValid()) {
+            if (this.guiActionListeners != null) {
+                for (IGuiAction action : this.guiActionListeners) {
+                    getScreen().removeGuiActionListener(action);
+                }
+            }
+            if (isExcludeAreaInRecipeViewer()) {
+                getContext().getRecipeViewerSettings().removeExclusionArea(this);
+            }
+        }
+        super.dispose();
+    }
+
+    // -----------------
+    // === Rendering ===
+    // -----------------
+
+    /**
+     * Called directly before {@link IWidget#draw(ModularGuiContext, WidgetThemeEntry)}. Draws background textures.
+     * It is highly recommended to at least replicate this behaviour when overriding.
+     * Overriding {@link IWidget#draw(ModularGuiContext, WidgetThemeEntry)} for custom visuals is preferred.
+     * If a parent of this widget is disabled, this widget will not be drawn.
+     *
+     * @param context     gui context
+     * @param widgetTheme widget theme of this widget
+     */
+    @Override
+    public void drawBackground(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        if (this.shadow != null) {
+            this.shadow.drawAtZero(context, getArea().width, getArea().height,
+                    getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+        IDrawable bg = getCurrentBackground(getPanel().getTheme(), widgetTheme);
+        if (bg != null) {
+            bg.drawAtZero(context, getArea().width, getArea().height, getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+    }
+
+    /**
+     * Called between {@link IWidget#drawBackground(ModularGuiContext, WidgetThemeEntry)} and
+     * {@link IWidget#drawOverlay(ModularGuiContext, WidgetThemeEntry)}.
+     * Custom visuals should be drawn here. For example the {@link com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot
+     * ItemSlot} draws its item
+     * here. If a parent of this widget is disabled, this widget will not be drawn.
+     *
+     * @param context     gui context
+     * @param widgetTheme widget theme
+     */
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {}
+
+    /**
+     * Called directly after {@link IWidget#draw(ModularGuiContext, WidgetThemeEntry)}. Draws overlay textures.
+     * It is highly recommended to at least replicate this behaviour when overriding.
+     * Overriding {@link #draw(ModularGuiContext, WidgetThemeEntry)} for custom visuals is preferred.
+     * If a parent of this widget is disabled, this widget will not be drawn.
+     *
+     * @param context     gui context
+     * @param widgetTheme widget theme
+     */
+    @Override
+    public void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        IDrawable bg = getCurrentOverlay(getPanel().getTheme(), widgetTheme);
+        if (bg != null) {
+            bg.drawAtZeroPadded(context, getArea(), getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+    }
+
+    /**
+     * Called after every widget of every panel and screen has been drawn. This is usually used to draw a tooltip, which
+     * is the default
+     * behaviour. If a parent of this widget is disabled, this widget will not be drawn.
+     *
+     * @param context gui context
+     */
+    @Override
+    public void drawForeground(ModularGuiContext context) {
+        RichTooltip tooltip = getTooltip();
+        if (tooltip != null && isHoveringFor(tooltip.showUpTimer())) {
+            tooltip.draw(context);
+        }
+    }
+
+    /**
+     * Returns the actual currently displayed background.
+     *
+     * @param theme       current theme
+     * @param widgetTheme widget theme which is used by this widget
+     * @return currently displayed background
+     */
+    public IDrawable getCurrentBackground(ITheme theme, WidgetThemeEntry<?> widgetTheme) {
+        if (isHovering()) {
+            IDrawable hoverBackground = getHoverBackground();
+            if (hoverBackground == null) hoverBackground = getActiveWidgetTheme(widgetTheme, true).getBackground();
+            if (hoverBackground != null && hoverBackground != IDrawable.NONE) return hoverBackground;
+        }
+        IDrawable background = getBackground();
+        return background == null ? getActiveWidgetTheme(widgetTheme, false).getBackground() : background;
+    }
+
+    /**
+     * Returns the actual currently displayed overlay.
+     *
+     * @param theme       current theme
+     * @param widgetTheme widget theme which is used by this widget
+     * @return currently displayed background
+     */
+    public IDrawable getCurrentOverlay(ITheme theme, WidgetThemeEntry<?> widgetTheme) {
+        IDrawable hoverBackground = getHoverOverlay();
+        return hoverBackground != null && hoverBackground != IDrawable.NONE && isHovering() ? hoverBackground :
+                getOverlay();
+    }
+
+    /**
+     * @return the tooltip object of this widget and creates a new one if there is currently none.
+     */
+    @Override
+    public @NotNull RichTooltip tooltip() {
+        if (this.tooltip == null) {
+            this.tooltip = new RichTooltip().parent(this);
+        }
+        return this.tooltip;
+    }
+
+    /**
+     * Sets a tooltip object.
+     *
+     * @param tooltip new tooltip
+     * @return this
+     */
+    @Override
+    public W tooltip(RichTooltip tooltip) {
+        this.tooltip = tooltip;
+        return getThis();
+    }
+
+    public W invisible() {
+        return background(IDrawable.EMPTY)
+                .disableHoverBackground();
+    }
+
+    /**
+     * Should be called when information which is displayed in the tooltip via
+     * {@link ITooltip#tooltipDynamic(Consumer)}.
+     * It will invalidate the current tooltip and be caused to rebuild.
+     */
+    public void markTooltipDirty() {
+        if (this.tooltip != null) {
+            this.tooltip.markDirty();
+        }
+    }
+
+    /**
+     * Returns the widget theme this widget class would like to use. Overriding is fine.
+     *
+     * @param theme theme to get widget theme from
+     * @return widget theme this widget wishes to use
+     */
+    @ApiStatus.OverrideOnly
+    protected WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getFallback();
+    }
+
+    @ApiStatus.OverrideOnly
+    protected WidgetTheme getActiveWidgetTheme(WidgetThemeEntry<?> widgetTheme, boolean hover) {
+        return widgetTheme.getTheme(hover);
+    }
+
+    /**
+     * Returns the actual used widget theme. Uses {@link #widgetTheme(String)} if it has been set, otherwise calls
+     * {@link #getWidgetThemeInternal(ITheme)}
+     *
+     * @param theme theme to get widget theme from
+     * @return widget theme this widget will use
+     */
+    @ApiStatus.NonExtendable
+    @Override
+    public final WidgetThemeEntry<?> getWidgetTheme(ITheme theme) {
+        if (this.widgetThemeOverride != null) {
+            return theme.getWidgetTheme(this.widgetThemeOverride);
+        }
+        return getWidgetThemeInternal(theme);
+    }
+
+    /**
+     * Returns the actual used widget theme. Uses {@link #widgetTheme(String)} if it has been set, otherwise calls
+     * {@link #getWidgetThemeInternal(ITheme)}
+     *
+     * @param theme        theme to get widget theme from
+     * @param expectedType type of the widget theme to expect used for validation
+     * @return widget theme this widget will use
+     */
+    @SuppressWarnings("unchecked")
+    @ApiStatus.NonExtendable
+    public final <T extends WidgetTheme> WidgetThemeEntry<T> getWidgetTheme(ITheme theme, Class<T> expectedType) {
+        WidgetThemeEntry<?> entry = getWidgetTheme(theme);
+        if (entry.getKey().isOfType(expectedType)) {
+            return (WidgetThemeEntry<T>) entry;
+        }
+        throw new IllegalStateException(String.format(
+                "Got widget theme with invalid type in widget '%s'. Got type '%s'" +
+                        ", but expected type '%s'!",
+                this, entry.getKey().getWidgetThemeType().getSimpleName(), expectedType.getSimpleName()));
+    }
+
+    /**
+     * Sets a background override. Ideally this is set in the used theme. Also consider using
+     * {@link #overlay(IDrawable...)} instead.
+     * Using {@link IDrawable#EMPTY} will make the background invisible while still overriding the widget theme.
+     * Background are drawn before the widget and overlays are drawn.
+     *
+     * @param background background to use.
+     * @return this
+     */
+    public W background(IDrawable... background) {
+        this.background = IDrawable.of(background);
+        return getThis();
+    }
+
+    /**
+     * Sets an overlay. Does not interfere with themes. Overlays are drawn after the widget and backgrounds.
+     *
+     * @param overlay overlay to use.
+     * @return this
+     */
+    public W overlay(IDrawable... overlay) {
+        this.overlay = IDrawable.of(overlay);
+        return getThis();
+    }
+
+    /**
+     * Sets a hover background override. Ideally this is set in the used theme. Also consider using
+     * {@link #hoverOverlay(IDrawable...)} instead.
+     * Using {@link IDrawable#EMPTY} will make the background invisible while still overriding the widget theme.
+     * Background are drawn before the widget and overlays are drawn.
+     * <p>
+     * Following argument special cases should be considered:
+     * <ul>
+     * <li>{@code null} will fallback to {@link WidgetThemeEntry#getHoverTheme()}</li>
+     * <li>{@link IDrawable#EMPTY} will make the hover background invisible</li>
+     * <li>{@link IDrawable#NONE} will use the normal background instead (which is also achieved using
+     * {@link #disableHoverBackground()})</li>
+     * <li>multiple drawables, will result in them being drawn on top of each other in the order they are passed to the
+     * method</li>
+     * </ul>
+     *
+     * @param background hover background to use.
+     * @return this
+     */
+    public W hoverBackground(IDrawable... background) {
+        this.hoverBackground = IDrawable.of(background);
+        return getThis();
+    }
+
+    /**
+     * Sets a hover overlay.
+     * Using {@link IDrawable#EMPTY} will make the background invisible while still overriding the widget theme.
+     * Background are drawn before the widget and overlays are drawn.
+     * <p>
+     * Following argument special cases should be considered:
+     * <ul>
+     * <li>{@link IDrawable#EMPTY} will make the hover overlay invisible</li>
+     * <li>{@code null} and {@link IDrawable#NONE} will use the normal overlay instead (which is also achieved using
+     * {@link #disableHoverOverlay()})</li>
+     * <li>multiple drawables, will result in them being drawn on top of each other in the order they are passed to the
+     * method</li>
+     * </ul>
+     *
+     * @param overlay hover overlay to use.
+     * @return this
+     */
+    public W hoverOverlay(IDrawable... overlay) {
+        this.hoverOverlay = IDrawable.of(overlay);
+        return getThis();
+    }
+
+    /**
+     * Forces the hover background to use the normal background instead.
+     *
+     * @return this
+     */
+    public W disableHoverBackground() {
+        return hoverBackground(IDrawable.NONE);
+    }
+
+    /**
+     * Forces the hover overlay to use the normal overlay instead.
+     *
+     * @return this
+     */
+    public W disableHoverOverlay() {
+        return hoverOverlay(IDrawable.NONE);
+    }
+
+    /**
+     * Sets an override widget theme. This will change of the appearance of this widget according to the widget theme.
+     *
+     * @param s id of the widget theme (see constants in {@link IThemeApi})
+     * @return this
+     */
+    public W widgetTheme(String s) {
+        WidgetThemeKey<?> widgetThemeKey = WidgetThemeKey.getFromFullName(s);
+        if (widgetThemeKey == null) {
+            throw new IllegalArgumentException("No widget theme for id '" + s + "' exists.");
+        }
+        return widgetTheme(widgetThemeKey);
+    }
+
+    /**
+     * Sets an override widget theme. This will change of the appearance of this widget according to the widget theme.
+     *
+     * @param s id of the widget theme (see constants in {@link IThemeApi})
+     * @return this
+     */
+    public W widgetTheme(WidgetThemeKey<?> s) {
+        this.widgetThemeOverride = s;
+        return getThis();
+    }
+
+    // --------------
+    // === Events ===
+    // --------------
+
+    /**
+     * Called once every tick (20 times per second). Overriding is fine, but super should be called. This will be called
+     * even of the widget
+     * is not enabled.
+     * By default, this will invoke update listeners set via setters.
+     */
+    @MustBeInvokedByOverriders
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (this.onUpdateListener != null) {
+            this.onUpdateListener.accept(getThis());
+        }
+    }
+
+    /**
+     * Registers a gui action this widget can listen to. Gui action listeners can listen to several mouse and keyboard
+     * input events.
+     * The listeners are called first, before any widgets are interacted with. The listeners will always be called, even
+     * if the widget
+     * is disabled or not hovered!
+     * <p>
+     * Lambdas must be cast to the appropriate functional interface.
+     * These actions are automatically unregistered when the widget is removed from the widget tree.
+     *
+     * @param action gui action to register
+     * @return this
+     */
+    public W listenGuiAction(IGuiAction action) {
+        if (this.guiActionListeners == null) {
+            this.guiActionListeners = new ArrayList<>();
+        }
+        this.guiActionListeners.add(action);
+        if (isValid()) {
+            getScreen().registerGuiActionListener(action);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets an update listener which is called once every tick even when this widget is disabled.
+     *
+     * @param listener update listener
+     * @return this
+     */
+    public W onUpdateListener(Consumer<W> listener) {
+        return onUpdateListener(listener, false);
+    }
+
+    /**
+     * Sets an update listener which is called once every tick even when this widget is disabled.
+     * If a listener is already set and {@code merge} is true, the listeners will be merged, so that both will be called
+     * on tick.
+     *
+     * @param listener update listener
+     * @return this
+     */
+    public W onUpdateListener(Consumer<W> listener, boolean merge) {
+        if (merge && this.onUpdateListener != null) {
+            final Consumer<W> oldListener = this.onUpdateListener;
+            if (listener != null) {
+                this.onUpdateListener = w -> {
+                    oldListener.accept(w);
+                    listener.accept(w);
+                };
+            }
+        } else {
+            this.onUpdateListener = listener;
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets a condition for when to enable/disable this widget. This register an update listener which checks the
+     * condition every tick.
+     * Careful not to overwrite this when calling {@link #onUpdateListener(Consumer)} afterward!
+     *
+     * @param condition condition when to enable this widget
+     * @return this
+     */
+    public W setEnabledIf(Predicate<W> condition) {
+        return onUpdateListener(w -> setEnabled(condition.test(w)), true);
+    }
+
+    // ----------------
+    // === Resizing ===
+    // ----------------
+
+    @Override
+    public int getDefaultWidth() {
+        return isValid() ? getWidgetTheme(getPanel().getTheme()).getTheme().getDefaultWidth() : 18;
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return isValid() ? getWidgetTheme(getPanel().getTheme()).getTheme().getDefaultHeight() : 18;
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        super.transform(stack);
+        if (this.transform != null) {
+            this.transform.accept(getThis(), stack);
+        }
+    }
+
+    public W transform(BiConsumer<W, IViewportStack> transform) {
+        this.transform = transform;
+        return getThis();
+    }
+
+    // ---------------
+    // === Syncing ===
+    // --------------
+
+    /**
+     * Returns if this widget has a valid sync handler.
+     */
+    @Override
+    public boolean isSynced() {
+        return this.syncHandler != null;
+    }
+
+    /**
+     * Returns the sync handler of this widget.
+     *
+     * @throws IllegalStateException if this widget has no sync handler ({@link #isSynced()} returns false)
+     */
+    @Override
+    public @NotNull SyncHandler getSyncHandler() {
+        if (this.syncHandler == null) {
+            throw new IllegalStateException("Widget is not initialised or not synced!");
+        }
+        return this.syncHandler;
+    }
+
+    /**
+     * Sets a sync handler id. A sync handler with the same id must have been registered to the appropriate
+     * {@link com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager PanelSyncManager} for this to work.
+     * This method is preferred over setting a sync handler directly since this does not require the widget to be
+     * defined on both sides.
+     *
+     * @param name sync handler key name
+     * @param id   sync handler key id
+     * @return this
+     */
+    @Override
+    public W syncHandler(String name, int id) {
+        this.syncKey = ISyncRegistrar.makeSyncKey(name, id);
+        return getThis();
+    }
+
+    @MustBeInvokedByOverriders
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        if (!syncOrValue.isSyncHandler() && !syncOrValue.isValueHandler()) return;
+        checkValidSyncOrValue(syncOrValue);
+        if (syncOrValue instanceof SyncHandler syncHandler) this.syncHandler = syncHandler;
+        if (syncOrValue instanceof IValue<?> value) this.value = value;
+    }
+
+    // -------------
+    // === Other ===
+    // -------------
+
+    public W excludeAreaInRecipeViewer() {
+        return excludeAreaInRecipeViewer(true);
+    }
+
+    public W excludeAreaInRecipeViewer(boolean val) {
+        this.excludeAreaInRecipeViewer = val;
+        if (isValid()) {
+            getContext().getRecipeViewerSettings().addExclusionArea(this);
+        }
+        return getThis();
+    }
+
+    /**
+     * Disables the widget from start. Useful inside widget tree creation, where widget references are usually not
+     * stored.
+     *
+     * @return this
+     */
+    public W disabled() {
+        setEnabled(false);
+        return getThis();
+    }
+
+    @Override
+    public Object getAdditionalHoverInfo(IViewportStack viewportStack, int mouseX, int mouseY) {
+        if (this instanceof IDragResizeable dragResizeable) {
+            return IDragResizeable.getDragResizeCorner(dragResizeable, getArea(), viewportStack, mouseX, mouseY);
+        }
+        return null;
+    }
+
+    /**
+     * This can be used to find the widget with various methods from {@link WidgetTree} from a parent.
+     * The name is also included in {@link #toString()}.
+     *
+     * @param name debug name to use
+     * @return this
+     */
+    public W name(String name) {
+        setName(name);
+        return getThis();
+    }
+
+    /**
+     * Returns this widget with proper generic type.
+     *
+     * @return this
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public W getThis() {
+        return (W) this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/WidgetTree.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/WidgetTree.java
new file mode 100644
index 00000000000..cabe7bfd6cf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/WidgetTree.java
@@ -0,0 +1,332 @@
+package com.gregtechceu.gtceu.api.mui.widget;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.widget.ISynced;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.TreeUtil;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.ResizeNode;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
+
+import net.minecraft.Util;
+import net.minecraft.network.chat.Component;
+
+import org.apache.commons.lang3.mutable.MutableInt;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+/**
+ * Helper class to perform operations on widget trees such as traversing, drawing, resizing, finding widgets and
+ * printing it.
+ */
+public class WidgetTree extends TreeUtil {
+
+    /**
+     * If this variable is true, the time it takes to resize a sub widget tree is logged each time.
+     * In production this should always be false.
+     */
+    public static boolean logResizeTime = false;
+
+    public static final WidgetInfo WIDGET_INFO_AREA = (root, widget, builder) -> builder
+            .append("Area xywh:")
+            .append(widget.getArea().x - root.getArea().x)
+            .append(", ")
+            .append(widget.getArea().y - root.getArea().y)
+            .append(" | ")
+            .append(widget.getArea().width)
+            .append(", ")
+            .append(widget.getArea().height)
+            .append(", rx: ").append(widget.getArea().rx)
+            .append(", ry: ").append(widget.getArea().ry);
+
+    public static final WidgetInfo WIDGET_INFO_ENABLED = (root, widget, builder) -> builder.append("Enabled: ")
+            .append(widget.isEnabled());
+    public static final WidgetInfo WIDGET_INFO_WIDGET_THEME = (root, widget, builder) -> builder
+            .append("Widget theme: ")
+            .append(widget.getWidgetTheme(widget.getPanel().getTheme()).getKey().getFullName());
+
+    private WidgetTree() {}
+
+    /**
+     * Finds the first widget in the sub widget tree that matches the given name.
+     *
+     * @param parent starting point
+     * @param name   name of the target widget
+     * @return the first widget with matching name or null if none was found
+     */
+    public static @Nullable IWidget findFirstWithNameNullable(IWidget parent, String name) {
+        return foreachChildWithResult(parent, w -> w.isName(name) ? w : null, true);
+    }
+
+    /**
+     * Finds the first widget in the sub widget tree that matches the given name.
+     *
+     * @param parent starting point
+     * @param name   name of the target widget
+     * @return the first widget with matching name
+     * @throws NoSuchElementException if no widget with the given name and type was found
+     */
+    public static @NotNull IWidget findFirstWithName(IWidget parent, String name) {
+        IWidget w = findFirstWithNameNullable(parent, name);
+        if (w == null) {
+            throw new NoSuchElementException("Expected to find widget with name '" + name +
+                    "' in sub widget tree of '" + parent + "', but non was found.");
+        }
+        return w;
+    }
+
+    /**
+     * Finds the first widget in the sub widget tree that matches the given name and type.
+     *
+     * @param parent starting point
+     * @param name   name of the target widget
+     * @param type   type of the target widget
+     * @param <T>    type of the target widget
+     * @return the first widget with matching name and class or null if none was found
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends IWidget> @Nullable T findFirstWithNameNullable(IWidget parent, String name,
+                                                                            Class<T> type) {
+        return foreachChildWithResult(parent, w -> w.isNameAndType(name, type) ? (T) w : null, true);
+    }
+
+    /**
+     * Finds the first widget in the sub widget tree that matches the given name and type.
+     *
+     * @param parent starting point
+     * @param name   name of the target widget
+     * @param type   type of the target widget
+     * @param <T>    type of the target widget
+     * @return the first widget with matching name and class
+     * @throws NoSuchElementException if no widget with the given name and type was found.
+     */
+    public static <T extends IWidget> @NotNull T findFirstWithName(IWidget parent, String name, Class<T> type) {
+        T w = findFirstWithNameNullable(parent, name, type);
+        if (w == null) {
+            throw new NoSuchElementException(
+                    "Expected to find widget with name '" + name + "' and type '" + type.getName() +
+                            "' in sub widget tree of '" + parent + "', but non was found.");
+        }
+        return w;
+    }
+
+    /**
+     * Finds a child of a parent at a given path. Each part of the path is name of a widget. That means every widget in
+     * the path to the
+     * target must be named and their names must be included in order.
+     *
+     * @param parent starting point
+     * @param path   path with each widget name in the path to the target
+     * @return the widget at the given path or null if none was found.
+     * @throws IllegalArgumentException if the path is empty
+     */
+    public static @Nullable IWidget findChildAtNullable(IWidget parent, String... path) {
+        if (path.length == 0) throw new IllegalArgumentException("Path to child must not be empty!");
+        return InternalWidgetTree.findChildAt(parent, IWidget.class, path, 0, true);
+    }
+
+    /**
+     * Finds a child of a parent at a given path. Each part of the path is name of a widget. That means every widget in
+     * the path to the
+     * target must be named and their names must be included in order.
+     *
+     * @param parent starting point
+     * @param path   path with each widget name in the path to the target
+     * @return the widget at the given path
+     * @throws IllegalArgumentException if the path is empty
+     * @throws NoSuchElementException   if a single widget in the path could not be found
+     */
+    public static @NotNull IWidget findChildAt(IWidget parent, String... path) {
+        if (path.length == 0) throw new IllegalArgumentException("Path to child must not be empty!");
+        return InternalWidgetTree.findChildAt(parent, IWidget.class, path, 0, false);
+    }
+
+    /**
+     * Finds a child of a parent at a given path. Each part of the path is name of a widget. That means every widget in
+     * the path to the
+     * target must be named and their names must be included in order.
+     *
+     * @param parent starting point
+     * @param type   type of the target
+     * @param path   path with each widget name in the path to the target
+     * @param <T>    the target widget type
+     * @return the widget at the given path or null if none was found.
+     * @throws IllegalArgumentException if the path is empty
+     * @throws ClassCastException       if a target widget was found, but the expected type doesn't match
+     */
+    public static <T extends IWidget> @Nullable T findChildAtNullable(IWidget parent, Class<T> type, String... path) {
+        if (path.length == 0) throw new IllegalArgumentException("Path to child must not be empty!");
+        return InternalWidgetTree.findChildAt(parent, type, path, 0, true);
+    }
+
+    /**
+     * Finds a child of a parent at a given path. Each part of the path is name of a widget. That means every widget in
+     * the path to the
+     * target must be named and their names must be included in order.
+     *
+     * @param parent starting point
+     * @param type   type of the target
+     * @param path   path with each widget name in the path to the target
+     * @param <T>    the target widget type
+     * @return the widget at the given path
+     * @throws IllegalArgumentException if the path is empty
+     * @throws ClassCastException       if a target widget was found, but the expected type doesn't match
+     * @throws NoSuchElementException   if a single widget in the path could not be found
+     */
+    public static <T extends IWidget> @NotNull T findChildAt(IWidget parent, Class<T> type, String... path) {
+        if (path.length == 0) throw new IllegalArgumentException("Path to child must not be empty!");
+        return InternalWidgetTree.findChildAt(parent, type, path, 0, false);
+    }
+
+    public static boolean hasSyncedValues(ModularPanel panel) {
+        return !foreachChild(panel, widget -> !(widget instanceof ISynced<?> synced) || !synced.isSynced(), true);
+    }
+
+    @ApiStatus.Internal
+    public static void collectSyncValues(PanelSyncManager syncManager, ModularPanel panel) {
+        collectSyncValues(syncManager, panel, true);
+    }
+
+    @ApiStatus.Internal
+    public static void collectSyncValues(PanelSyncManager syncManager, ModularPanel panel, boolean includePanel) {
+        collectSyncValues(syncManager, panel.getName(), panel, includePanel);
+    }
+
+    @ApiStatus.Internal
+    public static void collectSyncValues(PanelSyncManager syncManager, String panelName, IWidget panel,
+                                         boolean includePanel) {
+        MutableInt id = new MutableInt(0);
+        String syncKey = ModularSyncManager.AUTO_SYNC_PREFIX + panelName;
+        foreachChildBFS(panel, widget -> {
+            if (widget instanceof ISynced<?> synced) {
+                if (synced.isSynced() && !synced.getSyncHandler().isRegistered(syncManager)) {
+                    syncManager.syncValue(syncKey, id.getAndIncrement(), synced.getSyncHandler());
+                }
+            }
+            return true;
+        }, includePanel);
+    }
+
+    public static int countUnregisteredSyncHandlers(PanelSyncManager syncManager, IWidget parent) {
+        MutableInt count = new MutableInt();
+        foreachChildBFS(parent, widget -> {
+            if (widget instanceof ISynced<?> synced && synced.isSynced() &&
+                    !synced.getSyncHandler().isRegistered(syncManager)) {
+                count.increment();
+            }
+            return true;
+        });
+        return count.intValue();
+    }
+
+    public static void drawTree(IWidget parent, ModularGuiContext context) {
+        drawTree(parent, context, false, true);
+    }
+
+    public static void drawTree(IWidget parent, ModularGuiContext context, boolean ignoreEnabled,
+                                boolean shouldDrawBackground) {
+        InternalWidgetTree.drawTree(parent, context, ignoreEnabled, shouldDrawBackground);
+    }
+
+    public static void drawTreeForeground(IWidget parent, ModularGuiContext context) {
+        InternalWidgetTree.drawTreeForeground(parent, context);
+    }
+
+    @ApiStatus.Internal
+    public static void onUpdate(IWidget parent) {
+        foreachChildBFS(parent, widget -> {
+            widget.onUpdate();
+            return true;
+        }, true);
+    }
+
+    @Deprecated
+    public static void resize(IWidget parent) {
+        parent.scheduleResize();
+    }
+
+    @ApiStatus.Internal
+    public static void resizeInternal(ResizeNode parent, boolean onOpen) {
+        if (!GTCEu.isClientThread()) return;
+
+        long time = Util.getNanos();
+
+        while (parent.getParent() != null &&
+                (parent.getParent().dependsOnChildren() || parent.getParent().isLayout())) {
+            parent = parent.getParent();
+        }
+        // resize each widget and calculate their relative pos
+        try {
+            if (!InternalWidgetTree.resize(parent, true, onOpen, false) &&
+                    !InternalWidgetTree.resize(parent, false, onOpen, false)) {
+                if (MCHelper.getPlayer() != null) {
+                    MCHelper.getPlayer().sendSystemMessage(Component.literal("MUI: Failed to resize sub tree of " +
+                            parent.getDebugDisplayName() + ". See log for more info."));
+                }
+                GTCEu.LOGGER.error("Failed to resize widget. Affected resize node tree:");
+                print(parent, RESIZE_NODE_INFO_RESIZED_COLLAPSED);
+            }
+            // now apply the calculated pos
+            preApplyPos(parent);
+            applyPos(parent);
+            postFullResize(parent);
+        } catch (Throwable e) {
+            GTCEu.LOGGER.fatal("An exception was thrown while resizing widgets. Exception:");
+            GTCEu.LOGGER.catching(e);
+            GTCEu.LOGGER.fatal("Affected node tree:");
+            print(parent, RESIZE_NODE_INFO_RESIZED_COLLAPSED);
+        }
+
+        if (WidgetTree.logResizeTime) {
+            time = Util.getNanos() - time;
+            GTCEu.LOGGER.info("Resized widget tree in {} ns and {} ns for full resize.",
+                    FormattingUtil.formatNumbers(time),
+                    FormattingUtil.formatNumbers(time));
+        }
+    }
+
+    public static void preApplyPos(ResizeNode parent) {
+        parent.preApplyPos();
+        for (ResizeNode resizeNode : parent.getChildren()) {
+            preApplyPos(resizeNode);
+        }
+    }
+
+    public static void applyPos(ResizeNode parent) {
+        parent.applyPos();
+        for (ResizeNode resizeNode : parent.getChildren()) {
+            applyPos(resizeNode);
+        }
+    }
+
+    public static void postFullResize(ResizeNode parent) {
+        parent.postFullResize();
+        for (ResizeNode resizeNode : parent.getChildren()) {
+            postFullResize(resizeNode);
+        }
+    }
+
+    public static void verifyTree(ResizeNode parent, Set<ResizeNode> visited) {
+        if (visited.contains(parent)) {
+            throw new IllegalStateException("Found cycling resize node dependencies!");
+        }
+        visited.add(parent);
+        if (!parent.getChildren().isEmpty()) {
+            for (ResizeNode child : parent.getChildren()) {
+                verifyTree(child, visited);
+            }
+        }
+    }
+
+    /**
+     * An interface to add information of a widget to a string builder.
+     */
+    public interface WidgetInfo extends NodeInfo<IWidget> {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/HorizontalScrollData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/HorizontalScrollData.java
new file mode 100644
index 00000000000..58e8e1cbf3b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/HorizontalScrollData.java
@@ -0,0 +1,89 @@
+package com.gregtechceu.gtceu.api.mui.widget.scroll;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+public class HorizontalScrollData extends ScrollData {
+
+    /**
+     * Creates horizontal scroll data which handles scrolling and scroll bar.
+     * Scrollbar is 4 pixels high and is placed at the bottom.
+     */
+    public HorizontalScrollData() {
+        this(false, DEFAULT_THICKNESS);
+    }
+
+    /**
+     * Creates horizontal scroll data which handles scrolling and scroll bar.
+     * Scrollbar is 4 pixels high.
+     *
+     * @param topAlignment if the scroll bar should be placed at the top
+     */
+    public HorizontalScrollData(boolean topAlignment) {
+        this(topAlignment, DEFAULT_THICKNESS);
+    }
+
+    /**
+     * Creates horizontal scroll data which handles scrolling and scroll bar.
+     *
+     * @param topAlignment if the scroll bar should be placed at the top
+     * @param thickness    height of the scroll bar in pixels
+     */
+    public HorizontalScrollData(boolean topAlignment, int thickness) {
+        super(GuiAxis.X, topAlignment, thickness);
+    }
+
+    public HorizontalScrollData cancelScrollEdge(boolean cancelScrollEdge) {
+        setCancelScrollEdge(cancelScrollEdge);
+        return this;
+    }
+
+    @Override
+    protected int getFallbackThickness(WidgetTheme widgetTheme) {
+        return widgetTheme.getDefaultHeight();
+    }
+
+    @Override
+    public VerticalScrollData getOtherScrollData(ScrollArea area) {
+        return area.getScrollY();
+    }
+
+    @Override
+    public boolean isInsideScrollbarArea(ScrollArea area, int x, int y) {
+        if (!isScrollBarActive(area, false)) {
+            return false;
+        }
+        int scrollbar = getThickness();
+        ScrollData data = getOtherScrollData(area);
+        if (data != null && isOtherScrollBarActive(area, true)) {
+            int thickness = data.getThickness();
+            if (data.isAxisStart() ? x < thickness : x >= area.w() - thickness) {
+                return false;
+            }
+        }
+        return isAxisStart() ? y >= 0 && y < scrollbar : y >= area.h() - scrollbar && y < area.h();
+    }
+
+    @Override
+    public void drawScrollbar(GuiContext context, ScrollArea area, WidgetTheme widgetTheme, IDrawable texture) {
+        boolean isOtherActive = isOtherScrollBarActive(area, true);
+        int l = getScrollBarLength(area);
+        int x = 0;
+        int y = isAxisStart() ? 0 : area.height - getThickness();
+        int w = area.width;
+        int h = getThickness();
+        GuiDraw.drawRect(context.getGraphics(), x, y, w, h, area.getScrollBarBackgroundColor());
+
+        x = getScrollBarStart(area, l, isOtherActive);
+        ScrollData data2 = getOtherScrollData(area);
+        if (data2 != null && isOtherActive && data2.isAxisStart()) {
+            x += data2.getThickness();
+        }
+
+        w = l;
+        drawScrollBar(context, x, y, w, h, widgetTheme, texture);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollArea.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollArea.java
new file mode 100644
index 00000000000..7da82d30a3d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollArea.java
@@ -0,0 +1,220 @@
+package com.gregtechceu.gtceu.api.mui.widget.scroll;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.util.Mth;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+/**
+ * Scrollable area
+ * <p>
+ * This class is responsible for storing information for scrollable one
+ * directional objects.
+ */
+@Accessors(chain = true)
+public class ScrollArea extends Area {
+
+    @Getter
+    @Setter
+    private HorizontalScrollData scrollX;
+    @Getter
+    @Setter
+    private VerticalScrollData scrollY;
+    private final ScrollPadding scrollPadding = new ScrollPadding();
+    @Getter
+    @Setter
+    private int scrollBarBackgroundColor = Color.withAlpha(Color.BLACK.main, 0.25f);
+
+    public ScrollArea(int x, int y, int w, int h) {
+        super(x, y, w, h);
+    }
+
+    public ScrollArea() {}
+
+    @Override
+
+    public Box getPadding() {
+        return this.scrollPadding;
+    }
+
+    public ScrollPadding getScrollPadding() {
+        return this.scrollPadding;
+    }
+
+    public void setScrollData(ScrollData data) {
+        if (data instanceof HorizontalScrollData scrollData) {
+            this.scrollX = scrollData;
+        } else if (data instanceof VerticalScrollData scrollData) {
+            this.scrollY = scrollData;
+        }
+    }
+
+    public void removeScrollData() {
+        this.scrollX = null;
+        this.scrollY = null;
+    }
+
+    public ScrollData getScrollData(GuiAxis axis) {
+        return axis.isVertical() ? this.scrollY : this.scrollX;
+    }
+
+    /* GUI code for easier manipulations */
+
+    @OnlyIn(Dist.CLIENT)
+    public boolean mouseClicked(GuiContext context) {
+        return this.mouseClicked(context.getMouseX(), context.getMouseY());
+    }
+
+    /**
+     * This method should be invoked to register dragging
+     */
+    public boolean mouseClicked(int x, int y) {
+        if (this.scrollX != null && this.scrollX.isInsideScrollbarArea(this, x, y)) {
+            return this.scrollX.onMouseClicked(this, x, y, 0);
+        } else if (this.scrollY != null && this.scrollY.isInsideScrollbarArea(this, x, y)) {
+            return this.scrollY.onMouseClicked(this, y, x, 0);
+        } else {
+            return false;
+        }
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public boolean mouseScroll(GuiContext context) {
+        return this.mouseScroll(context.getMouseX(), context.getMouseY(), context.getMouseScrollDelta(),
+                Screen.hasShiftDown());
+    }
+
+    /**
+     * This method should be invoked when mouse wheel is scrolling
+     */
+    public boolean mouseScroll(int x, int y, double scroll, boolean shift) {
+        ScrollData data;
+        if (this.scrollX != null && this.scrollX.isScrollBarActive(this)) {
+            data = this.scrollY == null || !this.scrollY.isScrollBarActive(this) || shift ? this.scrollX : this.scrollY;
+        } else if (this.scrollY != null && this.scrollY.isScrollBarActive(this)) {
+            data = this.scrollY;
+        } else {
+            // no scroll data present -> cant be scrolled
+            return false;
+        }
+
+        int scrollAmount = (int) Math.copySign(data.getScrollSpeed(), scroll);
+        int scrollTo;
+        if (data.isAnimating()) {
+            scrollTo = data.getAnimatingTo() - scrollAmount;
+        } else {
+            scrollTo = data.getScroll() - scrollAmount;
+        }
+
+        // simulate scroll to determine whether event should be canceled
+        int oldScroll = data.getScroll();
+        data.scrollTo(this, scrollTo);
+        boolean changed = data.getScroll() != oldScroll;
+        data.scrollTo(this, oldScroll);
+        if (changed) {
+            data.animateTo(this, scrollTo);
+            return true;
+        }
+        return data.isCancelScrollEdge();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void mouseReleased(GuiContext context) {
+        this.mouseReleased(context.getMouseX(), context.getMouseY());
+    }
+
+    /**
+     * When mouse button gets released
+     */
+    public void mouseReleased(int x, int y) {
+        if (this.scrollX != null) {
+            this.scrollX.dragging = false;
+            this.scrollX.clickOffset = 0;
+        }
+        if (this.scrollY != null) {
+            this.scrollY.dragging = false;
+            this.scrollY.clickOffset = 0;
+        }
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void drag(GuiContext context) {
+        this.drag(context.getMouseX(), context.getMouseY());
+    }
+
+    /**
+     * This should be invoked in a drawing or and update method. It's
+     * responsible for scrolling through this view when dragging.
+     */
+    public void drag(int x, int y) {
+        ScrollData data;
+        float progress;
+        if (this.scrollX != null && this.scrollX.dragging) {
+            data = this.scrollX;
+            progress = data.getProgress(this, x, y);
+        } else if (this.scrollY != null && this.scrollY.dragging) {
+            data = this.scrollY;
+            progress = data.getProgress(this, y, x);
+        } else {
+            return;
+        }
+        progress = Mth.clamp(progress, 0f, 1f);
+        data.scrollTo(this,
+                (int) (progress * (data.getScrollSize() - data.getFullVisibleSize(this) + data.getThickness())));
+    }
+
+    public boolean isInsideScrollbarArea(int x, int y) {
+        if (!isInside(x, y)) {
+            return false;
+        }
+        if (this.scrollX != null && this.scrollX.isInsideScrollbarArea(this, x, y)) {
+            return true;
+        }
+        return this.scrollY != null && this.scrollY.isInsideScrollbarArea(this, x, y);
+    }
+
+    public boolean isScrollBarXActive() {
+        return this.scrollX != null && this.scrollX.isScrollBarActive(this);
+    }
+
+    public boolean isScrollBarYActive() {
+        return this.scrollY != null && this.scrollY.isScrollBarActive(this);
+    }
+
+    public boolean isDragging() {
+        return (this.scrollX != null && this.scrollX.isDragging()) ||
+                (this.scrollY != null && this.scrollY.isDragging());
+    }
+
+    public void applyWidgetTheme(WidgetTheme widgetTheme) {
+        if (this.scrollX != null) this.scrollX.applyWidgetTheme(widgetTheme);
+        if (this.scrollY != null) this.scrollY.applyWidgetTheme(widgetTheme);
+    }
+
+    /**
+     * This method is responsible for drawing a scroll bar
+     */
+    @OnlyIn(Dist.CLIENT)
+    public void drawScrollbar(GuiContext context, WidgetTheme widgetTheme, IDrawable texture) {
+        boolean isXActive = false; // micro optimisation
+        if (this.scrollX != null && this.scrollX.isScrollBarActive(this, false)) {
+            isXActive = true;
+            this.scrollX.drawScrollbar(context, this, widgetTheme, texture);
+        }
+        if (this.scrollY != null && this.scrollY.isScrollBarActive(this, isXActive)) {
+            this.scrollY.drawScrollbar(context, this, widgetTheme, texture);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollData.java
new file mode 100644
index 00000000000..2f9dabf45e0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollData.java
@@ -0,0 +1,294 @@
+package com.gregtechceu.gtceu.api.mui.widget.scroll;
+
+import com.gregtechceu.gtceu.api.mui.animation.Animator;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.Scrollbar;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolation;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.util.Mth;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class ScrollData {
+
+    /**
+     * Creates scroll data which handles scrolling and scroll bar. Scrollbar is 4 pixels thick
+     * and will be at the end of the cross axis (bottom/right).
+     *
+     * @param axis axis on which to scroll
+     * @return new scroll data
+     */
+    public static ScrollData of(GuiAxis axis) {
+        return of(axis, false, DEFAULT_THICKNESS);
+    }
+
+    /**
+     * Creates scroll data which handles scrolling and scroll bar. Scrollbar is 4 pixels thick.
+     *
+     * @param axis      axis on which to scroll
+     * @param axisStart if the scroll bar should be at the start of the cross axis (left/top)
+     * @return new scroll data
+     */
+    public static ScrollData of(GuiAxis axis, boolean axisStart) {
+        return of(axis, axisStart, DEFAULT_THICKNESS);
+    }
+
+    /**
+     * Creates scroll data which handles scrolling and scroll bar.
+     *
+     * @param axis      axis on which to scroll
+     * @param axisStart if the scroll bar should be at the start of the cross axis (left/top)
+     * @param thickness cross axis thickness of the scroll bar in pixel
+     * @return new scroll data
+     */
+    public static ScrollData of(GuiAxis axis, boolean axisStart, int thickness) {
+        if (axis.isHorizontal()) return new HorizontalScrollData(axisStart, thickness);
+        return new VerticalScrollData(axisStart, thickness);
+    }
+
+    public static final int DEFAULT_THICKNESS = -1;
+
+    @Getter
+    private final GuiAxis axis;
+    @Getter
+    private final boolean axisStart;
+    private final int thickness;
+    private int fallbackThickness = -1;
+    @Getter
+    @Setter
+    private int scrollSpeed = 30;
+    /**
+     * Determines if scrolling of widgets below should still be canceled if this scroll view
+     * has hit the end and is currently not scrolling.
+     * Most of the time this should be true
+     *
+     * @return true if scrolling should be canceled even when this view hit an edge
+     */
+    @Getter
+    @Setter
+    private boolean cancelScrollEdge = true;
+    private IDrawable scrollbar;
+
+    @Getter
+    @Setter
+    private int scrollSize;
+    @Getter
+    private int scroll;
+    @Getter
+    protected boolean dragging;
+    protected int clickOffset;
+
+    @Getter
+    private int animatingTo = 0;
+    private final Animator scrollAnimator = new Animator()
+            .duration(500)
+            .curve(Interpolation.QUAD_OUT);
+
+    protected ScrollData(GuiAxis axis, boolean axisStart, int thickness) {
+        this.axis = axis;
+        this.axisStart = axisStart;
+        this.thickness = thickness > 0 ? Math.max(2, thickness) : -1;
+    }
+
+    public int getThickness() {
+        return this.thickness > 0 ? this.thickness : this.fallbackThickness;
+    }
+
+    public boolean isVertical() {
+        return this.axis.isVertical();
+    }
+
+    public boolean isHorizontal() {
+        return this.axis.isHorizontal();
+    }
+
+    public final int getMinLength() {
+        return getThickness() + 1; // make sure bar is always longer than thicker;
+    }
+
+    protected final int getRawVisibleSize(ScrollArea area) {
+        // the scroll area doesn't contribute to the visible size in this case
+        return Math.max(0, getRawFullVisibleSize(area) - area.getPadding().getTotal(this.axis) +
+                area.getScrollPadding().getTotalScrollPadding(this.axis));
+    }
+
+    protected final int getRawFullVisibleSize(ScrollArea area) {
+        return area.getSize(this.axis);
+    }
+
+    public final int getFullVisibleSize(ScrollArea area) {
+        return getFullVisibleSize(area, false);
+    }
+
+    public final int getFullVisibleSize(ScrollArea area, boolean isOtherActive) {
+        int s = getRawFullVisibleSize(area);
+        ScrollData data = getOtherScrollData(area);
+        if (data != null && (isOtherActive || data.isScrollBarActive(area, true))) {
+            s -= data.getThickness();
+        }
+        return s;
+    }
+
+    public final int getVisibleSize(ScrollArea area) {
+        return getVisibleSize(area, false);
+    }
+
+    public final int getVisibleSize(ScrollArea area, int fullVisibleSize) {
+        return Math.max(0, fullVisibleSize - area.getPadding().getTotal(this.axis));
+    }
+
+    public final int getVisibleSize(ScrollArea area, boolean isOtherActive) {
+        return getVisibleSize(area, getFullVisibleSize(area, isOtherActive));
+    }
+
+    public float getProgress(ScrollArea area, int mainAxisPos, int crossAxisPos) {
+        float fullSize = (float) getFullVisibleSize(area);
+        return (mainAxisPos - clickOffset) / (fullSize - getScrollBarLength(area));
+    }
+
+    @Nullable
+    public abstract ScrollData getOtherScrollData(ScrollArea area);
+
+    /**
+     * Clamp scroll to the bounds of the scroll size;
+     */
+    public boolean clamp(ScrollArea area) {
+        int size = getFullVisibleSize(area);
+
+        int old = this.scroll;
+        if (this.scrollSize <= size) {
+            this.scroll = 0;
+        } else {
+            this.scroll = Mth.clamp(this.scroll, 0, this.scrollSize - size);
+        }
+        return old != this.scroll; // returns true if the area was clamped
+    }
+
+    public boolean scrollBy(ScrollArea area, int x) {
+        this.scroll += x;
+        return clamp(area);
+    }
+
+    /**
+     * Scroll to the position in the scroll area
+     */
+    public boolean scrollTo(ScrollArea area, int x) {
+        this.scroll = x;
+        return clamp(area);
+    }
+
+    public void animateTo(ScrollArea area, int x) {
+        this.scrollAnimator.bounds(this.scroll, x).onUpdate(value -> {
+            if (scrollTo(area, (int) value)) {
+                this.scrollAnimator.stop(false); // stop animation once an edge is hit
+            }
+        });
+        this.scrollAnimator.reset();
+        this.scrollAnimator.animate();
+        this.animatingTo = x;
+    }
+
+    public final boolean isScrollBarActive(ScrollArea area) {
+        return isScrollBarActive(area, false);
+    }
+
+    public final boolean isScrollBarActive(ScrollArea area, boolean isOtherActive) {
+        int s = getRawFullVisibleSize(area);
+        if (s < this.scrollSize) return true;
+        ScrollData data = getOtherScrollData(area);
+        if (data == null || s - data.getThickness() >= this.scrollSize) return false;
+        if (isOtherActive || data.isScrollBarActive(area, true)) {
+            s -= data.getThickness();
+        }
+        return s < this.scrollSize;
+    }
+
+    public final boolean isOtherScrollBarActive(ScrollArea area, boolean isSelfActive) {
+        ScrollData data = getOtherScrollData(area);
+        return data != null && data.isScrollBarActive(area, isSelfActive);
+    }
+
+    public int getScrollBarLength(ScrollArea area) {
+        float fullSize = getFullVisibleSize(area);
+        int length = (int) (fullSize * fullSize / this.scrollSize);
+        return Math.max(length, getMinLength()); // min length of 4
+    }
+
+    public abstract boolean isInsideScrollbarArea(ScrollArea area, int x, int y);
+
+    public boolean isAnimating() {
+        return this.scrollAnimator.isAnimating();
+    }
+
+    public int getAnimationDirection() {
+        if (!isAnimating()) return 0;
+        return this.scrollAnimator.getMax() >= this.scrollAnimator.getMin() ? 1 : -1;
+    }
+
+    public int getScrollBarStart(ScrollArea area, int scrollBarLength, int fullVisibleSize) {
+        return ((fullVisibleSize - scrollBarLength) * getScroll()) /
+                (getScrollSize() - fullVisibleSize);
+    }
+
+    public int getScrollBarStart(ScrollArea area, int scrollBarLength, boolean isOtherActive) {
+        return getScrollBarStart(area, scrollBarLength, getFullVisibleSize(area, isOtherActive));
+    }
+
+    protected abstract int getFallbackThickness(WidgetTheme widgetTheme);
+
+    protected final void applyWidgetTheme(WidgetTheme widgetTheme) {
+        this.fallbackThickness = Math.max(2, getFallbackThickness(widgetTheme));
+    }
+
+    public ScrollData texture(IDrawable drawable) {
+        this.scrollbar = drawable;
+        return this;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public abstract void drawScrollbar(GuiContext context, ScrollArea area, WidgetTheme widgetTheme, IDrawable texture);
+
+    @OnlyIn(Dist.CLIENT)
+    protected void drawScrollBar(GuiContext context, int x, int y, int w, int h, WidgetTheme widgetTheme,
+                                 IDrawable texture) {
+        IDrawable drawable;
+        if (this.scrollbar != null) {
+            drawable = this.scrollbar;
+        } else if (widgetTheme.getBackground() != null && widgetTheme.getBackground() != IDrawable.NONE) {
+            drawable = widgetTheme.getBackground();
+        } else {
+            drawable = texture;
+        }
+        if (drawable == null) drawable = Scrollbar.DEFAULT;
+        drawable.draw(context, x, y, w, h, widgetTheme);
+    }
+
+    public boolean onMouseClicked(ScrollArea area, int mainAxisPos, int crossAxisPos, int button) {
+        if (isAxisStart() ? crossAxisPos <= getThickness() :
+                crossAxisPos >= area.getSize(this.axis.getOther()) - getThickness()) {
+            this.dragging = true;
+            this.clickOffset = mainAxisPos;
+
+            int scrollBarSize = getScrollBarLength(area);
+            int start = getScrollBarStart(area, scrollBarSize, false);
+            boolean clickInsideBar = mainAxisPos >= start &&
+                    mainAxisPos <= start + scrollBarSize;
+
+            if (clickInsideBar) {
+                this.clickOffset = mainAxisPos - start; // relative click position inside bar
+            } else {
+                this.clickOffset = scrollBarSize / 2; // assume click position in center of bar
+            }
+
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollPadding.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollPadding.java
new file mode 100644
index 00000000000..1feaeca51d1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/ScrollPadding.java
@@ -0,0 +1,161 @@
+package com.gregtechceu.gtceu.api.mui.widget.scroll;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+
+import java.util.Objects;
+
+public class ScrollPadding extends Box {
+
+    public static final ScrollPadding SHARED = new ScrollPadding();
+    public static final ScrollPadding ZERO = new ScrollPadding();
+
+    protected int scrollPaddingLeft;
+    protected int scrollPaddingTop;
+    protected int scrollPaddingRight;
+    protected int scrollPaddingBottom;
+
+    public ScrollPadding scrollPaddingAll(int all) {
+        return this.scrollPaddingAll(all, all);
+    }
+
+    public ScrollPadding scrollPaddingAll(int horizontal, int vertical) {
+        return this.scrollPaddingAll(horizontal, horizontal, vertical, vertical);
+    }
+
+    public ScrollPadding scrollPaddingAll(int left, int right, int top, int bottom) {
+        this.scrollPaddingLeft = left;
+        this.scrollPaddingTop = top;
+        this.scrollPaddingRight = right;
+        this.scrollPaddingBottom = bottom;
+        return this;
+    }
+
+    public ScrollPadding scrollPaddingLeft(int left) {
+        this.scrollPaddingLeft = left;
+        return this;
+    }
+
+    public ScrollPadding scrollPaddingTop(int top) {
+        this.scrollPaddingTop = top;
+        return this;
+    }
+
+    public ScrollPadding scrollPaddingRight(int right) {
+        this.scrollPaddingRight = right;
+        return this;
+    }
+
+    public ScrollPadding scrollPaddingBottom(int bottom) {
+        this.scrollPaddingBottom = bottom;
+        return this;
+    }
+
+    public ScrollPadding scrollPadding(GuiAxis axis, boolean start, int val) {
+        if (axis.isVertical()) {
+            if (start) {
+                scrollPaddingTop(val);
+            } else {
+                scrollPaddingBottom(val);
+            }
+        } else {
+            if (start) {
+                scrollPaddingLeft(val);
+            } else {
+                scrollPaddingRight(val);
+            }
+        }
+        return this;
+    }
+
+    public ScrollPadding setScrollPadding(ScrollPadding box) {
+        all(box.left, box.right, box.top, box.bottom);
+        return scrollPaddingAll(box.scrollPaddingLeft, box.scrollPaddingRight, box.scrollPaddingTop,
+                box.scrollPaddingBottom);
+    }
+
+    public int getLeft() {
+        return this.left + this.scrollPaddingLeft;
+    }
+
+    public int getRight() {
+        return this.right + this.scrollPaddingRight;
+    }
+
+    public int getTop() {
+        return this.top + this.scrollPaddingTop;
+    }
+
+    public int getBottom() {
+        return this.bottom + this.scrollPaddingBottom;
+    }
+
+    public int vertical() {
+        return super.vertical() + this.scrollPaddingTop + this.scrollPaddingBottom;
+    }
+
+    public int horizontal() {
+        return super.horizontal() + this.scrollPaddingLeft + this.scrollPaddingRight;
+    }
+
+    public int getStart(GuiAxis axis) {
+        return axis.isHorizontal() ? this.left + this.scrollPaddingLeft : this.top + this.scrollPaddingTop;
+    }
+
+    public int getEnd(GuiAxis axis) {
+        return axis.isHorizontal() ? this.right + this.scrollPaddingRight : this.bottom + this.scrollPaddingBottom;
+    }
+
+    public int getTotalScrollPadding(GuiAxis axis) {
+        return axis.isHorizontal() ? this.scrollPaddingLeft + this.scrollPaddingRight :
+                this.scrollPaddingTop + this.scrollPaddingBottom;
+    }
+
+    @Override
+    public Box interpolate(Box startBox, Box endBox, float t) {
+        super.interpolate(startBox, endBox, t);
+        if (startBox instanceof ScrollPadding start && endBox instanceof ScrollPadding end) {
+            this.scrollPaddingLeft = Interpolations.lerp(start.scrollPaddingLeft, end.scrollPaddingLeft, t);
+            this.scrollPaddingTop = Interpolations.lerp(start.scrollPaddingTop, end.scrollPaddingTop, t);
+            this.scrollPaddingRight = Interpolations.lerp(start.scrollPaddingRight, end.scrollPaddingRight, t);
+            this.scrollPaddingBottom = Interpolations.lerp(start.scrollPaddingBottom, end.scrollPaddingBottom, t);
+        }
+        return this;
+    }
+
+    @Override
+    public Box copyOrImmutable() {
+        return new ScrollPadding().setScrollPadding(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Box{" +
+                "left=" + this.scrollPaddingLeft +
+                ", top=" + this.scrollPaddingTop +
+                ", right=" + this.scrollPaddingRight +
+                ", bottom=" + this.scrollPaddingBottom +
+                '}';
+    }
+
+    public boolean isEqual(ScrollPadding box) {
+        return super.isEqual(box) && this.scrollPaddingLeft == box.scrollPaddingLeft &&
+                this.scrollPaddingTop == box.scrollPaddingTop &&
+                this.scrollPaddingRight == box.scrollPaddingRight &&
+                this.scrollPaddingBottom == box.scrollPaddingBottom;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        return isEqual((ScrollPadding) o);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.left, this.top, this.right, this.bottom,
+                this.scrollPaddingLeft, this.scrollPaddingTop, this.scrollPaddingRight, this.scrollPaddingBottom);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/VerticalScrollData.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/VerticalScrollData.java
new file mode 100644
index 00000000000..8a879954965
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/scroll/VerticalScrollData.java
@@ -0,0 +1,88 @@
+package com.gregtechceu.gtceu.api.mui.widget.scroll;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+public class VerticalScrollData extends ScrollData {
+
+    /**
+     * Creates vertical scroll data which handles scrolling and scroll bar.
+     * Scrollbar is 4 pixels wide and is placed on the right.
+     */
+    public VerticalScrollData() {
+        this(false, DEFAULT_THICKNESS);
+    }
+
+    /**
+     * Creates vertical scroll data which handles scrolling and scroll bar.
+     * Scrollbar is 4 pixels wide.
+     *
+     * @param leftAlignment if the scroll bar should be placed on the left
+     */
+    public VerticalScrollData(boolean leftAlignment) {
+        this(leftAlignment, DEFAULT_THICKNESS);
+    }
+
+    /**
+     * Creates vertical scroll data which handles scrolling and scroll bar.
+     *
+     * @param leftAlignment if the scroll bar should be placed on the left
+     * @param thickness     width of the scroll bar in pixel
+     */
+    public VerticalScrollData(boolean leftAlignment, int thickness) {
+        super(GuiAxis.Y, leftAlignment, thickness);
+    }
+
+    public VerticalScrollData cancelScrollEdge(boolean cancelScrollEdge) {
+        setCancelScrollEdge(cancelScrollEdge);
+        return this;
+    }
+
+    @Override
+    protected int getFallbackThickness(WidgetTheme widgetTheme) {
+        return widgetTheme.getDefaultWidth();
+    }
+
+    @Override
+    public HorizontalScrollData getOtherScrollData(ScrollArea area) {
+        return area.getScrollX();
+    }
+
+    @Override
+    public boolean isInsideScrollbarArea(ScrollArea area, int x, int y) {
+        if (!isScrollBarActive(area)) {
+            return false;
+        }
+        int scrollbar = getThickness();
+        ScrollData data = getOtherScrollData(area);
+        if (data != null && isOtherScrollBarActive(area, true)) {
+            int thickness = data.getThickness();
+            if (data.isAxisStart() ? y < thickness : y >= area.h() - thickness) {
+                return false;
+            }
+        }
+        return isAxisStart() ? x >= 0 && x < scrollbar : x >= area.w() - scrollbar && x < area.w();
+    }
+
+    @Override
+    public void drawScrollbar(GuiContext context, ScrollArea area, WidgetTheme widgetTheme, IDrawable texture) {
+        boolean isOtherActive = isOtherScrollBarActive(area, true);
+        int l = this.getScrollBarLength(area);
+        int x = isAxisStart() ? 0 : area.w() - getThickness();
+        int y = 0;
+        int w = getThickness();
+        int h = area.height;
+        GuiDraw.drawRect(context.getGraphics(), x, y, w, h, area.getScrollBarBackgroundColor());
+
+        y = getScrollBarStart(area, l, isOtherActive);
+        ScrollData data2 = getOtherScrollData(area);
+        if (data2 != null && isOtherActive && data2.isAxisStart()) {
+            y += data2.getThickness();
+        }
+        h = l;
+        drawScrollBar(context, x, y, w, h, widgetTheme, texture);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Area.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Area.java
new file mode 100644
index 00000000000..b83509f0373
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Area.java
@@ -0,0 +1,575 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.animation.IAnimatable;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.api.mui.utils.Point;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.utils.GTMath;
+
+import net.minecraft.util.Mth;
+
+import lombok.Getter;
+
+import java.util.Objects;
+
+/**
+ * A rectangular widget area, composed of a position and a size.
+ * Also has fields for a relative position, a layer and margin & padding.
+ */
+public class Area extends Rectangle implements IAnimatable<Area> {
+
+    public static boolean isInside(int x, int y, int w, int h, int px, int py) {
+        SHARED.set(x, y, w, h);
+        return SHARED.isInside(px, py);
+    }
+
+    public static final Area SHARED = new Area();
+
+    public static final Area ZERO = new Area();
+
+    /**
+     * relative position (in most cases the direct parent)
+     */
+    public int rx;
+    public int ry;
+    /**
+     * the widget layer within this panel
+     */
+    private int z;
+    @Getter
+    private final Box margin = new Box();
+    @Getter
+    private final Box padding = new Box();
+
+    public Area() {
+        super();
+    }
+
+    public Area(int x, int y, int w, int h) {
+        super(x, y, w, h);
+    }
+
+    public Area(Rectangle rectangle) {
+        super(rectangle);
+    }
+
+    public Area(Area area) {
+        super(area);
+        this.rx = area.rx;
+        this.ry = area.ry;
+        this.z = area.z;
+        getMargin().set(area.getMargin());
+        getPadding().set(area.getPadding());
+    }
+
+    public int x() {
+        return this.x;
+    }
+
+    public void x(int x) {
+        this.x = x;
+    }
+
+    public int y() {
+        return this.y;
+    }
+
+    public void y(int y) {
+        this.y = y;
+    }
+
+    public int w() {
+        return this.width;
+    }
+
+    public void w(int w) {
+        this.width = w;
+    }
+
+    public int h() {
+        return this.height;
+    }
+
+    public void h(int h) {
+        this.height = h;
+    }
+
+    public int ex() {
+        return this.x + this.width;
+    }
+
+    public void ex(int ex) {
+        this.x = ex - this.width;
+    }
+
+    public int ey() {
+        return this.y + this.height;
+    }
+
+    public void ey(int ey) {
+        this.y = ey - this.height;
+    }
+
+    public int mx() {
+        return (int) (this.x + this.width * 0.5);
+    }
+
+    public int my() {
+        return (int) (this.y + this.height * 0.5);
+    }
+
+    public int z() {
+        return this.z;
+    }
+
+    public void z(int z) {
+        this.z = z;
+    }
+
+    /**
+     * Calculate X based on anchor value
+     */
+    public int x(float anchor) {
+        return this.x + (int) (this.width * anchor);
+    }
+
+    /**
+     * Calculate Y based on anchor value
+     */
+    public int y(float anchor) {
+        return this.y + (int) (this.height * anchor);
+    }
+
+    public int getPoint(GuiAxis axis) {
+        return axis.isHorizontal() ? this.x : this.y;
+    }
+
+    public int getEndPoint(GuiAxis axis) {
+        return axis.isHorizontal() ? this.x + this.width : this.y + this.height;
+    }
+
+    public int getSize(GuiAxis axis) {
+        return axis.isHorizontal() ? this.width : this.height;
+    }
+
+    public int getRelativePoint(GuiAxis axis) {
+        return axis.isHorizontal() ? this.rx : this.ry;
+    }
+
+    public void setPoint(GuiAxis axis, int v) {
+        if (axis.isHorizontal()) {
+            this.x = v;
+        } else {
+            this.y = v;
+        }
+    }
+
+    public void setSize(GuiAxis axis, int v) {
+        if (axis.isHorizontal()) {
+            this.width = v;
+        } else {
+            this.height = v;
+        }
+    }
+
+    public void setRelativePoint(GuiAxis axis, int v) {
+        if (axis.isHorizontal()) {
+            this.rx = v;
+        } else {
+            this.ry = v;
+        }
+    }
+
+    public void addPoint(GuiAxis axis, int v) {
+        if (axis.isHorizontal()) {
+            this.x += v;
+        } else {
+            this.y += v;
+        }
+    }
+
+    public void addSize(GuiAxis axis, int v) {
+        if (axis.isHorizontal()) {
+            this.width += v;
+        } else {
+            this.height += v;
+        }
+    }
+
+    public void addRelativePoint(GuiAxis axis, int v) {
+        if (axis.isHorizontal()) {
+            this.rx += v;
+        } else {
+            this.ry += v;
+        }
+    }
+
+    void applyPos(int parentX, int parentY) {
+        this.x = parentX + this.rx;
+        this.y = parentY + this.ry;
+    }
+
+    public int requestedWidth() {
+        return this.width + getMargin().horizontal();
+    }
+
+    public int paddedWidth() {
+        return this.width - getPadding().horizontal();
+    }
+
+    public int requestedHeight() {
+        return this.height + getMargin().vertical();
+    }
+
+    public int paddedHeight() {
+        return this.height - getPadding().vertical();
+    }
+
+    public int requestedSize(GuiAxis axis) {
+        return axis.isHorizontal() ? requestedWidth() : requestedHeight();
+    }
+
+    public int paddedSize(GuiAxis axis) {
+        return axis.isHorizontal() ? paddedWidth() : paddedHeight();
+    }
+
+    public int relativeEndX() {
+        return this.rx + this.width;
+    }
+
+    public int relativeEndY() {
+        return this.ry + this.height;
+    }
+
+    /**
+     * Check whether given position is inside the rect.
+     * Use {@link com.gregtechceu.gtceu.api.mui.base.widget.IWidget#isInside(IViewportStack, int, int)} rather than
+     * this!
+     */
+    public boolean isInside(int x, int y) {
+        return x >= this.x && x < this.x + this.width && y >= this.y && y < this.y + this.height;
+    }
+
+    /**
+     * Check whether given point is inside the rect.
+     * Use {@link com.gregtechceu.gtceu.api.mui.base.widget.IWidget#isInside(IViewportStack, int, int)} rather than
+     * this!
+     */
+    public boolean isInside(Point point) {
+        return isInside(point.x, point.y);
+    }
+
+    /**
+     * Check whether given rect intersects this rect
+     */
+    public boolean intersects(Rectangle area) {
+        return this.x < area.getX() + area.getWidth() && this.y < area.getY() + area.getHeight() &&
+                area.getX() < this.x + this.width && area.getY() < this.y + this.height;
+    }
+
+    /**
+     * Clamp given area inside of this one
+     */
+    public void clamp(Area area) {
+        int x1 = area.x();
+        int y1 = area.y();
+        int x2 = area.ex();
+        int y2 = area.ey();
+
+        x1 = Mth.clamp(x1, this.x, this.ex());
+        y1 = Mth.clamp(y1, this.y, this.ey());
+        x2 = Mth.clamp(x2, this.x, this.ex());
+        y2 = Mth.clamp(y2, this.y, this.ey());
+
+        area.setPos(x1, y1, x2, y2);
+    }
+
+    /**
+     * Increases or decreases the size of this area. The position will change so that the center of the new
+     * area is in the same place.
+     * The size will change with double of the given value. The position will change with the negative of the given
+     * value.
+     * <br>
+     * In short, it will push or pull all four edges by the given amount.
+     *
+     * @param expand amount to expand area by (no restrictions)
+     */
+    public void expand(int expand) {
+        this.expandX(expand);
+        this.expandY(expand);
+    }
+
+    /**
+     * Increases or decreases the size of this area. The position will change so that the center of the new
+     * area is in the same place.
+     * The size will change with double of the given value. The position will change with the negative of the given
+     * value.
+     * <br>
+     * In short, it will push or pull all four edges by the given amount.
+     *
+     * @param expandX amount to expand x-axis by (no restrictions)
+     * @param expandY amount to expand y-axis by (no restrictions)
+     */
+    public void expand(int expandX, int expandY) {
+        this.expandX(expandX);
+        this.expandY(expandY);
+    }
+
+    /**
+     * Increases or decreases the width of this area. The x position will change so that the center of the new
+     * area is in the same place.
+     * The width will change with double of the given value. The x position will change with the negative of the given
+     * value.
+     * <br>
+     * In short, it will push or pull the left and right edges by the given amount.
+     *
+     * @param expand amount to expand x-axis by (no restrictions)
+     */
+    public void expandX(int expand) {
+        offsetX(-expand);
+        growW(expand * 2);
+    }
+
+    /**
+     * Increases or decreases the height of this area. The y position will change so that the center of the new
+     * area is in the same place.
+     * The height will change with double of the given value. The y position will change with the negative of the given
+     * value.
+     * <br>
+     * In short, it will push or pull the top and bottom edges by the given amount.
+     *
+     * @param expand amount to expand y-axis by (no restrictions)
+     */
+    public void expandY(int expand) {
+        offsetY(-expand);
+        growH(expand * 2);
+    }
+
+    /**
+     * Increases or decreases the position of the area by the given amount, but doesn't change its size.
+     *
+     * @param offset amount to change position by (no restrictions)
+     */
+    public void offset(int offset) {
+        offsetX(offset);
+        offsetY(offset);
+    }
+
+    /**
+     * Increases or decreases the position of the area by the given amount, but doesn't change its size.
+     *
+     * @param offsetX amount to change x position by (no restrictions)
+     * @param offsetY amount to change y position by (no restrictions)
+     */
+    public void offset(int offsetX, int offsetY) {
+        offsetX(offsetX);
+        offsetY(offsetY);
+    }
+
+    /**
+     * Increases or decreases the x position of the area by the given amount, but doesn't change its size.
+     *
+     * @param offset amount to change x position by (no restrictions)
+     */
+    public void offsetX(int offset) {
+        this.x += offset;
+    }
+
+    /**
+     * Increases or decreases the y position of the area by the given amount, but doesn't change its size.
+     *
+     * @param offset amount to change y position by (no restrictions)
+     */
+    public void offsetY(int offset) {
+        this.y += offset;
+    }
+
+    /**
+     * Increases or decreases the size of the area by the given amount, but doesn't change its position.
+     *
+     * @param grow amount to change size by (no restrictions)
+     */
+    public void grow(int grow) {
+        growW(grow);
+        growH(grow);
+    }
+
+    /**
+     * Increases or decreases the size of the area by the given amount, but doesn't change its position.
+     *
+     * @param growW amount to change width by (no restrictions)
+     * @param growH amount to change height by (no restrictions)
+     */
+    public void grow(int growW, int growH) {
+        growW(growW);
+        growH(growH);
+    }
+
+    /**
+     * Increases or decreases the width of the area by the given amount, but doesn't change its position.
+     *
+     * @param grow amount to change width by (no restrictions)
+     */
+    public void growW(int grow) {
+        this.width += grow;
+    }
+
+    /**
+     * Increases or decreases the height of the area by the given amount, but doesn't change its position.
+     *
+     * @param grow amount to change height by (no restrictions)
+     */
+    public void growH(int grow) {
+        this.height += grow;
+    }
+
+    /**
+     * Set all values
+     */
+    public void set(int x, int y, int w, int h) {
+        this.setPos(x, y);
+        this.setSize(w, h);
+    }
+
+    /**
+     * Set the relative position
+     */
+    public void setRelativePos(int rx, int ry) {
+        this.rx = rx;
+        this.ry = ry;
+    }
+
+    /**
+     * Set the position
+     */
+    public void setPos(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /**
+     * Set the size
+     */
+    public void setSize(int w, int h) {
+        this.width = w;
+        this.height = h;
+    }
+
+    public void setPos(Rectangle rectangle) {
+        setPos(rectangle.x, rectangle.y);
+    }
+
+    public void setSize(Rectangle rectangle) {
+        setSize(rectangle.width, rectangle.height);
+    }
+
+    /**
+     * Sets position and size by specifying top left and bottom right corner position.
+     *
+     * @param sx x position of top left corner
+     * @param sy y position of top left corner
+     * @param ex x position of bottom right corner
+     * @param ey y position of bottom right corner
+     */
+    public void setPos(int sx, int sy, int ex, int ey) {
+        int x0 = Math.min(sx, ex);
+        int y0 = Math.min(sy, ey);
+        ex = Math.max(sx, ex);
+        ey = Math.max(sy, ey);
+        setPos(x0, y0);
+        setSize(ex - x0, ey - y0);
+    }
+
+    public void reset() {
+        this.x = 0;
+        this.y = 0;
+        this.width = 0;
+        this.height = 0;
+    }
+
+    public void set(Rectangle area) {
+        setBounds(area.x, area.y, area.width, area.height);
+    }
+
+    /**
+     * Transforms the four corners of this rectangle with the given pose stack. The new rectangle can be rotated.
+     * Then a min fit rectangle, which is aligned with the screen axis, is put around the corners.
+     *
+     * @param stack pose stack
+     */
+    public void transformAndRectanglerize(IViewportStack stack) {
+        int xTL = stack.transformX(this.x, this.y), xTR = stack.transformX(ex(), this.y),
+                xBL = stack.transformX(this.x, ey()), xBR = stack.transformX(ex(), ey());
+        int yTL = stack.transformY(this.x, this.y), yTR = stack.transformY(ex(), this.y),
+                yBL = stack.transformY(this.x, ey()), yBR = stack.transformY(ex(), ey());
+        int x0 = GTMath.min(xTL, xTR, xBL, xBR);
+        int x1 = GTMath.max(xTL, xTR, xBL, xBR);
+        int y0 = GTMath.min(yTL, yTR, yBL, yBR);
+        int y1 = GTMath.max(yTL, yTR, yBL, yBR);
+        setPos(x0, y0, x1, y1);
+    }
+
+    /**
+     * This creates a copy with size, pos, margin padding and z layer.
+     *
+     * @return copy
+     */
+    public Area createCopy() {
+        return new Area(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Area{" +
+                "x=" + this.x +
+                ", y=" + this.y +
+                ", w=" + this.width +
+                ", h=" + this.height +
+                ", rx=" + this.rx +
+                ", ry=" + this.ry +
+                '}';
+    }
+
+    @Override
+    public Area interpolate(Area start, Area end, float t) {
+        this.x = Interpolations.lerp(start.x, end.x, t);
+        this.y = Interpolations.lerp(start.y, end.y, t);
+        this.width = Interpolations.lerp(start.width, end.width, t);
+        this.height = Interpolations.lerp(start.height, end.height, t);
+        this.rx = Interpolations.lerp(start.rx, end.rx, t);
+        this.ry = Interpolations.lerp(start.ry, end.ry, t);
+        getMargin().interpolate(start.getMargin(), end.getMargin(), t);
+        getPadding().interpolate(start.getPadding(), end.getPadding(), t);
+        return this;
+    }
+
+    @Override
+    public Area copyOrImmutable() {
+        return createCopy();
+    }
+
+    @Override
+    public boolean shouldAnimate(Area target) {
+        return x != target.x || y != target.y || width != target.width || height != target.height ||
+                rx != target.rx || ry != target.ry || !getMargin().isEqual(target.getMargin()) ||
+                !getPadding().isEqual(target.getPadding());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        if (!super.equals(o)) return false;
+        Area area = (Area) o;
+        return rx == area.rx && ry == area.ry && z == area.z &&
+                Objects.equals(getMargin(), area.getMargin()) &&
+                Objects.equals(getPadding(), area.getPadding());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), rx, ry, z, margin, padding);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/AreaResizer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/AreaResizer.java
new file mode 100644
index 00000000000..f11d4645566
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/AreaResizer.java
@@ -0,0 +1,25 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+public class AreaResizer extends StaticResizer {
+
+    private final Area area;
+
+    public AreaResizer(Area area) {
+        this.area = area;
+    }
+
+    @Override
+    public Area getArea() {
+        return area;
+    }
+
+    @Override
+    public String getDebugDisplayName() {
+        return "";
+    }
+
+    @Override
+    public String toString() {
+        return "AreaResizer(" + this.area + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Box.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Box.java
new file mode 100644
index 00000000000..798f66700d8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Box.java
@@ -0,0 +1,160 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.animation.IAnimatable;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonHelper;
+
+import com.google.gson.JsonObject;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.Objects;
+
+/**
+ * A box with four edges.
+ * Used for margins and paddings.
+ */
+@Accessors(fluent = true, chain = true)
+public class Box implements IAnimatable<Box> {
+
+    public static final Box SHARED = new Box();
+
+    public static final Box ZERO = new Box();
+
+    public static final Box ONE = new Box().all(1);
+
+    @Getter
+    @Setter
+    protected int left;
+    @Getter
+    @Setter
+    protected int top;
+    @Getter
+    @Setter
+    protected int right;
+    @Getter
+    @Setter
+    protected int bottom;
+
+    public Box all(int all) {
+        return this.all(all, all);
+    }
+
+    public Box all(int horizontal, int vertical) {
+        return this.all(horizontal, horizontal, vertical, vertical);
+    }
+
+    public Box all(int left, int right, int top, int bottom) {
+        this.left = left;
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        return this;
+    }
+
+    public Box set(Box box) {
+        return all(box.left, box.right, box.top, box.bottom);
+    }
+
+    public Box set(GuiAxis axis, boolean start, int val) {
+        if (axis.isVertical()) {
+            if (start) {
+                top(val);
+            } else {
+                bottom(val);
+            }
+        } else {
+            if (start) {
+                left(val);
+            } else {
+                right(val);
+            }
+        }
+        return this;
+    }
+
+    public int vertical() {
+        return this.top + this.bottom;
+    }
+
+    public int horizontal() {
+        return this.left + this.right;
+    }
+
+    public int getTotal(GuiAxis axis) {
+        return axis.isHorizontal() ? horizontal() : vertical();
+    }
+
+    public int getStart(GuiAxis axis) {
+        return axis.isHorizontal() ? this.left : this.top;
+    }
+
+    public int getEnd(GuiAxis axis) {
+        return axis.isHorizontal() ? this.right : this.bottom;
+    }
+
+    public void fromJson(JsonObject json) {
+        all(JsonHelper.getInt(json, 0, "margin"));
+        if (json.has("marginHorizontal")) {
+            this.left = json.get("marginHorizontal").getAsInt();
+            this.right = this.left;
+        }
+        if (json.has("marginVertical")) {
+            this.top = json.get("marginVertical").getAsInt();
+            this.bottom = this.top;
+        }
+        this.top = JsonHelper.getInt(json, this.top, "marginTop");
+        this.bottom = JsonHelper.getInt(json, this.bottom, "marginBottom");
+        this.left = JsonHelper.getInt(json, this.left, "marginLeft");
+        this.right = JsonHelper.getInt(json, this.right, "marginRight");
+    }
+
+    public void toJson(JsonObject json) {
+        json.addProperty("marginTop", this.top);
+        json.addProperty("marginBottom", this.bottom);
+        json.addProperty("marginLeft", this.left);
+        json.addProperty("marginRight", this.right);
+    }
+
+    @Override
+    public Box interpolate(Box start, Box end, float t) {
+        this.left = Interpolations.lerp(start.left, end.left, t);
+        this.top = Interpolations.lerp(start.top, end.top, t);
+        this.right = Interpolations.lerp(start.right, end.right, t);
+        this.bottom = Interpolations.lerp(start.bottom, end.bottom, t);
+        return this;
+    }
+
+    @Override
+    public Box copyOrImmutable() {
+        return new Box().set(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Box{" +
+                "left=" + left +
+                ", top=" + top +
+                ", right=" + right +
+                ", bottom=" + bottom +
+                '}';
+    }
+
+    public boolean isEqual(Box box) {
+        return left == box.left && top == box.top && right == box.right && bottom == box.bottom;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        return isEqual((Box) o);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(left, top, right, bottom);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/DelegatingResizer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/DelegatingResizer.java
new file mode 100644
index 00000000000..642bbe9311d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/DelegatingResizer.java
@@ -0,0 +1,10 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+public class DelegatingResizer extends StandardResizer {
+
+    public DelegatingResizer(IWidget widget) {
+        super(widget);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/DimensionSizer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/DimensionSizer.java
new file mode 100644
index 00000000000..c20158e784c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/DimensionSizer.java
@@ -0,0 +1,416 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.GuiError;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.IntSupplier;
+
+/**
+ * Handles calculating size and position in one dimension (x or y).
+ * Two of these can fully calculate a widget size and pos.
+ */
+@ApiStatus.Internal
+public class DimensionSizer {
+
+    private final ResizeNode resizer;
+    private final GuiAxis axis;
+
+    private final Unit p1 = new Unit(), p2 = new Unit();
+    private Unit start, end, size;
+    private Unit next = p1;
+
+    @Setter
+    private boolean coverChildren = false, expanded = false;
+    @Setter
+    private boolean cancelAutoMovement = false;
+
+    @Getter
+    private boolean posCalculated = false, sizeCalculated = false;
+    @Getter
+    @Setter
+    private boolean marginPaddingApplied = false;
+    private boolean canRelayout = false;
+
+    public DimensionSizer(ResizeNode resizer, GuiAxis axis) {
+        this.resizer = resizer;
+        this.axis = axis;
+    }
+
+    public void reset() {
+        this.p1.reset();
+        this.p2.reset();
+        this.start = null;
+        this.end = null;
+        this.size = null;
+        this.next = this.p1;
+    }
+
+    public void resetPosition() {
+        if (this.start != null) {
+            this.start.reset();
+            this.start = null;
+        }
+        if (this.end != null) {
+            this.end.reset();
+            this.end = null;
+        }
+        if (this.p1.isUnused()) {
+            this.next = this.p1;
+        } else if (this.p2.isUnused()) {
+            this.next = this.p2;
+        }
+    }
+
+    public void resetSize() {
+        if (this.size != null) {
+            this.size.reset();
+            this.size = null;
+        }
+        if (this.p1.isUnused()) {
+            this.next = this.p1;
+        } else if (this.p2.isUnused()) {
+            this.next = this.p2;
+        }
+    }
+
+    public void setCoverChildren(boolean coverChildren, IWidget widget) {
+        getSize(widget);
+        this.coverChildren = coverChildren;
+    }
+
+    public void setUnit(Unit unit, Unit.State pos) {
+        switch (pos) {
+            case START -> getStart(null).setFrom(unit);
+            case END -> getEnd(null).setFrom(unit);
+            case SIZE -> getSize(null).setFrom(unit);
+        }
+    }
+
+    public boolean hasStart() {
+        return this.start != null;
+    }
+
+    public boolean hasEnd() {
+        return this.end != null;
+    }
+
+    public boolean hasPos() {
+        return this.start != null || this.end != null;
+    }
+
+    public boolean hasFixedSize() {
+        return this.start == null || this.end == null;
+    }
+
+    public boolean hasSize() {
+        return this.size != null;
+    }
+
+    public boolean isFullSize() {
+        if (hasSize()) {
+            return this.size.isRelative() && this.size.getValue() >= 0.99f && this.size.getAbsOffset() < 5;
+        }
+        if (hasStart() && hasEnd()) {
+            return this.start.isCloseToZero() && this.end.isCloseToZero();
+        }
+        return false;
+    }
+
+    public boolean canRelayout() {
+        return this.canRelayout;
+    }
+
+    public boolean dependsOnChildren() {
+        return this.coverChildren;
+    }
+
+    public boolean dependsOnParent() {
+        if (this.coverChildren) {
+            // if we cover children we ignore size config
+            return this.end != null || (this.start != null && this.start.isRelative());
+        }
+        return this.end != null ||
+                (this.start != null && this.start.isRelative()) ||
+                (this.size != null && this.size.isRelative());
+    }
+
+    public void setResized(boolean all) {
+        setResized(all, all);
+    }
+
+    public void setResized(boolean pos, boolean size) {
+        this.posCalculated = pos;
+        this.sizeCalculated = size;
+        this.canRelayout &= !(pos && size);
+    }
+
+    private boolean needsSize(Unit unit) {
+        return unit.isRelative() && unit.getAnchor() != 0;
+    }
+
+    public void apply(Area area, ResizeNode relativeTo, IntSupplier defaultSize) {
+        boolean sizeCalculated = isSizeCalculated();
+        boolean posCalculated = isPosCalculated();
+        if (sizeCalculated && posCalculated) return;
+        int p, s;
+        int parentSize = relativeTo.getArea().getSize(this.axis);
+        boolean calcParent = relativeTo.isSizeCalculated(this.axis);
+        Box padding = relativeTo.getArea().getPadding();
+
+        if (sizeCalculated) { // pos not calculated
+            // size was calculated before
+            s = area.getSize(this.axis);
+            if (this.start != null) {
+                p = calcPoint(this.start, padding, s, parentSize, calcParent);
+            } else if (this.end != null) {
+                p = calcPoint(this.end, padding, s, parentSize, calcParent) - s;
+            } else {
+                p = 0;
+                this.posCalculated = true;
+            }
+        } else if (posCalculated) {
+            // pos was calculated before
+            p = area.getRelativePoint(this.axis);
+            if (this.size != null) {
+                s = calcSize(this.size, padding, parentSize, calcParent);
+            } else {
+                s = defaultSize.getAsInt();
+                this.sizeCalculated = s > 0;
+            }
+        } else { // pos and size not calculated
+            // calc start, end and size
+            if (this.start == null && this.end == null) {
+                p = 0;
+                if (this.size == null) {
+                    s = defaultSize.getAsInt();
+                    this.sizeCalculated = s > 0 && !this.expanded && !this.coverChildren;
+                } else {
+                    s = calcSize(this.size, padding, parentSize, calcParent);
+                }
+                this.posCalculated = true;
+                // children in layout widgets have no position, but if the size can only be calculated later than we
+                // need to tell the parent layout that this position is not final
+                this.canRelayout = true;
+            } else {
+                if (this.size == null) {
+                    if (this.start != null && this.end != null) {
+                        p = calcPoint(this.start, padding, -1, parentSize, calcParent);
+                        boolean b = this.posCalculated;
+                        this.posCalculated = false;
+                        int p2 = calcPoint(this.end, padding, -1, parentSize, calcParent);
+                        s = Math.abs(p2 - p);
+                        this.posCalculated &= b;
+                        this.sizeCalculated |= this.posCalculated;
+                    } else {
+                        s = defaultSize.getAsInt();
+                        this.sizeCalculated = s > 0 && !this.expanded;
+                        if (this.start == null) {
+                            p = calcPoint(this.end, padding, s, parentSize, calcParent);
+                            p -= s;
+                            this.posCalculated &= this.sizeCalculated;
+                        } else {
+                            p = calcPoint(this.start, padding, s, parentSize, calcParent);
+                            this.posCalculated &= (this.sizeCalculated || !needsSize(this.start));
+                        }
+                    }
+                } else if (this.start != null) {
+                    s = calcSize(this.size, padding, parentSize, calcParent);
+                    p = calcPoint(this.start, padding, s, parentSize, calcParent);
+                    this.posCalculated &= (this.sizeCalculated || !needsSize(this.start));
+                } else {
+                    s = calcSize(this.size, padding, parentSize, calcParent);
+                    p = calcPoint(this.end, padding, s, parentSize, calcParent) - s;
+                    this.posCalculated &= this.sizeCalculated;
+                }
+            }
+        }
+
+        // TODO find a better place to apply the margin, is it needed at all?
+        // apply padding and margin to size
+        if (this.sizeCalculated && calcParent && ((this.size != null && this.size.isRelative()) ||
+                (this.start != null && this.end != null && (this.start.isRelative() || this.end.isRelative())))) {
+            Box margin = area.getMargin();
+            // padding is applied in calcSize()
+            s = Math.min(s, parentSize /*- padding.getTotal(this.axis)*/ - margin.getTotal(this.axis));
+        }
+        area.setRelativePoint(this.axis, p);
+        area.setPoint(this.axis, p + relativeTo.getArea().getPoint(this.axis)); // temporary
+        area.setSize(this.axis, s);
+    }
+
+    public int postApply(Area area, Area relativeTo, int p0, int p1) {
+        // only called when the widget cover its children
+        int moveAmount = 0;
+        // calculate width and recalculate x based on the new width
+        int s = p1 - p0, p;
+        area.setSize(this.axis, s);
+        this.sizeCalculated = true;
+        if (!isPosCalculated()) {
+            if (this.start != null) {
+                p = calcPoint(this.start, relativeTo.getPadding(), s, relativeTo.getSize(this.axis), true);
+            } else if (this.end != null) {
+                p = calcPoint(this.end, relativeTo.getPadding(), s, relativeTo.getSize(this.axis), true) - s;
+            } else {
+                p = area.getRelativePoint(this.axis) + p0/* + area.getMargin().getStart(this.axis) */;
+                if (!this.cancelAutoMovement) {
+                    moveAmount = -p0;
+                }
+            }
+            area.setRelativePoint(this.axis, p);
+            this.posCalculated = true;
+        }
+        return moveAmount;
+    }
+
+    public void coverChildrenForEmpty(Area area, Area relativeTo) {
+        int s = 0;
+        area.setSize(this.axis, s);
+        this.sizeCalculated = true;
+        if (!isPosCalculated()) {
+            int p;
+            if (this.start != null) {
+                p = calcPoint(this.start, relativeTo.getPadding(), s, relativeTo.getSize(this.axis), true);
+            } else if (this.end != null) {
+                p = calcPoint(this.end, relativeTo.getPadding(), s, relativeTo.getSize(this.axis), true) - s;
+            } else {
+                p = area.getRelativePoint(this.axis);
+            }
+            area.setRelativePoint(this.axis, p);
+            this.posCalculated = true;
+        }
+    }
+
+    public void applyMarginAndPaddingToPos(IWidget parent, Area area, Area relativeTo) {
+        // apply self margin and parent padding if not done yet
+        if (isMarginPaddingApplied()) return;
+        setMarginPaddingApplied(true);
+        int start = area.getMargin().getStart(this.axis) + relativeTo.getPadding().getStart(this.axis);
+        int end = area.getMargin().getEnd(this.axis) + relativeTo.getPadding().getEnd(this.axis);
+        if (start > 0 && ((this.start != null && !this.start.isRelative()) ||
+                (this.end != null && !this.end.isRelative() && (this.size == null || !this.size.isRelative())))) {
+            start = 0;
+        }
+        if (end > 0 && ((this.end != null && !this.end.isRelative()) ||
+                (this.start != null && !this.start.isRelative() && (this.size == null || !this.size.isRelative())))) {
+            end = 0;
+        }
+        if (start == 0 && end == 0) return;
+        int parentS = relativeTo.getSize(this.axis);
+        int s = area.getSize(this.axis);
+        int rp = area.getRelativePoint(this.axis); // relative pos
+        if (start > 0) {
+            if (end > 0) {
+                if (start + end + s > parentS) {
+                    // widget and margin + padding is larger than available space
+                    area.setRelativePoint(this.axis, start);
+                    GuiError.throwNew(parent, GuiError.Type.SIZING,
+                            "Margin/padding is set on both sides on axis " + this.axis +
+                                    ", but total size exceeds parent size.");
+                    return;
+                }
+                if (end > parentS - s - rp) area.setRelativePoint(this.axis, parentS - end - s);
+                else if (start > rp) area.setRelativePoint(this.axis, start);
+                return;
+            }
+            if (start > rp) area.setRelativePoint(this.axis, start);
+        } else if (end > 0) {
+            if (end > parentS - s - rp) area.setRelativePoint(this.axis, parentS - end - s);
+        }
+    }
+
+    private int calcSize(Unit s, Box padding, int parentSize, boolean parentSizeCalculated) {
+        // placeholder value, size is calculated externally
+        if (this.coverChildren || this.expanded) return 18;
+        float val = s.getValue();
+        if (s.isRelative()) {
+            if (!parentSizeCalculated) return (int) val;
+            val *= parentSize - padding.getTotal(this.axis);
+        }
+        val += s.getOffset();
+        this.sizeCalculated = true;
+        return (int) val;
+    }
+
+    public int calcPoint(Unit p, Box padding, int width, int parentSize, boolean parentSizeCalculated) {
+        float val = p.getValue();
+        if (!parentSizeCalculated && (p == this.end || p.isRelative())) return (int) val;
+        if (p.isRelative()) {
+            val *= parentSize + padding.getTotal(this.axis);
+            float anchor = p.getAnchor();
+            if (width > 0 && anchor != 0) {
+                val -= width * anchor;
+            }
+        }
+        if (p == this.end) {
+            val = parentSize - val;
+        }
+        val += p.getOffset();
+        this.posCalculated = true;
+        return (int) val;
+    }
+
+    public void detectConflictingConfiguration() {
+        if (this.expanded && this.coverChildren) {
+            GTCEu.LOGGER.warn(
+                    "Resizer '{}' has expanded() and coverChildren() on {} axis. This conflicts and may cause layout issues.",
+                    this.resizer, this.axis);
+        }
+        // TODO detect when this depends and all siblings depend on parent and parent depends on all children
+    }
+
+    /**
+     * Tries to find a unit for start, end or size. If p1 and p2 are already used, the first one will be overwritten.
+     *
+     * @param widget   widget this sizer belongs to. Used for logging
+     * @param newState the new unit type for the found unit
+     * @return a used or unused unit.
+     */
+    private Unit getNext(IWidget widget, Unit.State newState) {
+        Unit ret = this.next;
+        Unit other = ret == this.p1 ? this.p2 : this.p1;
+        if (ret.state != Unit.State.UNUSED) {
+            if (ret.state == newState) return ret;
+            if (other.state == newState) return other;
+            if (ret == this.start) this.start = null;
+            if (ret == this.end) this.end = null;
+            if (ret == this.size) this.size = null;
+            if (ConfigHolder.INSTANCE.dev.debugUI && GTCEu.isClientThread()) {
+                // only log on client in debug mode since its sometimes intentional
+                GTCEu.LOGGER.info("unit {} of widget {} was already used and will be overwritten with unit {}",
+                        ret.state.getText(this.axis), widget, newState.getText(this.axis));
+            }
+        }
+        ret.reset();
+        ret.state = newState;
+        this.next = other;
+        return ret;
+    }
+
+    protected Unit getStart(IWidget widget) {
+        if (this.start == null) {
+            this.start = getNext(widget, Unit.State.START);
+        }
+        return this.start;
+    }
+
+    protected Unit getEnd(IWidget widget) {
+        if (this.end == null) {
+            this.end = getNext(widget, Unit.State.END);
+        }
+        return this.end;
+    }
+
+    protected Unit getSize(IWidget widget) {
+        if (this.size == null) {
+            this.size = getNext(widget, Unit.State.SIZE);
+        }
+        return this.size;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ExpanderResizer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ExpanderResizer.java
new file mode 100644
index 00000000000..e7ccf8a398c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ExpanderResizer.java
@@ -0,0 +1,20 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.IExpander;
+
+public class ExpanderResizer extends StandardResizer implements IExpander {
+
+    private final GuiAxis axis;
+
+    public ExpanderResizer(IWidget widget, GuiAxis axis) {
+        super(widget);
+        this.axis = axis;
+    }
+
+    @Override
+    public GuiAxis getExpandAxis() {
+        return axis;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ResizeNode.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ResizeNode.java
new file mode 100644
index 00000000000..6911d182393
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ResizeNode.java
@@ -0,0 +1,251 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.ITreeNode;
+import com.gregtechceu.gtceu.api.mui.base.layout.IResizeable;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class ResizeNode implements IResizeable, ITreeNode<ResizeNode> {
+
+    private ResizeNode defaultParent;
+    private ResizeNode parentOverride;
+    private final List<ResizeNode> children = new ArrayList<>();
+    private boolean defaultParentIsDelegating = false;
+    private boolean requiresResize = true;
+
+    @ApiStatus.Internal
+    @Override
+    public List<ResizeNode> getChildren() {
+        return children;
+    }
+
+    @Override
+    public ResizeNode getParent() {
+        return parentOverride != null ? parentOverride : defaultParent;
+    }
+
+    @ApiStatus.Internal
+    public void replacementOf(ResizeNode node) {
+        if (this == node) return;
+        // GTCEu.LOGGER.info("Replacing resizer node {} with node {}", node, this);
+        // remove this node from the tree by removing itself from the parents and removing the children
+        if (this.defaultParent != null) this.defaultParent.children.remove(this);
+        if (this.parentOverride != null) this.parentOverride.children.remove(this);
+        for (ResizeNode n : this.children) {
+            if (n.parentOverride == this) {
+                n.setParentOverride(null);
+            }
+            if (n.defaultParent == this) {
+                n.setDefaultParent(null);
+            }
+        }
+        this.children.clear();
+
+        // remove the node to replace from its tree and remember the exact position
+        int defI = -1;
+        int ovrI = -1;
+        if (node.defaultParent != null) {
+            defI = node.defaultParent.children.indexOf(node);
+            if (defI >= 0) node.defaultParent.children.remove(defI);
+        }
+        if (node.parentOverride != null) {
+            ovrI = node.parentOverride.children.indexOf(node);
+            if (ovrI >= 0) node.parentOverride.children.remove(ovrI);
+        }
+        // take over the parent and ourselves to the new parents with the remembered position
+        this.defaultParent = node.defaultParent;
+        this.parentOverride = node.parentOverride;
+        if (this.parentOverride != null) {
+            if (ovrI < 0) throw new IllegalStateException();
+            this.parentOverride.children.add(ovrI, this);
+        }
+        if (this.defaultParent != null) {
+            if (defI < 0) throw new IllegalStateException();
+            this.defaultParent.children.add(ovrI, this);
+        }
+        // take all children and update their parent to ourselves
+        this.children.addAll(node.children);
+        for (ResizeNode n : this.children) {
+            if (n.parentOverride == node) n.parentOverride = this;
+            if (n.defaultParent == node) n.defaultParent = this;
+        }
+        // finally invalidate replaced node
+        node.dispose();
+    }
+
+    public void dispose() {
+        if (getParent() != null) getParent().children.remove(this);
+        this.defaultParent = null;
+        this.parentOverride = null;
+        this.children.clear();
+    }
+
+    private boolean removeFromParent(ResizeNode parent, ResizeNode parent2, ResizeNode replacement) {
+        if (parent != null) {
+            if (parent == replacement) return true;
+            parent.children.remove(this);
+        } else if (parent2 != null) {
+            if (parent2 == replacement) return true;
+            parent2.children.remove(this);
+        }
+        return false;
+    }
+
+    @ApiStatus.Internal
+    public void initialize(ResizeNode defaultParent, ResizeNode root) {
+        setDefaultParent(defaultParent);
+    }
+
+    @ApiStatus.Internal
+    public void setDefaultParent(ResizeNode resizeNode) {
+        // GTCEu.LOGGER.info("Set default parent of {} to {}. Current: default: {}, override: {}", this, resizeNode,
+        // this.defaultParent, this.parentOverride);
+        if (resizeNode == this) throw new IllegalArgumentException("Tried to set itself as default parent in " + this);
+        if (removeFromParent(this.defaultParent, null, resizeNode)) return;
+        this.defaultParent = resizeNode;
+        if (this.parentOverride == null && resizeNode != null) {
+            resizeNode.children.add(this);
+        }
+    }
+
+    protected void setParentOverride(ResizeNode resizeNode) {
+        // GTCEu.LOGGER.info("Set override parent of {} to {}. Current: default: {}, override: {}", this, resizeNode,
+        // this.defaultParent, this.parentOverride);
+        if (resizeNode == this) throw new IllegalArgumentException("Tried to set itself as parent override in " + this);
+        if (removeFromParent(this.parentOverride, this.defaultParent, resizeNode)) return;
+        this.parentOverride = resizeNode;
+        if (this.parentOverride != null) {
+            this.parentOverride.children.add(this);
+        } else if (this.defaultParent != null) {
+            this.defaultParent.children.add(this);
+        }
+    }
+
+    @ApiStatus.Internal
+    public void setDefaultParentIsDelegating(boolean defaultParentIsDelegating) {
+        this.defaultParentIsDelegating = defaultParentIsDelegating;
+    }
+
+    public boolean hasParentOverride() {
+        return this.parentOverride != null;
+    }
+
+    @Override
+    public void initResizing(boolean onOpen) {
+        if (this.defaultParentIsDelegating && this.parentOverride != null) {
+            this.defaultParent.initResizing(onOpen);
+        }
+    }
+
+    public void reset() {}
+
+    public void markDirty() {
+        this.requiresResize = true;
+    }
+
+    public void onResized() {
+        this.requiresResize = false;
+        if (this.defaultParentIsDelegating && this.parentOverride != null) {
+            this.defaultParent.onResized();
+        }
+    }
+
+    public void postFullResize() {
+        if (this.defaultParentIsDelegating && this.parentOverride != null) {
+            this.defaultParent.postFullResize();
+        }
+    }
+
+    public boolean requiresResize() {
+        return this.requiresResize;
+    }
+
+    public boolean dependsOnParentX() {
+        return false;
+    }
+
+    public boolean dependsOnParentY() {
+        return false;
+    }
+
+    public boolean dependsOnParent() {
+        return dependsOnParentX() || dependsOnParentY();
+    }
+
+    public boolean dependsOnParent(GuiAxis axis) {
+        return axis.isHorizontal() ? dependsOnParentX() : dependsOnParentY();
+    }
+
+    public boolean dependsOnChildrenX() {
+        return false;
+    }
+
+    public boolean dependsOnChildrenY() {
+        return false;
+    }
+
+    public boolean dependsOnChildren() {
+        return dependsOnChildrenX() || dependsOnChildrenY();
+    }
+
+    public boolean dependsOnChildren(GuiAxis axis) {
+        return axis.isHorizontal() ? dependsOnChildrenX() : dependsOnChildrenY();
+    }
+
+    public boolean isSameResizer(ResizeNode node) {
+        return node == this;
+    }
+
+    public boolean isLayout() {
+        return false;
+    }
+
+    public boolean layoutChildren() {
+        return true;
+    }
+
+    public boolean postLayoutChildren() {
+        return true;
+    }
+
+    @ApiStatus.Internal
+    public void checkExpanded(@Nullable GuiAxis axis) {}
+
+    public abstract boolean hasYPos();
+
+    public abstract boolean hasXPos();
+
+    public abstract boolean hasHeight();
+
+    public abstract boolean hasWidth();
+
+    public abstract boolean hasStartPos(GuiAxis axis);
+
+    public abstract boolean hasEndPos(GuiAxis axis);
+
+    public boolean hasPos(GuiAxis axis) {
+        return axis.isHorizontal() ? hasXPos() : hasYPos();
+    }
+
+    public boolean hasSize(GuiAxis axis) {
+        return axis.isHorizontal() ? hasWidth() : hasHeight();
+    }
+
+    public boolean isExpanded() {
+        return false;
+    }
+
+    public abstract boolean isFullSize();
+
+    public abstract boolean hasFixedSize();
+
+    public abstract String getDebugDisplayName();
+
+    @Override
+    public abstract String toString();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ScreenResizeNode.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ScreenResizeNode.java
new file mode 100644
index 00000000000..e088ce99789
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/ScreenResizeNode.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+public class ScreenResizeNode extends StaticResizer {
+
+    private final ModularScreen screen;
+
+    public ScreenResizeNode(ModularScreen screen) {
+        this.screen = screen;
+    }
+
+    public ModularScreen getScreen() {
+        return screen;
+    }
+
+    @Override
+    public Area getArea() {
+        return screen.getScreenArea();
+    }
+
+    @Override
+    public String getDebugDisplayName() {
+        return "screen '" + this.screen + "'";
+    }
+
+    @Override
+    public String toString() {
+        return "ScreenResizeNode(" + this.screen + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/StandardResizer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/StandardResizer.java
new file mode 100644
index 00000000000..e62f9bb0e82
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/StandardResizer.java
@@ -0,0 +1,672 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.GuiError;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.layout.ILayoutWidget;
+import com.gregtechceu.gtceu.api.mui.base.layout.IResizeable;
+import com.gregtechceu.gtceu.api.mui.base.widget.*;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.IExpander;
+import com.gregtechceu.gtceu.core.mixins.client.SlotAccessor;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.DoubleSupplier;
+
+/**
+ * This class handles resizing and positioning of widgets.
+ */
+public class StandardResizer extends WidgetResizeNode implements IPositioned<StandardResizer> {
+
+    private final DimensionSizer x;
+    private final DimensionSizer y;
+    @Getter
+    private boolean expanded = false;
+
+    private boolean childrenResized = false;
+    private boolean layoutResized = false;
+    private boolean relativeToScreen = false;
+
+    public StandardResizer(IWidget widget) {
+        super(widget);
+        this.x = createDimensionSizer(GuiAxis.X);
+        this.y = createDimensionSizer(GuiAxis.Y);
+    }
+
+    protected DimensionSizer createDimensionSizer(GuiAxis axis) {
+        return new DimensionSizer(this, axis);
+    }
+
+    @Override
+    public void initialize(ResizeNode defaultParent, ResizeNode root) {
+        super.initialize(defaultParent, root);
+        if (this.relativeToScreen) {
+            setParentOverride(root);
+        }
+    }
+
+    @Override
+    public void initResizing(boolean onOpen) {
+        setMarginPaddingApplied(false);
+        setResized(false);
+        this.childrenResized = false;
+        this.layoutResized = false;
+        super.initResizing(onOpen);
+        if (onOpen) {
+            detectConflictingConfiguration();
+        }
+    }
+
+    @Override
+    public void reset() {
+        this.x.reset();
+        this.y.reset();
+    }
+
+    public void resetPosition() {
+        this.x.resetPosition();
+        this.y.resetPosition();
+    }
+
+    public void detectConflictingConfiguration() {
+        if (!GTCEu.isDev()) return;
+        if (this.expanded && !(getParent() instanceof IExpander)) {
+            GTCEu.LOGGER.warn("Resizer '{}' has expanded() but the parent is not a Flow!", this);
+        }
+        this.x.detectConflictingConfiguration();
+        this.y.detectConflictingConfiguration();
+    }
+
+    @Override
+    public boolean isXCalculated() {
+        return this.x.isPosCalculated();
+    }
+
+    @Override
+    public boolean isYCalculated() {
+        return this.y.isPosCalculated();
+    }
+
+    @Override
+    public boolean isWidthCalculated() {
+        return this.x.isSizeCalculated();
+    }
+
+    @Override
+    public boolean isHeightCalculated() {
+        return this.y.isSizeCalculated();
+    }
+
+    @Override
+    public boolean areChildrenCalculated() {
+        return this.childrenResized;
+    }
+
+    @Override
+    public boolean isLayoutDone() {
+        return this.layoutResized;
+    }
+
+    @Override
+    public boolean canRelayout(boolean isParentLayout) {
+        return isParentLayout && (this.x.canRelayout() || this.y.canRelayout());
+    }
+
+    @Override
+    public boolean isXMarginPaddingApplied() {
+        return this.x.isMarginPaddingApplied();
+    }
+
+    @Override
+    public boolean isYMarginPaddingApplied() {
+        return this.y.isMarginPaddingApplied();
+    }
+
+    @Override
+    public StandardResizer resizer() {
+        return this;
+    }
+
+    @Override
+    public void scheduleResize() {
+        markDirty();
+    }
+
+    @ApiStatus.Internal
+    @Override
+    public void checkExpanded(@Nullable GuiAxis axis) {
+        this.x.setExpanded(false);
+        this.y.setExpanded(false);
+        if (this.expanded && axis != null) {
+            if (axis.isHorizontal()) this.x.setExpanded(true);
+            else this.y.setExpanded(true);
+        }
+    }
+
+    @Override
+    public boolean resize(boolean isParentLayout) {
+        Area area = getArea();
+        ResizeNode relativeTo = getParent();
+        // calculate x, y, width and height if possible
+        this.x.apply(area, relativeTo, () -> getWidget().getDefaultWidth());
+        this.y.apply(area, relativeTo, () -> getWidget().getDefaultHeight());
+        return isSelfFullyCalculated(isParentLayout);
+    }
+
+    @Override
+    public boolean postResize() {
+        boolean coverWidth = this.x.dependsOnChildren();
+        boolean coverHeight = this.y.dependsOnChildren();
+        if (!coverWidth && !coverHeight) return isSelfFullyCalculated();
+        IWidget widget = getWidget();
+        if (!widget.hasChildren()) {
+            coverChildrenForEmpty();
+            return isSelfFullyCalculated();
+        }
+        if (getWidget() instanceof ILayoutWidget layout) {
+            // layout widgets handle widget layout's themselves, so we only need to fit the right and bottom border
+            coverChildrenForLayout(layout, widget);
+            return isSelfFullyCalculated();
+        }
+        // non layout widgets can have their children in any position
+        // we try to wrap all edges as close as possible to all widgets
+        // this means for each edge there is at least one widget that touches it (plus padding and margin)
+
+        // children are now calculated and now this area can be calculated if it requires children's area
+        List<IWidget> children = widget.getChildren(); // TODO cover resizer children instead?
+        int moveChildrenX = 0, moveChildrenY = 0;
+
+        Box padding = getWidget().getArea().getPadding();
+        // first calculate the area the children span
+        int x0 = Integer.MAX_VALUE, x1 = Integer.MIN_VALUE, y0 = Integer.MAX_VALUE, y1 = Integer.MIN_VALUE;
+        int w = 0, h = 0;
+        boolean hasIndependentChildX = false;
+        boolean hasIndependentChildY = false;
+        for (IWidget child : children) {
+            Box margin = child.getArea().getMargin();
+            ResizeNode resizeable = child.resizer();
+            Area area = child.getArea();
+            if (coverWidth) {
+                if (!resizeable.dependsOnParentX()) {
+                    hasIndependentChildX = true;
+                    if (resizeable.isWidthCalculated() && resizeable.isXCalculated()) {
+                        w = Math.max(w, area.requestedWidth() + padding.horizontal());
+                        x0 = Math.min(x0, area.rx - padding.left() - margin.left());
+                        x1 = Math.max(x1, area.rx + area.width + padding.right + margin.right);
+                    } else {
+                        return isSelfFullyCalculated();
+                    }
+                }
+            }
+            if (coverHeight) {
+                if (!resizeable.dependsOnParentY()) {
+                    hasIndependentChildY = true;
+                    if (resizeable.isHeightCalculated() && resizeable.isYCalculated()) {
+                        h = Math.max(h, area.requestedHeight() + padding.vertical());
+                        y0 = Math.min(y0, area.ry - padding.top() - margin.top());
+                        y1 = Math.max(y1, area.ry + area.height + padding.bottom + margin.bottom);
+                    } else {
+                        return isSelfFullyCalculated();
+                    }
+                }
+            }
+        }
+        if ((coverWidth && !hasIndependentChildX) || (coverHeight && !hasIndependentChildY)) {
+            GuiError.throwNew(getWidget(), GuiError.Type.SIZING,
+                    "Can't cover children when all children depend on their parent!");
+            return false;
+        }
+        if (x1 == Integer.MIN_VALUE) x1 = 0;
+        if (y1 == Integer.MIN_VALUE) y1 = 0;
+        if (x0 == Integer.MAX_VALUE) x0 = 0;
+        if (y0 == Integer.MAX_VALUE) y0 = 0;
+        if (w > x1 - x0) x1 = x0 + w; // we found at least one widget which was wider than what was calculated by start
+                                      // and end pos
+        if (h > y1 - y0) y1 = y0 + h;
+
+        // now calculate new x, y, width and height based on the children area
+        Area relativeTo = getParent().getArea();
+        if (coverWidth) {
+            // apply the size to this widget
+            // the return value is the amount of pixels we need to move the children
+            moveChildrenX = this.x.postApply(getWidget().getArea(), relativeTo, x0, x1);
+        }
+        if (coverHeight) {
+            moveChildrenY = this.y.postApply(getWidget().getArea(), relativeTo, y0, y1);
+        }
+        // since the edges might have been moved closer to the widgets, the widgets should move back into it's original
+        // (absolute) position
+        if (moveChildrenX != 0 || moveChildrenY != 0) {
+            for (IWidget child : children) {
+                Area area = child.getArea();
+                ResizeNode resizeable = child.resizer();
+                if (resizeable.isXCalculated()) area.rx += moveChildrenX;
+                if (resizeable.isYCalculated()) area.ry += moveChildrenY;
+            }
+        }
+        return isSelfFullyCalculated();
+    }
+
+    private void coverChildrenForLayout(ILayoutWidget layout, IWidget widget) {
+        List<IWidget> children = widget.getChildren();
+        Box padding = getWidget().getArea().getPadding();
+        // first calculate the area the children span
+        int x1 = Integer.MIN_VALUE, y1 = Integer.MIN_VALUE;
+        int w = 0, h = 0;
+        int withDefaultW = 0, withDefaultH = 0;
+        boolean coverWidth = this.x.dependsOnChildren();
+        boolean coverHeight = this.y.dependsOnChildren();
+        boolean hasIndependentChildX = false;
+        boolean hasIndependentChildY = false;
+        boolean coverByDefaultSizeX = coverWidth && layout.canCoverByDefaultSize(GuiAxis.X);
+        boolean coverByDefaultSizeY = coverHeight && layout.canCoverByDefaultSize(GuiAxis.Y);
+        for (IWidget child : children) {
+            if (layout.shouldIgnoreChildSize(child)) continue;
+            Area area = child.getArea();
+            Box margin = area.getMargin();
+            IResizeable resizeable = child.resizer();
+            if (coverWidth) {
+                if (!child.resizer().dependsOnParentX()) {
+                    hasIndependentChildX = true;
+                    if (resizeable.isWidthCalculated() && resizeable.isXCalculated()) {
+                        int s = area.requestedWidth() + padding.horizontal();
+                        w = Math.max(w, s);
+                        withDefaultW = Math.max(withDefaultW, s);
+                        x1 = Math.max(x1, area.rx + area.width + padding.right + margin.right);
+                    } else {
+                        return;
+                    }
+                } else if (coverByDefaultSizeX) {
+                    withDefaultW = Math.max(withDefaultW,
+                            child.getDefaultWidth() + margin.horizontal() + padding.horizontal());
+                }
+            }
+
+            if (coverHeight) {
+                if (!child.resizer().dependsOnParentY()) {
+                    hasIndependentChildY = true;
+                    if (resizeable.isHeightCalculated() && resizeable.isYCalculated()) {
+                        int s = area.requestedHeight() + padding.vertical();
+                        h = Math.max(h, s);
+                        withDefaultH = Math.max(withDefaultH, s);
+                        y1 = Math.max(y1, area.ry + area.height + padding.bottom + margin.bottom);
+                    } else {
+                        return;
+                    }
+                } else if (coverByDefaultSizeY) {
+                    withDefaultH = Math.max(withDefaultH,
+                            child.getDefaultHeight() + margin.vertical() + padding.vertical());
+                }
+            }
+        }
+        if ((coverWidth && !hasIndependentChildX && !coverByDefaultSizeX) ||
+                (coverHeight && !hasIndependentChildY && !coverByDefaultSizeY)) {
+            GuiError.throwNew(getWidget(), GuiError.Type.SIZING,
+                    "Can't cover children when all children depend on their parent!");
+            return;
+        }
+        if (w == 0) w = withDefaultW; // only use default sizes, if no size is defined
+        if (h == 0) h = withDefaultH;
+        if (x1 == Integer.MIN_VALUE) x1 = 0;
+        if (y1 == Integer.MIN_VALUE) y1 = 0;
+        if (w > x1) x1 = w;
+        if (h > y1) y1 = h;
+
+        Area relativeTo = getParent().getArea();
+        if (coverWidth) this.x.postApply(getArea(), relativeTo, 0, x1);
+        if (coverHeight) this.y.postApply(getArea(), relativeTo, 0, y1);
+    }
+
+    private void coverChildrenForEmpty() {
+        if (this.x.dependsOnChildren()) {
+            this.x.coverChildrenForEmpty(getWidget().getArea(), getParent().getArea());
+        }
+        if (this.y.dependsOnChildren()) {
+            this.y.coverChildrenForEmpty(getWidget().getArea(), getParent().getArea());
+        }
+    }
+
+    @Override
+    public void preApplyPos() {
+        IWidget widget = getWidget();
+        Area relativeTo = getParent().getArea();
+        Area area = widget.getArea();
+        // apply margin and padding if not done yet
+        this.x.applyMarginAndPaddingToPos(widget, area, relativeTo);
+        this.y.applyMarginAndPaddingToPos(widget, area, relativeTo);
+        // after all widgets x, y, width and height have been calculated we can now calculate the absolute position
+        area.applyPos(relativeTo.x, relativeTo.y);
+    }
+
+    @Override
+    public void applyPos() {
+        IWidget widget = getWidget();
+        if (widget instanceof IDelegatingWidget dw && dw.getDelegate() != null) {
+            super.postFullResize();
+            return;
+        }
+        Area area = widget.getArea();
+        // update rx and ry to be relative to the widget parent not the resize node parent
+        Area parentArea = widget.getParentArea();
+        area.rx = area.x - parentArea.x;
+        area.ry = area.y - parentArea.y;
+        if (widget instanceof IVanillaSlot vanillaSlot && vanillaSlot.handleAsVanillaSlot()) {
+            // special treatment for minecraft slots
+            SlotAccessor slot = (SlotAccessor) vanillaSlot.getVanillaSlot();
+            Area mainArea = widget.getScreen().getMainPanel().getArea();
+            // in vanilla uis the position is relative to the gui area and size is 16 x 16
+            // since our slots are 18 x 18 we need to offset by 1
+            slot.gtceu$setX(widget.getArea().x - mainArea.x + 1);
+            slot.gtceu$setY(widget.getArea().y - mainArea.y + 1);
+        }
+    }
+
+    @Override
+    public void setChildrenResized(boolean resized) {
+        this.childrenResized = resized;
+    }
+
+    @Override
+    public void setLayoutDone(boolean done) {
+        this.layoutResized = done;
+    }
+
+    @Override
+    public void setXAxisResized(boolean pos, boolean size) {
+        this.x.setResized(pos, size);
+    }
+
+    @Override
+    public void setYAxisResized(boolean pos, boolean size) {
+        this.y.setResized(pos, size);
+    }
+
+    @Override
+    public void setXMarginPaddingApplied(boolean b) {
+        this.x.setMarginPaddingApplied(b);
+    }
+
+    @Override
+    public void setYMarginPaddingApplied(boolean b) {
+        this.y.setMarginPaddingApplied(b);
+    }
+
+    @Override
+    public boolean hasYPos() {
+        return this.y.hasPos();
+    }
+
+    @Override
+    public boolean hasXPos() {
+        return this.x.hasPos();
+    }
+
+    @Override
+    public boolean hasHeight() {
+        return this.y.hasSize();
+    }
+
+    @Override
+    public boolean hasWidth() {
+        return this.x.hasSize();
+    }
+
+    @Override
+    public boolean hasStartPos(GuiAxis axis) {
+        return axis.isHorizontal() ? this.x.hasStart() : this.y.hasStart();
+    }
+
+    @Override
+    public boolean hasEndPos(GuiAxis axis) {
+        return axis.isHorizontal() ? this.x.hasEnd() : this.y.hasEnd();
+    }
+
+    @Override
+    public boolean dependsOnParentX() {
+        return this.x.dependsOnParent();
+    }
+
+    @Override
+    public boolean dependsOnParentY() {
+        return this.y.dependsOnParent();
+    }
+
+    @Override
+    public boolean dependsOnChildrenX() {
+        return this.x.dependsOnChildren();
+    }
+
+    @Override
+    public boolean dependsOnChildrenY() {
+        return this.y.dependsOnChildren();
+    }
+
+    public StandardResizer expanded() {
+        this.expanded = true;
+        scheduleResize();
+        return this;
+    }
+
+    @Override
+    public boolean hasFixedSize() {
+        return this.x.hasFixedSize() && this.y.hasFixedSize();
+    }
+
+    @Override
+    public boolean isFullSize() {
+        if (!hasHeight() || !hasWidth()) return false;
+        return this.x.isFullSize() && this.y.isFullSize();
+    }
+
+    @Override
+    public StandardResizer relative(ResizeNode resizeNode) {
+        setParentOverride(resizeNode);
+        this.relativeToScreen = false;
+        return this;
+    }
+
+    @Override
+    public StandardResizer relativeToParent() {
+        setParentOverride(null);
+        this.relativeToScreen = false;
+        return this;
+    }
+
+    @Override
+    public StandardResizer relativeToScreen() {
+        this.relativeToScreen = true;
+        return this;
+    }
+
+    @Override
+    public StandardResizer coverChildren() {
+        this.x.setCoverChildren(true, getWidget());
+        this.y.setCoverChildren(true, getWidget());
+        return this;
+    }
+
+    @Override
+    public StandardResizer coverChildrenWidth() {
+        this.x.setCoverChildren(true, getWidget());
+        return this;
+    }
+
+    @Override
+    public StandardResizer coverChildrenHeight() {
+        this.y.setCoverChildren(true, getWidget());
+        return this;
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer left(float x, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getLeft(), x, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer left(DoubleSupplier x, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getLeft(), x, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer right(float x, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getRight(), x, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer right(DoubleSupplier x, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getRight(), x, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer top(float y, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getTop(), y, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer top(DoubleSupplier y, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getTop(), y, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer bottom(float y, int offset, float anchor, Unit.Measure measure, boolean autoAnchor) {
+        return unit(getBottom(), y, offset, anchor, measure, autoAnchor);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer bottom(DoubleSupplier y, int offset, float anchor, Unit.Measure measure,
+                                  boolean autoAnchor) {
+        return unit(getBottom(), y, offset, anchor, measure, autoAnchor);
+    }
+
+    private StandardResizer unit(Unit u, float val, int offset, float anchor, Unit.Measure measure,
+                                 boolean autoAnchor) {
+        u.setValue(val);
+        u.setMeasure(measure);
+        u.setOffset(offset);
+        u.setAnchor(anchor);
+        u.setAutoAnchor(autoAnchor);
+        scheduleResize();
+        return this;
+    }
+
+    private StandardResizer unit(Unit u, DoubleSupplier val, int offset, float anchor, Unit.Measure measure,
+                                 boolean autoAnchor) {
+        u.setValue(val);
+        u.setMeasure(measure);
+        u.setOffset(offset);
+        u.setAnchor(anchor);
+        u.setAutoAnchor(autoAnchor);
+        scheduleResize();
+        return this;
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer width(float val, int offset, Unit.Measure measure) {
+        return unitSize(getWidth(), val, offset, measure);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer width(DoubleSupplier val, int offset, Unit.Measure measure) {
+        return unitSize(getWidth(), val, offset, measure);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer height(float val, int offset, Unit.Measure measure) {
+        return unitSize(getHeight(), val, offset, measure);
+    }
+
+    @ApiStatus.Internal
+    public StandardResizer height(DoubleSupplier val, int offset, Unit.Measure measure) {
+        return unitSize(getHeight(), val, offset, measure);
+    }
+
+    private StandardResizer unitSize(Unit u, float val, int offset, Unit.Measure measure) {
+        u.setValue(val);
+        u.setMeasure(measure);
+        u.setOffset(offset);
+        scheduleResize();
+        return this;
+    }
+
+    private StandardResizer unitSize(Unit u, DoubleSupplier val, int offset, Unit.Measure measure) {
+        u.setValue(val);
+        u.setMeasure(measure);
+        u.setOffset(offset);
+        scheduleResize();
+        return this;
+    }
+
+    public StandardResizer anchorLeft(float val) {
+        getLeft().setAnchor(val);
+        getLeft().setAutoAnchor(false);
+        scheduleResize();
+        return this;
+    }
+
+    public StandardResizer anchorRight(float val) {
+        getRight().setAnchor(1 - val);
+        getRight().setAutoAnchor(false);
+        scheduleResize();
+        return this;
+    }
+
+    public StandardResizer anchorTop(float val) {
+        getTop().setAnchor(val);
+        getTop().setAutoAnchor(false);
+        scheduleResize();
+        return this;
+    }
+
+    public StandardResizer anchorBottom(float val) {
+        getBottom().setAnchor(1 - val);
+        getBottom().setAutoAnchor(false);
+        scheduleResize();
+        return this;
+    }
+
+    public StandardResizer anchor(Alignment alignment) {
+        if (this.x.hasStart() || !this.x.hasEnd()) {
+            anchorLeft(alignment.x);
+        } else if (this.x.hasEnd()) {
+            anchorRight(alignment.x);
+        }
+        if (this.y.hasStart() || !this.y.hasEnd()) {
+            anchorTop(alignment.y);
+        } else if (this.y.hasEnd()) {
+            anchorBottom(alignment.y);
+        }
+        return this;
+    }
+
+    public void setUnit(Unit unit, GuiAxis axis, Unit.State pos) {
+        (axis.isHorizontal() ? this.x : this.y).setUnit(unit, pos);
+    }
+
+    private Unit getLeft() {
+        return this.x.getStart(getWidget());
+    }
+
+    private Unit getRight() {
+        return this.x.getEnd(getWidget());
+    }
+
+    private Unit getTop() {
+        return this.y.getStart(getWidget());
+    }
+
+    private Unit getBottom() {
+        return this.y.getEnd(getWidget());
+    }
+
+    private Unit getWidth() {
+        return this.x.getSize(getWidget());
+    }
+
+    private Unit getHeight() {
+        return this.y.getSize(getWidget());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/StaticResizer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/StaticResizer.java
new file mode 100644
index 00000000000..66b0aeea9a4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/StaticResizer.java
@@ -0,0 +1,131 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+public abstract class StaticResizer extends ResizeNode {
+
+    private boolean childrenCalculated = false;
+
+    public StaticResizer() {}
+
+    @Override
+    public void initResizing(boolean onOpen) {
+        super.initResizing(onOpen);
+        setChildrenResized(false);
+    }
+
+    @Override
+    public boolean isXCalculated() {
+        return true;
+    }
+
+    @Override
+    public boolean isYCalculated() {
+        return true;
+    }
+
+    @Override
+    public boolean isWidthCalculated() {
+        return true;
+    }
+
+    @Override
+    public boolean isHeightCalculated() {
+        return true;
+    }
+
+    @Override
+    public boolean areChildrenCalculated() {
+        return this.childrenCalculated;
+    }
+
+    @Override
+    public boolean isLayoutDone() {
+        return true;
+    }
+
+    @Override
+    public boolean canRelayout(boolean isParentLayout) {
+        return false;
+    }
+
+    @Override
+    public boolean isXMarginPaddingApplied() {
+        return true;
+    }
+
+    @Override
+    public boolean isYMarginPaddingApplied() {
+        return true;
+    }
+
+    @Override
+    public boolean resize(boolean isParentLayout) {
+        return true;
+    }
+
+    @Override
+    public boolean postResize() {
+        return true;
+    }
+
+    @Override
+    public void setChildrenResized(boolean resized) {
+        this.childrenCalculated = resized;
+    }
+
+    @Override
+    public void setLayoutDone(boolean done) {}
+
+    @Override
+    public void setXAxisResized(boolean pos, boolean size) {}
+
+    @Override
+    public void setYAxisResized(boolean pos, boolean size) {}
+
+    @Override
+    public void setXMarginPaddingApplied(boolean b) {}
+
+    @Override
+    public void setYMarginPaddingApplied(boolean b) {}
+
+    @Override
+    public boolean hasYPos() {
+        return true;
+    }
+
+    @Override
+    public boolean hasXPos() {
+        return true;
+    }
+
+    @Override
+    public boolean hasHeight() {
+        return true;
+    }
+
+    @Override
+    public boolean hasWidth() {
+        return true;
+    }
+
+    @Override
+    public boolean hasStartPos(GuiAxis axis) {
+        return true;
+    }
+
+    @Override
+    public boolean hasEndPos(GuiAxis axis) {
+        return false;
+    }
+
+    @Override
+    public boolean hasFixedSize() {
+        return true;
+    }
+
+    @Override
+    public boolean isFullSize() {
+        return false;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Unit.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Unit.java
new file mode 100644
index 00000000000..bcf07ade4f7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/Unit.java
@@ -0,0 +1,111 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.DoubleSupplier;
+
+@ApiStatus.Internal
+public class Unit {
+
+    public enum State {
+
+        UNUSED("", ""),
+        START("LEFT", "TOP"),
+        END("RIGHT", "BOTTOM"),
+        SIZE("WIDTH", "HEIGHT");
+
+        public final String xText, yText;
+
+        State(String xText, String yText) {
+            this.xText = xText;
+            this.yText = yText;
+        }
+
+        public String getText(GuiAxis axis) {
+            return axis.isHorizontal() ? this.xText : this.yText;
+        }
+    }
+
+    @Getter
+    @Setter
+    private boolean autoAnchor = true;
+    private float value = 0f;
+    private DoubleSupplier valueSupplier = null;
+    @Getter
+    @Setter
+    private Measure measure = Measure.PIXEL;
+    @Setter
+    private float anchor = 0f;
+    @Getter
+    @Setter
+    private int offset = 0;
+
+    public State state = State.UNUSED;
+
+    public Unit() {}
+
+    public void reset() {
+        this.state = State.UNUSED;
+        this.autoAnchor = true;
+        this.value = 0f;
+        this.valueSupplier = null;
+        this.measure = Measure.PIXEL;
+        this.anchor = 0f;
+        this.offset = 0;
+    }
+
+    public void setFrom(Unit other) {
+        this.autoAnchor = other.autoAnchor;
+        this.value = other.value;
+        this.valueSupplier = other.valueSupplier;
+        this.measure = other.measure;
+        this.anchor = other.anchor;
+        this.offset = other.offset;
+    }
+
+    public void setValue(float value) {
+        this.value = value;
+        this.valueSupplier = null;
+    }
+
+    public void setValue(DoubleSupplier valueSupplier) {
+        this.valueSupplier = valueSupplier;
+    }
+
+    public float getValue() {
+        return this.valueSupplier == null ? this.value : (float) this.valueSupplier.getAsDouble();
+    }
+
+    public int getAbsOffset() {
+        return Math.abs(this.offset);
+    }
+
+    public boolean isCloseToZero() {
+        if (isRelative()) {
+            return Math.abs(getValue()) < -0.01 && Math.abs(getValue()) < 5;
+        }
+        return Math.abs(getValue() + getOffset()) < 5;
+    }
+
+    public float getAnchor() {
+        float val = getValue();
+        return isAutoAnchor() && isRelative() && val < 1 ? val : this.anchor;
+    }
+
+    public boolean isRelative() {
+        return this.measure == Measure.RELATIVE;
+    }
+
+    public boolean isUnused() {
+        return this.state == State.UNUSED;
+    }
+
+    public enum Measure {
+        PIXEL,
+        RELATIVE
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/WidgetResizeNode.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/WidgetResizeNode.java
new file mode 100644
index 00000000000..77d86e26a1a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/sizer/WidgetResizeNode.java
@@ -0,0 +1,73 @@
+package com.gregtechceu.gtceu.api.mui.widget.sizer;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.ILayoutWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+import java.util.Objects;
+
+public abstract class WidgetResizeNode extends ResizeNode {
+
+    private final IWidget widget;
+
+    protected WidgetResizeNode(IWidget widget) {
+        this.widget = Objects.requireNonNull(widget);
+    }
+
+    public IWidget getWidget() {
+        return widget;
+    }
+
+    @Override
+    public Area getArea() {
+        return widget.getArea();
+    }
+
+    @Override
+    public void initResizing(boolean onOpen) {
+        super.initResizing(onOpen);
+        this.widget.beforeResize(onOpen);
+    }
+
+    @Override
+    public void onResized() {
+        super.onResized();
+        this.widget.onResized();
+    }
+
+    @Override
+    public void postFullResize() {
+        super.postFullResize();
+        this.widget.postResize();
+    }
+
+    @Override
+    public boolean isLayout() {
+        return this.widget instanceof ILayoutWidget;
+    }
+
+    @Override
+    public boolean layoutChildren() {
+        if (this.widget instanceof ILayoutWidget layoutWidget) {
+            return layoutWidget.layoutWidgets();
+        }
+        return true;
+    }
+
+    @Override
+    public boolean postLayoutChildren() {
+        if (this.widget instanceof ILayoutWidget layoutWidget) {
+            return layoutWidget.postLayoutWidgets();
+        }
+        return true;
+    }
+
+    @Override
+    public String getDebugDisplayName() {
+        return "widget '" + this.widget + "' of screen '" + this.widget.getScreen() + "'";
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(" + this.widget + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widget/wrapper/WidgetWrapper.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/wrapper/WidgetWrapper.java
new file mode 100644
index 00000000000..545c19a4100
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widget/wrapper/WidgetWrapper.java
@@ -0,0 +1,127 @@
+package com.gregtechceu.gtceu.api.mui.widget.wrapper;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IFocusedWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.TabOrderedElement;
+import net.minecraft.client.gui.narration.NarratableEntry;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@OnlyIn(Dist.CLIENT)
+public class WidgetWrapper extends AbstractWidget {
+
+    private NarratableEntry lastNarratable = null;
+
+    private final IWidget wrapped;
+    private final List<WidgetWrapper> children = new ArrayList<>();
+    private final ModularScreen screen;
+
+    public WidgetWrapper(IWidget wrapped) {
+        super(0, 0, 0, 0, CommonComponents.EMPTY);
+        this.wrapped = wrapped;
+        this.screen = wrapped.getScreen();
+        for (IWidget widget : this.wrapped.getChildren()) {
+            this.children.add(new WidgetWrapper(widget));
+        }
+    }
+
+    public int getX() {
+        return this.wrapped.getArea().getX();
+    }
+
+    public void setX(int x) {
+        this.wrapped.getArea().setX(x);
+    }
+
+    public int getY() {
+        return this.wrapped.getArea().getY();
+    }
+
+    public void setY(int y) {
+        this.wrapped.getArea().setY(y);
+    }
+
+    @Override
+    public void visitWidgets(@NotNull Consumer<AbstractWidget> consumer) {
+        if (this.wrapped instanceof EmptyWidget) return;
+        if (!this.children.isEmpty()) {
+            for (WidgetWrapper child : this.children) {
+                child.visitWidgets(consumer);
+            }
+        } else {
+            super.visitWidgets(consumer);
+        }
+    }
+
+    @Override
+    protected void renderWidget(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+        ModularGuiContext context = this.screen.getContext();
+        GuiGraphics lastGraphics = context.getGraphics();
+        context.setGraphics(graphics);
+
+        this.wrapped.draw(context, this.wrapped.getWidgetTheme(context.getTheme()));
+
+        context.setGraphics(lastGraphics);
+    }
+
+    @Override
+    protected void updateWidgetNarration(@NotNull NarrationElementOutput output) {
+        output.add(NarratedElementType.TITLE, Component.translatable(this.wrapped.getTranslationId()));
+        if (!this.wrapped.isEnabled()) return;
+        if (this.children.isEmpty()) {
+            if (this.wrapped instanceof IFocusedWidget focusable && focusable.isFocused()) {
+                output.add(NarratedElementType.USAGE, Component.translatable("narration.button.usage.focused"));
+            } else if (this.wrapped.isHovering()) {
+                output.add(NarratedElementType.USAGE, Component.translatable("narration.button.usage.hovered"));
+            }
+            return;
+        }
+
+        Stream<WidgetWrapper> entries = this.children.stream();
+        updateNarrations(this.children.stream(), output, lastNarratable, entry -> lastNarratable = entry);
+    }
+
+    public static <T extends NarratableEntry> void updateNarrations(Stream<T> unsorted, NarrationElementOutput output,
+                                                                    NarratableEntry lastNarratable,
+                                                                    Consumer<NarratableEntry> setter) {
+        List<NarratableEntry> entries = unsorted.filter(NarratableEntry::isActive)
+                .sorted(Comparator.comparingInt(TabOrderedElement::getTabOrderGroup))
+                .collect(Collectors.toList());
+        Screen.NarratableSearchResult result = Screen.findNarratableWidget(entries, lastNarratable);
+        if (result != null) {
+            if (result.priority.isTerminal()) {
+                setter.accept(result.entry);
+            }
+
+            if (entries.size() > 1) {
+                output.add(NarratedElementType.POSITION,
+                        Component.translatable("narrator.position.screen", result.index + 1, entries.size()));
+                if (result.priority == NarrationPriority.FOCUSED) {
+                    output.add(NarratedElementType.USAGE, Component.translatable("narration.component_list.usage"));
+                }
+            }
+
+            result.entry.updateNarration(output.nest());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/AbstractCycleButtonWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/AbstractCycleButtonWidget.java
new file mode 100644
index 00000000000..f82c5e75d54
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/AbstractCycleButtonWidget.java
@@ -0,0 +1,619 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.api.mui.base.value.*;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.IntValue;
+import com.gregtechceu.gtceu.api.mui.widget.SingleChildWidget;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+public class AbstractCycleButtonWidget<W extends AbstractCycleButtonWidget<W>> extends SingleChildWidget<W>
+                                      implements Interactable {
+
+    private static final RichTooltip[] EMPTY_TOOLTIP = new RichTooltip[0];
+
+    private int stateCount = 1;
+    private boolean explicitStateCount = false;
+    private boolean hasCount = false;
+    private IIntValue<?> intValue;
+    private int lastValue = -1;
+    protected IDrawable[] background = null;
+    protected IDrawable[] hoverBackground = null;
+    protected IDrawable[] overlay = null;
+    protected IDrawable[] hoverOverlay = null;
+    protected RichTooltip[] tooltip = EMPTY_TOOLTIP;
+    protected IWidget[] stateChildren = null;
+    protected IWidget fallbackChild = null;
+
+    @Override
+    public void onInit() {
+        if (this.intValue == null) {
+            this.intValue = new IntValue(0);
+        }
+        updateChild(getState());
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(IIntValue.class);
+    }
+
+    protected void updateStateCount(int count, boolean explicit) {
+        if (count < 1) return;
+        if (explicit) {
+            setStateCount(count);
+            this.explicitStateCount = true;
+        } else if (!this.explicitStateCount && count > this.stateCount) {
+            setStateCount(count);
+        }
+    }
+
+    private void setStateCount(int stateCount) {
+        this.hasCount = true;
+        if (this.stateCount == stateCount) return;
+        this.stateCount = stateCount;
+
+        int currentSize = this.tooltip.length;
+        if (stateCount > currentSize) {
+            this.tooltip = Arrays.copyOf(this.tooltip, stateCount);
+            for (; currentSize < stateCount; currentSize++) {
+                this.tooltip[currentSize] = new RichTooltip().parent(this);
+            }
+        } else if (stateCount < currentSize) {
+            for (int i = stateCount; i < currentSize; i++) {
+                this.tooltip[i].reset();
+            }
+        }
+
+        this.background = checkArray(this.background, stateCount);
+        this.overlay = checkArray(this.overlay, stateCount);
+        this.hoverBackground = checkArray(this.hoverBackground, stateCount);
+        this.hoverOverlay = checkArray(this.hoverOverlay, stateCount);
+        if (this.stateChildren == null) this.stateChildren = new IWidget[stateCount];
+        else if (this.stateChildren.length < stateCount)
+            this.stateChildren = Arrays.copyOf(this.stateChildren, stateCount);
+    }
+
+    protected void expectCount() {
+        if (!this.hasCount) {
+            GTCEu.LOGGER.error("State count for widget {} is required, but has not been set yet!", this);
+        }
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.intValue = syncOrValue.castNullable(IIntValue.class);
+        if (syncOrValue instanceof IEnumValue<?> enumValue) {
+            updateStateCount(enumValue.getEnumClass().getEnumConstants().length, true);
+        } else if (syncOrValue instanceof IBoolValue) {
+            updateStateCount(2, true);
+        }
+    }
+
+    protected int getState() {
+        int val = this.intValue.getIntValue();
+        if (val != this.lastValue) {
+            setState(val, false);
+        }
+        return val;
+    }
+
+    public void next() {
+        int state = (getState() + 1) % this.stateCount;
+
+        setState(state, true);
+    }
+
+    public void prev() {
+        int state = getState();
+        if (--state == -1) {
+            state = this.stateCount - 1;
+        }
+        setState(state, true);
+    }
+
+    public void setState(int state, boolean setSource) {
+        if (state < 0 || state >= this.stateCount) {
+            throw new IndexOutOfBoundsException("CycleButton state out of bounds");
+        }
+        updateChild(state);
+        if (setSource) {
+            this.intValue.setIntValue(state);
+        }
+        this.lastValue = state;
+        markTooltipDirty();
+    }
+
+    private void updateChild(int state) {
+        IWidget child = this.stateChildren != null && this.stateChildren.length > state ? this.stateChildren[state] :
+                null;
+        if (child != null) {
+            child(child);
+        } else if (getChild() != this.fallbackChild) {
+            child(this.fallbackChild);
+        }
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        switch (button) {
+            case 0:
+                next();
+                Interactable.playButtonClickSound();
+                return Result.SUCCESS;
+            case 1:
+                prev();
+                Interactable.playButtonClickSound();
+                return Result.SUCCESS;
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getButtonTheme();
+    }
+
+    @Override
+    public IDrawable getCurrentBackground(ITheme theme, WidgetThemeEntry<?> widgetTheme) {
+        // make sure texture is up-to-date
+        int state = getState();
+        if (isHovering() && this.hoverBackground != null && this.hoverBackground[state] != null &&
+                this.hoverBackground[state] != IDrawable.NONE) {
+            return this.hoverBackground[state];
+        }
+        return this.background != null && this.background[state] != null ? this.background[state] :
+                super.getCurrentBackground(theme, widgetTheme);
+    }
+
+    @Override
+    public IDrawable getCurrentOverlay(ITheme theme, WidgetThemeEntry<?> widgetTheme) {
+        int state = getState();
+        if (isHovering() && this.hoverOverlay != null && this.hoverOverlay[state] != null &&
+                this.hoverOverlay[state] != IDrawable.NONE) {
+            return this.hoverOverlay[state];
+        }
+        return this.overlay != null && this.overlay[state] != null ? this.overlay[state] :
+                super.getCurrentOverlay(theme, widgetTheme);
+    }
+
+    @Override
+    public boolean hasTooltip() {
+        int state = getState();
+        return super.hasTooltip() || (this.tooltip.length > state && !this.tooltip[state].isEmpty());
+    }
+
+    @Override
+    public void markTooltipDirty() {
+        super.markTooltipDirty();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.markDirty();
+        }
+        getState();
+    }
+
+    @Override
+    public @Nullable RichTooltip getTooltip() {
+        RichTooltip tooltip = super.getTooltip();
+        if (tooltip == null || tooltip.isEmpty()) {
+            int state = getState();
+            if (this.tooltip.length > 0 && this.tooltip.length > state) {
+                return this.tooltip[state];
+            }
+        }
+        return tooltip;
+    }
+
+    @Override
+    public W disableHoverBackground() {
+        expectCount();
+        if (this.hoverBackground != null) {
+            Arrays.fill(this.hoverBackground, IDrawable.NONE);
+        }
+        if (getHoverBackground() == null) {
+            super.hoverBackground(IDrawable.NONE);
+        }
+        return getThis();
+    }
+
+    @Override
+    public W disableHoverOverlay() {
+        expectCount();
+        if (this.hoverOverlay != null) {
+            Arrays.fill(this.hoverOverlay, IDrawable.NONE);
+        }
+        if (getHoverOverlay() == null) {
+            super.hoverOverlay(IDrawable.NONE);
+        }
+        return getThis();
+    }
+
+    @Override
+    public W invisible() {
+        if (this.background != null) {
+            Arrays.fill(this.background, IDrawable.EMPTY);
+        }
+        if (getBackground() == null) {
+            super.background(IDrawable.EMPTY);
+        }
+        return disableHoverBackground();
+    }
+
+    protected W value(IIntValue<?> value) {
+        setSyncOrValue(ISyncOrValue.orEmpty(value));
+        return getThis();
+    }
+
+    @Override
+    public W child(IWidget child) {
+        this.fallbackChild = child;
+        return super.child(child);
+    }
+
+    public W stateChild(int state, IWidget child) {
+        updateStateCount(state, false);
+        if (this.stateChildren == null) {
+            this.stateChildren = new IWidget[state + 1];
+        } else if (this.stateChildren.length < state + 1) {
+            this.stateChildren = Arrays.copyOf(this.stateChildren, state + 1);
+        }
+        this.stateChildren[state] = child;
+        return getThis();
+    }
+
+    /**
+     * Sets the state dependent background. The images should be vertically stacked images from top to bottom
+     * Note: The length must be already set!
+     *
+     * @param texture background
+     * @return this
+     */
+    public W stateBackground(UITexture texture) {
+        expectCount();
+        splitTexture(texture, this.background);
+        return getThis();
+    }
+
+    /**
+     * Sets the state dependent overlay. The images should be vertically stacked images from top to bottom
+     * Note: The length must be already set!
+     *
+     * @param texture background
+     * @return this
+     */
+    public W stateOverlay(UITexture texture) {
+        expectCount();
+        splitTexture(texture, this.overlay);
+        return getThis();
+    }
+
+    /**
+     * Sets the state dependent hover background. The images should be vertically stacked images from top to bottom
+     * Note: The length must be already set!
+     *
+     * @param texture background
+     * @return this
+     */
+    public W stateHoverBackground(UITexture texture) {
+        expectCount();
+        splitTexture(texture, this.hoverBackground);
+        return getThis();
+    }
+
+    /**
+     * Sets the state dependent hover overlay. The images should be vertically stacked images from top to bottom
+     * Note: The length must be already set!
+     *
+     * @param texture background
+     * @return this
+     */
+    public W stateHoverOverlay(UITexture texture) {
+        expectCount();
+        splitTexture(texture, this.hoverOverlay);
+        return getThis();
+    }
+
+    /**
+     * Adds a line to the tooltip
+     */
+    protected W addTooltip(int state, IDrawable tooltip) {
+        updateStateCount(state + 1, false);
+        this.tooltip[state].addLine(tooltip);
+        return getThis();
+    }
+
+    /**
+     * Adds a line to the tooltip
+     */
+    protected W addTooltip(int state, String tooltip) {
+        return addTooltip(state, IKey.str(tooltip));
+    }
+
+    /**
+     * Adds a tooltip element to all states.
+     *
+     * @param s element
+     * @return this
+     */
+    @Override
+    public W addTooltipElement(String s) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.add(s);
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds tooltip drawables as lines to all states.
+     *
+     * @param lines drawables
+     * @return this
+     */
+    @Override
+    public W addTooltipDrawableLines(Iterable<IDrawable> lines) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.addDrawableLines(lines);
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds a tooltip element to all states.
+     *
+     * @param drawable element
+     * @return this
+     */
+    @Override
+    public W addTooltipElement(IDrawable drawable) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.add(drawable);
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds a tooltip line to all states.
+     *
+     * @param line tooltip line
+     * @return this
+     */
+    @Override
+    public W addTooltipLine(ITextLine line) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.addLine(line);
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds a tooltip line to all states.
+     *
+     * @param drawable tooltip line
+     * @return this
+     */
+    @Override
+    public W addTooltipLine(IDrawable drawable) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.addLine(drawable);
+        }
+        return getThis();
+    }
+
+    /**
+     * Adds tooltip lines to all states.
+     *
+     * @param lines tooltip lines
+     * @return this
+     */
+    @Override
+    public W addTooltipStringLines(Iterable<String> lines) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.addStringLines(lines);
+        }
+        return getThis();
+    }
+
+    /**
+     * Applies a function to the tooltip of all states once.
+     *
+     * @param tooltipConsumer tooltip function
+     * @return this
+     */
+    @Override
+    public W tooltipStatic(Consumer<RichTooltip> tooltipConsumer) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltipConsumer.accept(tooltip);
+        }
+        return getThis();
+    }
+
+    /**
+     * Applies a function to the tooltip of all states every time the tooltip needs to update.
+     *
+     * @param tooltipBuilder tooltip function
+     * @return this
+     */
+    @Override
+    public W tooltipDynamic(Consumer<RichTooltip> tooltipBuilder) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.tooltipBuilder(tooltipBuilder);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip alignment of all states.
+     *
+     * @param alignment alignment
+     * @return this
+     */
+    @Override
+    public W tooltipAlignment(Alignment alignment) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.alignment(alignment);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip position of all states.
+     *
+     * @param pos tooltip pos
+     * @return this
+     */
+    @Override
+    public W tooltipPos(RichTooltip.Pos pos) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.pos(pos);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip position of all states.
+     *
+     * @param x x
+     * @param y y
+     * @return this
+     */
+    @Override
+    public W tooltipPos(int x, int y) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.pos(x, y);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip scale of all states.
+     *
+     * @param scale tooltip scale
+     * @return this
+     */
+    @Override
+    public W tooltipScale(float scale) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.scale(scale);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip text color of all states.
+     *
+     * @param textColor tooltip text color
+     * @return this
+     */
+    @Override
+    public W tooltipTextColor(int textColor) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.textColor(textColor);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip text shadow of all states.
+     *
+     * @param textShadow tooltip pos
+     * @return this
+     */
+    @Override
+    public W tooltipTextShadow(boolean textShadow) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.textShadow(textShadow);
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the tooltip show up timer of all states.
+     *
+     * @param showUpTimer tooltip show up timer
+     * @return this
+     */
+    @Override
+    public W tooltipShowUpTimer(int showUpTimer) {
+        expectCount();
+        for (RichTooltip tooltip : this.tooltip) {
+            tooltip.showUpTimer(showUpTimer);
+        }
+        return getThis();
+    }
+
+    protected W stateCount(int stateCount) {
+        updateStateCount(stateCount, true);
+        return getThis();
+    }
+
+    private static IDrawable[] checkArray(IDrawable[] array, int length) {
+        if (array == null) return new IDrawable[length];
+        return array.length < length ? Arrays.copyOf(array, length) : array;
+    }
+
+    protected IDrawable[] addToArray(IDrawable[] array, IDrawable[] drawable, int index) {
+        return addToArray(array, IDrawable.of(drawable), index);
+    }
+
+    protected IDrawable[] addToArray(IDrawable[] array, IDrawable drawable, int index) {
+        if (index < 0) throw new IndexOutOfBoundsException();
+        updateStateCount(index + 1, false);
+        if (array == null || index >= array.length) {
+            IDrawable[] copy = new IDrawable[(int) (Math.ceil((index + 1) / 4.0) * 4)];
+            if (array != null) {
+                System.arraycopy(array, 0, copy, 0, array.length);
+            }
+            array = copy;
+        }
+        array[index] = drawable;
+        return array;
+    }
+
+    protected static void splitTexture(UITexture texture, IDrawable[] dest) {
+        for (int i = 0; i < dest.length; i++) {
+            float a = 1f / dest.length;
+            dest[i] = texture.getSubArea(0, i * a, 1, i * a + a);
+        }
+    }
+
+    protected W tooltip(int index, Consumer<RichTooltip> builder) {
+        updateStateCount(index + 1, false);
+        builder.accept(this.tooltip[index]);
+        return getThis();
+    }
+
+    protected W tooltipBuilder(int index, Consumer<RichTooltip> builder) {
+        updateStateCount(index + 1, false);
+        this.tooltip[index].tooltipBuilder(builder);
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/AbstractFluidDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/AbstractFluidDisplayWidget.java
new file mode 100644
index 00000000000..6a6b5aefef1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/AbstractFluidDisplayWidget.java
@@ -0,0 +1,165 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
+import com.gregtechceu.gtceu.utils.GTMath;
+import com.gregtechceu.gtceu.utils.math.SIPrefix;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class AbstractFluidDisplayWidget<W extends AbstractFluidDisplayWidget<W>> extends Widget<W>
+                                                implements IngredientProvider<FluidStack> {
+
+    public static final String UNIT_BUCKET = "B";
+    public static final String UNIT_LITER = "L";
+
+    private final Box contentPadding = new Box().all(1);
+    private String unit = UNIT_BUCKET;
+    private SIPrefix baseUnitPrefix = SIPrefix.Milli;
+    @Getter
+    private boolean flipLighterThanAir = true;
+
+    protected AbstractFluidDisplayWidget() {
+        size(18);
+    }
+
+    @Override
+    protected WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getFluidSlotTheme();
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        FluidStack fluid = getFluidStack();
+        if (fluid == null) return;
+        int x = this.contentPadding.left();
+        int y = this.contentPadding.top();
+        int w = getArea().width - this.contentPadding.horizontal();
+        int h = getArea().height - this.contentPadding.vertical();
+        float c = getCapacity();
+        if (c > 0 && fluid.getAmount() > 0) {
+            int newH = (int) GTMath.rescaleLinear(fluid.getAmount(), 0, c, 1, h);
+            if (!this.flipLighterThanAir || !fluid.getFluid().getFluidType().isLighterThanAir()) y += h - newH;
+            h = newH;
+        }
+        GuiDraw.drawFluidTexture(context.getGraphics(), fluid, x, y, w, h, context.getCurrentDrawingZ());
+    }
+
+    @Override
+    public void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        super.drawOverlay(context, widgetTheme);
+        FluidStack fluid = getFluidStack();
+        if (fluid != null && displayAmountText()) {
+            String s = FormattingUtil.formatNumberReadable2F(getBaseUnitAmount(fluid.getAmount()), false) +
+                    getBaseUnit();
+            // mc doesn't consider the 1px border in item slots for amount text, but it looks weird when it touches the
+            // left border, so
+            // we only apply padding there
+            GuiDraw.drawScaledAlignedTextInBox(context, s, this.contentPadding.left(), 0,
+                    getArea().width - this.contentPadding.left(), getArea().height, Alignment.BottomRight);
+        }
+    }
+
+    protected abstract boolean displayAmountText();
+
+    @Nullable
+    protected abstract FluidStack getFluidStack();
+
+    /**
+     * Return a positive value if the fluid should be drawn partly depending on the amount filled.
+     *
+     * @return capacity in milli buckets or zero/negative if fluid should always be drawn full
+     */
+    protected int getCapacity() {
+        return 0;
+    }
+
+    public double getBaseUnitAmount(double amount) {
+        return amount * getBaseUnitSiPrefix().factor;
+    }
+
+    public final String getUnit() {
+        return getBaseUnitSiPrefix().stringSymbol + getBaseUnit();
+    }
+
+    public String getBaseUnit() {
+        return this.unit;
+    }
+
+    public SIPrefix getBaseUnitSiPrefix() {
+        return this.baseUnitPrefix;
+    }
+
+    public W contentPadding(int left, int right, int top, int bottom) {
+        this.contentPadding.all(left, right, top, bottom);
+        return getThis();
+    }
+
+    public W contentPadding(int horizontal, int vertical) {
+        this.contentPadding.all(horizontal, vertical);
+        return getThis();
+    }
+
+    public W contentPadding(int all) {
+        this.contentPadding.all(all);
+        return getThis();
+    }
+
+    public W contentPaddingLeft(int val) {
+        this.contentPadding.left(val);
+        return getThis();
+    }
+
+    public W contentPaddingRight(int val) {
+        this.contentPadding.right(val);
+        return getThis();
+    }
+
+    public W contentPaddingTop(int val) {
+        this.contentPadding.top(val);
+        return getThis();
+    }
+
+    public W contentPaddingBottom(int val) {
+        this.contentPadding.bottom(val);
+        return getThis();
+    }
+
+    public W fluidUnit(String baseUnitSymbol, SIPrefix baseUnitPrefix) {
+        this.unit = baseUnitSymbol;
+        this.baseUnitPrefix = baseUnitPrefix;
+        return getThis();
+    }
+
+    /**
+     * Determines if a partially filled fluid should be drawn from the top instead of the bottom if the current fluid is
+     * lighter than air.
+     * When the full fluid is drawn (when {@link #getCapacity()} returns 0) this does nothing.
+     */
+    public W flipLighterThanAir(boolean flipLighterThanAir) {
+        this.flipLighterThanAir = flipLighterThanAir;
+        return getThis();
+    }
+
+    @Override
+    public @NotNull Class<FluidStack> ingredientClass() {
+        return FluidStack.class;
+    }
+
+    public EntryList<FluidStack> getIngredients() {
+        return FluidStackList.of(getFluidStack());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ButtonWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ButtonWidget.java
new file mode 100644
index 00000000000..6544e65447f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ButtonWidget.java
@@ -0,0 +1,186 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IGuiAction;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.value.sync.InteractionSyncHandler;
+import com.gregtechceu.gtceu.api.mui.widget.SingleChildWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import org.jetbrains.annotations.NotNull;
+
+public class ButtonWidget<W extends ButtonWidget<W>> extends SingleChildWidget<W> implements Interactable {
+
+    public static ButtonWidget<?> panelCloseButton() {
+        ButtonWidget<?> buttonWidget = new ButtonWidget<>();
+        return buttonWidget.widgetTheme(IThemeApi.CLOSE_BUTTON)
+                .top(4).right(4)
+                .overlay(GTGuiTextures.CROSS_TINY)
+                .onMousePressed((mouseX, mouseY, button) -> {
+                    if (button == 0 || button == 1) {
+                        buttonWidget.getPanel().closeIfOpen();
+                        return true;
+                    }
+                    return false;
+                });
+    }
+
+    private boolean playClickSound = true;
+    private Runnable clickSound;
+    private IGuiAction.MousePressed mousePressed;
+    private IGuiAction.MouseReleased mouseReleased;
+    private IGuiAction.MousePressed mouseTapped;
+    private IGuiAction.MouseScroll mouseScroll;
+    private IGuiAction.KeyPressed keyPressed;
+    private IGuiAction.KeyReleased keyReleased;
+    private IGuiAction.KeyPressed keyTapped;
+
+    private InteractionSyncHandler syncHandler;
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getButtonTheme();
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(InteractionSyncHandler.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.syncHandler = syncOrValue.castNullable(InteractionSyncHandler.class);
+    }
+
+    public void playClickSound() {
+        if (this.playClickSound) {
+            if (this.clickSound != null) {
+                this.clickSound.run();
+            } else {
+                Interactable.playButtonClickSound();
+            }
+        }
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        if (this.mousePressed != null && this.mousePressed.press(mouseX, mouseY, button)) {
+            playClickSound();
+            return Result.SUCCESS;
+        }
+        if (this.syncHandler != null && this.syncHandler.onMousePressed(button)) {
+            playClickSound();
+            return Result.SUCCESS;
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        return (this.mouseReleased != null && this.mouseReleased.release(mouseX, mouseY, button)) ||
+                (this.syncHandler != null && this.syncHandler.onMouseReleased(button));
+    }
+
+    @NotNull
+    @Override
+    public Result onMouseTapped(double mouseX, double mouseY, int button) {
+        if (this.mouseTapped != null && this.mouseTapped.press(mouseX, mouseY, button)) {
+            playClickSound();
+            return Result.SUCCESS;
+        }
+        if (this.syncHandler != null && this.syncHandler.onMouseTapped(button)) {
+            playClickSound();
+            return Result.SUCCESS;
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public @NotNull Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        if (this.keyPressed != null && this.keyPressed.press(keyCode, scanCode, modifiers)) {
+            return Result.SUCCESS;
+        }
+        if (this.syncHandler != null && this.syncHandler.onKeyPressed(keyCode, scanCode, modifiers)) {
+            return Result.SUCCESS;
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        return (this.keyReleased != null && this.keyReleased.release(keyCode, scanCode, modifiers)) ||
+                (this.syncHandler != null && this.syncHandler.onKeyReleased(keyCode, scanCode, modifiers));
+    }
+
+    @NotNull
+    @Override
+    public Result onKeyTapped(int keyCode, int scanCode, int modifiers) {
+        if (this.keyTapped != null && this.keyTapped.press(keyCode, scanCode, modifiers)) {
+            return Result.SUCCESS;
+        }
+        if (this.syncHandler != null && this.syncHandler.onKeyTapped(keyCode, scanCode, modifiers)) {
+            return Result.SUCCESS;
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        return (this.mouseScroll != null && this.mouseScroll.scroll(mouseX, mouseY, delta)) ||
+                (this.syncHandler != null && this.syncHandler.onMouseScroll((int) delta));
+    }
+
+    public W onMousePressed(IGuiAction.MousePressed mousePressed) {
+        this.mousePressed = mousePressed;
+        return getThis();
+    }
+
+    public W onMouseReleased(IGuiAction.MouseReleased mouseReleased) {
+        this.mouseReleased = mouseReleased;
+        return getThis();
+    }
+
+    public W onMouseTapped(IGuiAction.MousePressed mouseTapped) {
+        this.mouseTapped = mouseTapped;
+        return getThis();
+    }
+
+    public W onMouseScrolled(IGuiAction.MouseScroll mouseScroll) {
+        this.mouseScroll = mouseScroll;
+        return getThis();
+    }
+
+    public W onKeyPressed(IGuiAction.KeyPressed keyPressed) {
+        this.keyPressed = keyPressed;
+        return getThis();
+    }
+
+    public W onKeyReleased(IGuiAction.KeyReleased keyReleased) {
+        this.keyReleased = keyReleased;
+        return getThis();
+    }
+
+    public W onKeyTapped(IGuiAction.KeyPressed keyTapped) {
+        this.keyTapped = keyTapped;
+        return getThis();
+    }
+
+    public W syncHandler(InteractionSyncHandler interactionSyncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(interactionSyncHandler));
+        return getThis();
+    }
+
+    public W playClickSound(boolean play) {
+        this.playClickSound = play;
+        return getThis();
+    }
+
+    public W clickSound(Runnable clickSound) {
+        this.clickSound = clickSound;
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/CategoryList.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/CategoryList.java
new file mode 100644
index 00000000000..a025fe60546
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/CategoryList.java
@@ -0,0 +1,173 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.layout.ILayoutWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.AbstractParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CategoryList extends AbstractParentWidget<IWidget, CategoryList> implements Interactable, ILayoutWidget {
+
+    private final List<CategoryList> subCategories = new ArrayList<>();
+    private boolean expanded = false;
+    private int totalHeight = 0;
+    private IDrawable expandedOverlay;
+    private IDrawable collapsedOverlay;
+
+    @Override
+    public void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        super.drawOverlay(context, widgetTheme);
+        if (this.expanded) {
+            this.expandedOverlay.drawAtZeroPadded(context, getArea(), getActiveWidgetTheme(widgetTheme, isHovering()));
+        } else {
+            this.collapsedOverlay.drawAtZeroPadded(context, getArea(), getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        if (this.expandedOverlay == null) {
+            if (getParent() instanceof CategoryList categoryList) {
+                this.expandedOverlay = categoryList.expandedOverlay;
+            } else if (getParent() instanceof Root root) {
+                this.expandedOverlay = root.expandedOverlay;
+            } else {
+                this.expandedOverlay = IDrawable.EMPTY;
+            }
+        }
+        if (this.collapsedOverlay == null) {
+            if (getParent() instanceof CategoryList categoryList) {
+                this.collapsedOverlay = categoryList.collapsedOverlay;
+            } else if (getParent() instanceof Root root) {
+                this.collapsedOverlay = root.collapsedOverlay;
+            } else {
+                this.collapsedOverlay = IDrawable.EMPTY;
+            }
+        }
+    }
+
+    @Override
+    public void onChildAdd(IWidget child) {
+        if (child instanceof CategoryList categoryList) {
+            this.subCategories.add(categoryList);
+        }
+        child.setEnabled(this.expanded);
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        if (button == 0 || button == 1) {
+            expanded(!this.expanded);
+            return Result.SUCCESS;
+        }
+        return Result.ACCEPT;
+    }
+
+    public void expanded(boolean expanded) {
+        if (expanded == this.expanded) return;
+        this.expanded = expanded;
+        for (IWidget widget : getChildren()) {
+            widget.setEnabled(expanded);
+        }
+        calculateHeightAndLayout(true);
+    }
+
+    public boolean calculateHeightAndLayout(boolean calculateParents) {
+        if (this.expanded) {
+            int y = getArea().height;
+            for (IWidget widget : getChildren()) {
+                widget.getArea().ry = y;
+                widget.resizer().setYResized(true);
+                if (!widget.resizer().isHeightCalculated()) return false;
+                y += widget instanceof CategoryList categoryList && categoryList.expanded ?
+                        categoryList.totalHeight : widget.getArea().height;
+            }
+            this.totalHeight = y;
+        } else {
+            this.totalHeight = getArea().height;
+        }
+
+        if (calculateParents) {
+            if (getParent() instanceof CategoryList categoryList) {
+                categoryList.calculateHeightAndLayout(true);
+            } else if (getParent() instanceof Root root) {
+                root.updateHeight();
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean layoutWidgets() {
+        return calculateHeightAndLayout(false);
+    }
+
+    public CategoryList setCollapsedOverlay(IDrawable collapsedOverlay) {
+        this.collapsedOverlay = collapsedOverlay;
+        return this;
+    }
+
+    public CategoryList setExpandedOverlay(IDrawable expandedOverlay) {
+        this.expandedOverlay = expandedOverlay;
+        return this;
+    }
+
+    public static class Root extends ListWidget<IWidget, Root> {
+
+        private final List<CategoryList> categories = new ArrayList<>();
+
+        private IDrawable expandedOverlay = GTGuiTextures.MOVE_DOWN.asIcon().size(16, 8)
+                .alignment(Alignment.CenterRight)
+                .marginRight(4);
+        private IDrawable collapsedOverlay = GTGuiTextures.MOVE_RIGHT.asIcon().size(8, 16)
+                .alignment(Alignment.CenterRight).marginRight(8);
+
+        @Override
+        public void onChildAdd(IWidget child) {
+            if (child instanceof CategoryList categoryList) {
+                this.categories.add(categoryList);
+            }
+        }
+
+        private void updateHeight() {
+            layoutWidgets();
+            WidgetTree.preApplyPos(resizer());
+            WidgetTree.applyPos(resizer());
+        }
+
+        @Override
+        public boolean layoutWidgets() {
+            int y = 0;
+            for (IWidget widget : getChildren()) {
+                widget.getArea().ry = y;
+                widget.resizer().setYResized(true);
+                if (!widget.resizer().isHeightCalculated()) return false;
+                y += widget instanceof CategoryList categoryList && categoryList.expanded ?
+                        categoryList.totalHeight : widget.getArea().height;
+            }
+            getScrollArea().getScrollY().setScrollSize(y);
+            return true;
+        }
+
+        public Root setCollapsedOverlay(IDrawable collapsedOverlay) {
+            this.collapsedOverlay = collapsedOverlay;
+            return this;
+        }
+
+        public Root setExpandedOverlay(IDrawable expandedOverlay) {
+            this.expandedOverlay = expandedOverlay;
+            return this;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ColorPickerDialog.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ColorPickerDialog.java
new file mode 100644
index 00000000000..19dc012ddd3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ColorPickerDialog.java
@@ -0,0 +1,277 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.HueBar;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.DoubleValue;
+import com.gregtechceu.gtceu.api.mui.value.StringValue;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import java.util.function.Consumer;
+
+public class ColorPickerDialog extends Dialog<Integer> {
+
+    private static final IDrawable handleBackground = new Rectangle().color(Color.WHITE.main);
+
+    private int color;
+    private int red;
+    private int green;
+    private int blue;
+    private double hue;
+    private double saturation;
+    private double value;
+
+    private int alpha;
+    private final boolean controlAlpha;
+
+    private final Rectangle preview = new Rectangle();
+    private final Rectangle sliderBackgroundR = new Rectangle();
+    private final Rectangle sliderBackgroundG = new Rectangle();
+    private final Rectangle sliderBackgroundB = new Rectangle();
+    private final Rectangle sliderBackgroundA = new Rectangle();
+    private final Rectangle sliderBackgroundS = new Rectangle();
+    private final Rectangle sliderBackgroundV = new Rectangle();
+
+    public ColorPickerDialog(Consumer<Integer> resultConsumer, int startColor, boolean controlAlpha) {
+        this("color_picker", resultConsumer, startColor, controlAlpha);
+    }
+
+    public ColorPickerDialog(String name, Consumer<Integer> resultConsumer, int startColor, boolean controlAlpha) {
+        super(name, resultConsumer);
+
+        this.controlAlpha = controlAlpha;
+        this.alpha = Color.getAlpha(startColor);
+        updateAll(startColor);
+        size(140, controlAlpha ? 106 : 94).background(GTGuiTextures.BACKGROUND);
+
+        PagedWidget.Controller controller = new PagedWidget.Controller();
+        child(new Column()
+                .left(5).right(5).top(5).bottom(5)
+                .child(new Row()
+                        .left(5).right(5).height(14)
+                        .child(new PageButton(0, controller)
+                                .sizeRel(0.5f, 1f)
+                                .overlay(IKey.str("RGB")))
+                        .child(new PageButton(1, controller)
+                                .sizeRel(0.5f, 1f)
+                                .overlay(IKey.str("HSV"))))
+                .child(new Row().widthRel(1f).height(12).marginTop(4)
+                        .child(IKey.str("Hex: ").asWidget().heightRel(1f))
+                        .child(new TextFieldWidget()
+                                .height(12)
+                                .expanded()
+                                .setValidator(this::validateRawColor)
+                                .value(new StringValue.Dynamic(() -> {
+                                    if (controlAlpha) {
+                                        return "#" + Color.toFullHexString(this.red, this.green, this.blue, this.alpha);
+                                    }
+                                    return "#" + Color.toFullHexString(this.red, this.green, this.blue);
+                                }, val -> {
+                                    try {
+                                        updateAll((int) (long) Long.decode(val));
+                                    } catch (NumberFormatException ignored) {
+                                        GTCEu.LOGGER.error("Illegal color string '{}'", val);
+                                    }
+                                })))
+                        .child(this.preview.asWidget().background(GTGuiTextures.CHECKBOARD).size(10, 10).margin(1)))
+                .child(new PagedWidget<>()
+                        .left(5).right(5)
+                        .expanded()
+                        .controller(controller)
+                        .addPage(createRGBPage(createAlphaSlider("rgb")))
+                        .addPage(createHSVPage(createAlphaSlider("hsv"))))
+                .child(new Row()
+                        .left(10).right(10).height(14)
+                        .mainAxisAlignment(Alignment.MainAxis.SPACE_BETWEEN)
+                        .child(new ButtonWidget<>()
+                                .heightRel(1f).width(50)
+                                .overlay(IKey.str("Cancel"))
+                                .onMousePressed((mouseX, mouseY, button) -> {
+                                    closeIfOpen();
+                                    return true;
+                                }))
+                        .child(new ButtonWidget<>()
+                                .heightRel(1f).width(50)
+                                .overlay(IKey.str("Confirm"))
+                                .onMousePressed((mouseX, mouseY, button) -> {
+                                    closeWith(this.color);
+                                    return true;
+                                }))));
+    }
+
+    private IWidget createRGBPage(IWidget alphaSlider) {
+        return new Column()
+                .sizeRel(1f, 1f)
+                .child(new Row()
+                        .widthRel(1f).height(12)
+                        .child(IKey.str("R: ").asWidget().heightRel(1f))
+                        .child(createSlider(this.sliderBackgroundR)
+                                .name("red")
+                                .bounds(0, 255)
+                                .value(new DoubleValue.Dynamic(() -> this.red, this::updateRed))))
+                .child(new Row()
+                        .widthRel(1f).height(12)
+                        .child(IKey.str("G: ").asWidget().heightRel(1f))
+                        .child(createSlider(this.sliderBackgroundG)
+                                .name("green")
+                                .bounds(0, 255)
+                                .value(new DoubleValue.Dynamic(() -> this.green, this::updateGreen))))
+                .child(new Row()
+                        .widthRel(1f).height(12)
+                        .child(IKey.str("B: ").asWidget().heightRel(1f))
+                        .child(createSlider(this.sliderBackgroundB)
+                                .name("blue")
+                                .bounds(0, 255)
+                                .value(new DoubleValue.Dynamic(() -> this.blue, this::updateBlue))))
+                .childIf(alphaSlider != null, () -> alphaSlider);
+    }
+
+    private IWidget createHSVPage(IWidget alphaSlider) {
+        return new Column()
+                .sizeRel(1f, 1f)
+                .child(new Row()
+                        .widthRel(1f).height(12)
+                        .child(IKey.str("H: ").asWidget().heightRel(1f))
+                        .child(createSlider(new HueBar(GuiAxis.X))
+                                .name("hue")
+                                .bounds(0, 360)
+                                .value(new DoubleValue.Dynamic(() -> this.hue, this::updateHue))))
+                .child(new Row()
+                        .widthRel(1f).height(12)
+                        .child(IKey.str("S: ").asWidget().heightRel(1f))
+                        .child(createSlider(this.sliderBackgroundS)
+                                .name("saturation")
+                                .bounds(0, 1)
+                                .value(new DoubleValue.Dynamic(() -> this.saturation, this::updateSaturation))))
+                .child(new Row()
+                        .widthRel(1f).height(12)
+                        .child(IKey.str("V: ").asWidget().heightRel(1f))
+                        .child(createSlider(this.sliderBackgroundV)
+                                .name("value")
+                                .bounds(0, 1)
+                                .value(new DoubleValue.Dynamic(() -> this.value, this::updateValue))))
+                .childIf(alphaSlider != null, () -> alphaSlider);
+    }
+
+    private static SliderWidget createSlider(IDrawable background) {
+        return new SliderWidget()
+                .expanded()
+                .heightRel(1f)
+                .background(background.asIcon().size(0, 4))
+                .sliderTexture(handleBackground)
+                .sliderSize(2, 8);
+    }
+
+    private IWidget createAlphaSlider(String s) {
+        return controlAlpha ? new Row()
+                .widthRel(1f).height(12)
+                .child(IKey.str("A: ").asWidget().heightRel(1f))
+                .child(createSlider(this.sliderBackgroundA)
+                        .name("alpha " + s)
+                        .bounds(0, 255)
+                        .value(new DoubleValue.Dynamic(() -> this.alpha, this::updateAlpha))) :
+                null;
+    }
+
+    private String validateRawColor(String raw) {
+        if (!raw.startsWith("#")) {
+            if (raw.startsWith("0x") || raw.startsWith("0X")) {
+                raw = raw.substring(2);
+            }
+            return "#" + raw;
+        }
+        return raw;
+    }
+
+    private void updateRed(double v) {
+        this.red = (int) v;
+        updateFromRGB();
+    }
+
+    private void updateGreen(double v) {
+        this.green = (int) v;
+        updateFromRGB();
+    }
+
+    private void updateBlue(double v) {
+        this.blue = (int) v;
+        updateFromRGB();
+    }
+
+    private void updateHue(double v) {
+        this.hue = v;
+        updateFromHSV();
+    }
+
+    private void updateSaturation(double v) {
+        this.saturation = v;
+        updateFromHSV();
+    }
+
+    private void updateValue(double v) {
+        this.value = v;
+        updateFromHSV();
+    }
+
+    private void updateAlpha(double v) {
+        if (!this.controlAlpha) return;
+        this.alpha = (int) v;
+        this.color = Color.withAlpha(this.color, this.alpha);
+    }
+
+    private void updateFromRGB() {
+        this.color = Color.argb(this.red, this.green, this.blue, this.alpha);
+        this.saturation = Color.getHSVSaturation(this.color);
+        this.value = Color.getValue(this.color);
+        this.hue = Color.getHue(this.color);
+        updateColor(this.color);
+    }
+
+    private void updateFromHSV() {
+        this.color = Color.ofHSV((float) this.hue, (float) this.saturation, (float) this.value, this.alpha);
+        this.red = Color.getRed(this.color);
+        this.green = Color.getGreen(this.color);
+        this.blue = Color.getBlue(this.color);
+        updateColor(this.color);
+    }
+
+    public void updateAll(int color) {
+        if (!this.controlAlpha) {
+            color = Color.withAlpha(color, this.alpha);
+        }
+        this.color = color;
+        this.alpha = Color.getAlpha(color);
+        this.red = Color.getRed(color);
+        this.green = Color.getGreen(color);
+        this.blue = Color.getBlue(color);
+        this.hue = Color.getHue(color);
+        this.saturation = Color.getHSVSaturation(color);
+        this.value = Color.getValue(color);
+        updateColor(color);
+    }
+
+    public void updateColor(int color) {
+        color = Color.withAlpha(color, 255);
+        int rs = Color.withRed(color, 0), re = Color.withRed(color, 255);
+        int gs = Color.withGreen(color, 0), ge = Color.withGreen(color, 255);
+        int bs = Color.withBlue(color, 0), be = Color.withBlue(color, 255);
+        int as = Color.withAlpha(color, 0), ae = Color.withAlpha(color, 255);
+        this.sliderBackgroundR.horizontalGradient(rs, re);
+        this.sliderBackgroundG.horizontalGradient(gs, ge);
+        this.sliderBackgroundB.horizontalGradient(bs, be);
+        this.sliderBackgroundA.horizontalGradient(as, ae);
+        this.sliderBackgroundS.horizontalGradient(Color.withHSVSaturation(color, 0f),
+                Color.withHSVSaturation(color, 1f));
+        this.sliderBackgroundV.horizontalGradient(Color.withValue(color, 0f), Color.withValue(color, 1f));
+        this.preview.color(color);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/CycleButtonWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/CycleButtonWidget.java
new file mode 100644
index 00000000000..7c161433186
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/CycleButtonWidget.java
@@ -0,0 +1,108 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import java.util.function.Consumer;
+
+/**
+ * A button which cycles between multiple states by clicking on it. Background, overlay and tooltip can be supplied per
+ * state.
+ * <p>
+ * Note that you need to set the amount of states before setting any state backgrounds etc. The state count is
+ * automatically set, if the passed {@link com.gregtechceu.gtceu.api.mui.base.value.IIntValue} is a
+ * {@link com.gregtechceu.gtceu.api.mui.base.value.IEnumValue IEnumValue} or a
+ * {@link com.gregtechceu.gtceu.api.mui.base.value.IBoolValue IBoolValue}.
+ * </p>
+ * 
+ * @see ToggleButton
+ */
+public class CycleButtonWidget extends AbstractCycleButtonWidget<CycleButtonWidget> {
+
+    @Override
+    public CycleButtonWidget value(IIntValue<?> value) {
+        return super.value(value);
+    }
+
+    public CycleButtonWidget stateBackground(int state, IDrawable drawable) {
+        this.background = addToArray(this.background, drawable, state);
+        return getThis();
+    }
+
+    public CycleButtonWidget stateHoverBackground(int state, IDrawable drawable) {
+        this.hoverBackground = addToArray(this.hoverBackground, drawable, state);
+        return getThis();
+    }
+
+    public CycleButtonWidget stateOverlay(int state, IDrawable drawable) {
+        this.overlay = addToArray(this.overlay, drawable, state);
+        return getThis();
+    }
+
+    public CycleButtonWidget stateHoverOverlay(int state, IDrawable drawable) {
+        this.hoverOverlay = addToArray(this.hoverOverlay, drawable, state);
+        return getThis();
+    }
+
+    public CycleButtonWidget stateBackground(boolean state, IDrawable drawable) {
+        return stateBackground(state ? 1 : 0, drawable);
+    }
+
+    public CycleButtonWidget stateHoverBackground(boolean state, IDrawable drawable) {
+        return stateHoverBackground(state ? 1 : 0, drawable);
+    }
+
+    public CycleButtonWidget stateOverlay(boolean state, IDrawable drawable) {
+        return stateOverlay(state ? 1 : 0, drawable);
+    }
+
+    public CycleButtonWidget stateHoverOverlay(boolean state, IDrawable drawable) {
+        return stateHoverOverlay(state ? 1 : 0, drawable);
+    }
+
+    public <T extends Enum<T>> CycleButtonWidget stateBackground(T state, IDrawable drawable) {
+        return stateBackground(state.ordinal(), drawable);
+    }
+
+    public <T extends Enum<T>> CycleButtonWidget stateHoverBackground(T state, IDrawable drawable) {
+        return stateHoverBackground(state.ordinal(), drawable);
+    }
+
+    public <T extends Enum<T>> CycleButtonWidget stateOverlay(T state, IDrawable drawable) {
+        return stateOverlay(state.ordinal(), drawable);
+    }
+
+    public <T extends Enum<T>> CycleButtonWidget stateHoverOverlay(T state, IDrawable drawable) {
+        return stateHoverOverlay(state.ordinal(), drawable);
+    }
+
+    @Override
+    public CycleButtonWidget addTooltip(int state, String tooltip) {
+        return super.addTooltip(state, tooltip);
+    }
+
+    @Override
+    public CycleButtonWidget addTooltip(int state, IDrawable tooltip) {
+        return super.addTooltip(state, tooltip);
+    }
+
+    public CycleButtonWidget length(int length) {
+        return stateCount(length);
+    }
+
+    @Override
+    public CycleButtonWidget stateCount(int stateCount) {
+        return super.stateCount(stateCount);
+    }
+
+    @Override
+    public CycleButtonWidget tooltip(int index, Consumer<RichTooltip> builder) {
+        return super.tooltip(index, builder);
+    }
+
+    @Override
+    public CycleButtonWidget tooltipBuilder(int index, Consumer<RichTooltip> builder) {
+        return super.tooltipBuilder(index, builder);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/Dialog.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/Dialog.java
new file mode 100644
index 00000000000..ee264fb75e0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/Dialog.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.function.Consumer;
+
+@Accessors(chain = true)
+public class Dialog<T> extends ModularPanel {
+
+    private final Consumer<T> resultConsumer;
+    @Getter
+    @Setter
+    private boolean draggable = false;
+    @Setter
+    private boolean disablePanelsBelow = true;
+    @Setter
+    private boolean closeOnOutOfBoundsClick = false;
+
+    public Dialog(String name) {
+        this(name, null);
+    }
+
+    public Dialog(String name, Consumer<T> resultConsumer) {
+        super(name);
+        this.resultConsumer = resultConsumer;
+    }
+
+    public void closeWith(T result) {
+        if (this.resultConsumer != null) {
+            this.resultConsumer.accept(result);
+        }
+        closeIfOpen();
+    }
+
+    @Override
+    public boolean disablePanelsBelow() {
+        return this.disablePanelsBelow;
+    }
+
+    @Override
+    public boolean closeOnOutOfBoundsClick() {
+        return this.closeOnOutOfBoundsClick;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/DynamicSyncedWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/DynamicSyncedWidget.java
new file mode 100644
index 00000000000..c7c120be7c3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/DynamicSyncedWidget.java
@@ -0,0 +1,88 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.DynamicLinkedSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.DynamicSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.IDynamicSyncNotifiable;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandler;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * A widget which can update its child based on a function in {@link DynamicSyncHandler}.
+ * Such a sync handler must be supplied or else this widget has no effect.
+ * The dynamic child can be a widget tree of any size which can also contain {@link SyncHandler}s. These sync handlers
+ * MUST be registered
+ * via a variant of
+ * {@link com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager#getOrCreateSyncHandler(String, Class, Supplier)
+ * PanelSyncManager#getOrCreateSyncHandler(String, Class, Supplier)}.
+ * 
+ * @param <W> type of this widget
+ */
+public class DynamicSyncedWidget<W extends DynamicSyncedWidget<W>> extends Widget<W> {
+
+    private IDynamicSyncNotifiable syncHandler;
+    private IWidget child;
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(IDynamicSyncNotifiable.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.syncHandler = syncOrValue.castNullable(IDynamicSyncNotifiable.class);
+        if (this.syncHandler != null) this.syncHandler.attachDynamicWidgetListener(this::updateChild);
+    }
+
+    @Override
+    public @NotNull List<IWidget> getChildren() {
+        if (this.child == null) {
+            return Collections.emptyList();
+        } else {
+            return Collections.singletonList(this.child);
+        }
+    }
+
+    private void updateChild(IWidget widget) {
+        if (this.child != null) {
+            this.child.dispose();
+        } else if (widget == null) {
+            return;
+        }
+        this.child = widget;
+        if (isValid()) {
+            if (this.child != null) this.child.initialise(this, true);
+            scheduleResize();
+        }
+    }
+
+    public W syncHandler(DynamicSyncHandler syncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(syncHandler));
+        return getThis();
+    }
+
+    public W syncHandler(DynamicLinkedSyncHandler<?> syncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(syncHandler));
+        return getThis();
+    }
+
+    /**
+     * Sets an initial child. This can only be done before the widget is initialised.
+     *
+     * @param child initial child
+     * @return this
+     */
+    public W initialChild(IWidget child) {
+        if (isValid()) throw new IllegalStateException("Can only set initial child before the widget is initialised.");
+        this.child = child;
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/Expandable.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/Expandable.java
new file mode 100644
index 00000000000..a9377e36bf0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/Expandable.java
@@ -0,0 +1,176 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.animation.Animator;
+import com.gregtechceu.gtceu.api.mui.animation.MutableObjectAnimator;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IInterpolation;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolation;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiConsumer;
+
+public class Expandable extends Widget<Expandable> implements Interactable, IViewport {
+
+    private IWidget normalView = new EmptyWidget();
+    private IWidget expandedView = new EmptyWidget();
+    private final List<IWidget> children = Arrays.asList(normalView, expandedView);
+    private List<IWidget> currentChildren = children;
+    private boolean expanded = false;
+    private Area areaSnapshot;
+    private Animator animator;
+    private BiConsumer<Rectangle, Boolean> stencilTransform;
+    private int animationDuration = 300;
+    private IInterpolation interpolation = Interpolation.SINE_OUT;
+
+    public Expandable() {
+        coverChildren();
+    }
+
+    @Override
+    public void onInit() {
+        this.children.set(0, normalView);
+        this.children.set(1, expandedView);
+        this.normalView.setEnabled(!this.expanded);
+        this.expandedView.setEnabled(this.expanded);
+    }
+
+    @Override
+    public void beforeResize(boolean onOpen) {
+        super.beforeResize(onOpen);
+        if (resizer().getChildren().isEmpty() || resizer().getChildren().size() > 2)
+            throw new IllegalStateException("Invalid Expandable children size");
+        if (resizer().getChildren().size() > 1) {
+            resizer().getChildren().remove(1);
+        }
+        resizer().getChildren().set(0, this.expanded ? this.expandedView.resizer() : this.normalView.resizer());
+        this.currentChildren = Collections.singletonList(this.expanded ? this.expandedView : this.normalView);
+    }
+
+    @Override
+    public void postResize() {
+        super.postResize();
+        currentChildren = children;
+        if (this.animator != null) {
+            this.animator.stop(true);
+            this.animator = null;
+        }
+        if (this.areaSnapshot != null) {
+            if (this.animationDuration <= 0) {
+                if (!this.expanded) {
+                    this.normalView.setEnabled(true);
+                    this.expandedView.setEnabled(false);
+                }
+            } else {
+                this.animator = new MutableObjectAnimator<>(getArea(), this.areaSnapshot, getArea().copyOrImmutable())
+                        .duration(
+                                this.animationDuration)
+                        .curve(this.interpolation).onFinish(() -> {
+                            if (!this.expanded) {
+                                this.normalView.setEnabled(true);
+                                this.expandedView.setEnabled(false);
+                            }
+                        });
+                this.animator.animate();
+            }
+            this.areaSnapshot = null;
+        }
+    }
+
+    @Override
+    @NotNull
+    public List<IWidget> getChildren() {
+        return currentChildren;
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        toggle();
+        return Result.SUCCESS;
+    }
+
+    public void toggle() {
+        expanded(!expanded);
+    }
+
+    @Override
+    public void preDraw(ModularGuiContext context, boolean transformed) {
+        if (!transformed) {
+            Rectangle rect = new Rectangle(getArea());
+            rect.x = 0;
+            rect.y = 0;
+            if (this.stencilTransform != null) {
+                this.stencilTransform.accept(rect, this.expanded);
+            }
+            context.getStencil().push(rect);
+        }
+    }
+
+    @Override
+    public void postDraw(ModularGuiContext context, boolean transformed) {
+        if (!transformed) {
+            context.getStencil().pop();
+        }
+    }
+
+    public Expandable expanded(boolean expanded) {
+        if (this.expanded == expanded) return this;
+        this.expanded = expanded;
+        if (expanded) {
+            this.normalView.setEnabled(false);
+            this.expandedView.setEnabled(true);
+        }
+        if (isValid()) {
+            if (expanded) {
+                this.normalView.setEnabled(false);
+                this.expandedView.setEnabled(true);
+            }
+            this.areaSnapshot = getArea().copyOrImmutable();
+            scheduleResize();
+        }
+        return this;
+    }
+
+    public Expandable collapsedView(IWidget normalView) {
+        this.normalView = normalView;
+        this.children.set(0, normalView);
+        if (isValid()) {
+            this.normalView.initialise(this, true);
+        }
+        return this;
+    }
+
+    public Expandable expandedView(IWidget expandedView) {
+        this.expandedView = expandedView;
+        this.children.set(1, expandedView);
+        if (isValid()) {
+            this.expandedView.initialise(this, true);
+        }
+        return this;
+    }
+
+    public Expandable stencilTransform(BiConsumer<Rectangle, Boolean> stencilTransform) {
+        this.stencilTransform = stencilTransform;
+        return this;
+    }
+
+    public Expandable animationDuration(int animationDuration) {
+        this.animationDuration = animationDuration;
+        return this;
+    }
+
+    public Expandable interpolation(IInterpolation interpolation) {
+        this.interpolation = interpolation;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/FluidDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/FluidDisplayWidget.java
new file mode 100644
index 00000000000..d2c0db94283
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/FluidDisplayWidget.java
@@ -0,0 +1,80 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+import com.gregtechceu.gtceu.api.mui.value.ObjectValue;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiConsumer;
+
+public class FluidDisplayWidget extends AbstractFluidDisplayWidget<FluidDisplayWidget> {
+
+    private IValue<FluidStack> value;
+    @Getter
+    private int capacity = 0;
+    private boolean displayAmount = true;
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isValueOfType(FluidStack.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.value = syncOrValue.castValueNullable(FluidStack.class);
+    }
+
+    @Override
+    protected boolean displayAmountText() {
+        return this.displayAmount;
+    }
+
+    @Override
+    protected @Nullable FluidStack getFluidStack() {
+        return this.value != null ? this.value.getValue() : null;
+    }
+
+    public FluidDisplayWidget value(IValue<FluidStack> value) {
+        setSyncOrValue(value);
+        return this;
+    }
+
+    public FluidDisplayWidget value(FluidStack value) {
+        return value(new ObjectValue<>(FluidStack.class, value));
+    }
+
+    /**
+     * Sets the capacity of the slot. This is only used for drawing and doesn't affect the actual capacity in any way.
+     * When the capacity is
+     * greater than zero, the fluid will be drawn partially depending on the fill level.
+     *
+     * @param capacity capacity for drawing the fluid
+     * @return this
+     */
+    public FluidDisplayWidget capacity(int capacity) {
+        this.capacity = capacity;
+        return this;
+    }
+
+    /**
+     * Sets whether the amount number should be displayed in the bottom left corner of the slot.
+     *
+     * @param displayAmount true if amount should be displayed
+     * @return this
+     */
+    public FluidDisplayWidget displayAmount(boolean displayAmount) {
+        this.displayAmount = displayAmount;
+        return this;
+    }
+
+    public FluidDisplayWidget fluidTooltip(BiConsumer<RichTooltip, FluidStack> tooltip) {
+        return tooltipAutoUpdate(true).tooltipBuilder(t -> tooltip.accept(t, getFluidStack()));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ItemDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ItemDisplayWidget.java
new file mode 100644
index 00000000000..8a6b707e559
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ItemDisplayWidget.java
@@ -0,0 +1,78 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.value.ObjectValue;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+
+import net.minecraft.world.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+
+public class ItemDisplayWidget extends Widget<ItemDisplayWidget> implements IngredientProvider<ItemStack> {
+
+    private IValue<ItemStack> value;
+    private boolean displayAmount = false;
+
+    public ItemDisplayWidget() {
+        size(18);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isValueOfType(ItemStack.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.value = syncOrValue.castValueNullable(ItemStack.class);
+    }
+
+    @Override
+    protected WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getItemSlotTheme();
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        ItemStack item = value.getValue();
+        if (!item.isEmpty()) {
+            GuiDraw.drawItem(context.getGraphics(), item, 1, 1, 16, 16, context.getCurrentDrawingZ());
+            if (this.displayAmount) {
+                GuiDraw.drawStandardSlotAmountText(context, item.getCount(), null, getArea(), 0);
+            }
+        }
+    }
+
+    public ItemDisplayWidget item(IValue<ItemStack> itemSupplier) {
+        setSyncOrValue(ISyncOrValue.orEmpty(itemSupplier));
+        return this;
+    }
+
+    public ItemDisplayWidget item(ItemStack itemStack) {
+        return item(new ObjectValue<>(ItemStack.class, itemStack));
+    }
+
+    public ItemDisplayWidget displayAmount(boolean displayAmount) {
+        this.displayAmount = displayAmount;
+        return this;
+    }
+
+    @Override
+    public EntryList<ItemStack> getIngredients() {
+        return ItemStackList.of(value.getValue());
+    }
+
+    @Override
+    public @NotNull Class<ItemStack> ingredientClass() {
+        return ItemStack.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ListValueWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ListValueWidget.java
new file mode 100644
index 00000000000..4e6b91713a7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ListValueWidget.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public class ListValueWidget<T, I extends IWidget, W extends ListValueWidget<T, I, W>> extends ListWidget<I, W> {
+
+    private final Function<I, T> widgetToValue;
+
+    public ListValueWidget(Function<I, T> widgetToValue) {
+        this.widgetToValue = widgetToValue;
+    }
+
+    public List<T> getValues() {
+        List<T> list = new ArrayList<>();
+        for (I widget : getTypeChildren()) {
+            list.add(this.widgetToValue.apply(widget));
+        }
+        return list;
+    }
+
+    public <V> W children(Iterable<V> values, Function<V, I> widgetCreator) {
+        for (V value : values) {
+            child(widgetCreator.apply(value));
+        }
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ListWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ListWidget.java
new file mode 100644
index 00000000000..0aa1d39859d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ListWidget.java
@@ -0,0 +1,335 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.layout.ILayoutWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IParentWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.AbstractScrollWidget;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Unit;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.SimpleFlow;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.utils.ReversedList;
+
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.ints.IntList;
+import lombok.Getter;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.DoubleSupplier;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+
+/**
+ * A widget which can hold any amount of children.
+ *
+ * @param <I> type of children (in most cases just {@link IWidget})
+ * @param <W> type of this widget
+ */
+public class ListWidget<I extends IWidget, W extends ListWidget<I, W>> extends AbstractScrollWidget<I, W>
+                       implements ILayoutWidget, IParentWidget<I, W> {
+
+    @Getter
+    private ScrollData scrollData;
+    private IIcon childSeparator;
+    private final IntList separatorPositions = new IntArrayList();
+    private boolean collapseDisabledChild = true;
+    private boolean wrapTight = false;
+    private Alignment.CrossAxis crossAxisAlignment = Alignment.CrossAxis.CENTER;
+    private Unit mainAxisMaxSize;
+    /**
+     * Whether the children list should be laid out in reverse.
+     */
+    private boolean reverseLayout = false;
+
+    public ListWidget() {
+        super(null, null);
+    }
+
+    @Override
+    public void onInit() {
+        if (this.scrollData == null) {
+            scrollDirection(new VerticalScrollData());
+        }
+    }
+
+    @Override
+    public void beforeResize(boolean onOpen) {
+        super.beforeResize(onOpen);
+        if (this.mainAxisMaxSize != null) {
+            resizer().setUnit(this.mainAxisMaxSize, getAxis(), Unit.State.SIZE);
+        }
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        if (this.childSeparator == null || this.separatorPositions.isEmpty()) return;
+        GuiAxis axis = this.scrollData.getAxis();
+        int x = getArea().getPadding().left(), y = getArea().getPadding().top(), w, h;
+        if (axis.isHorizontal()) {
+            w = this.childSeparator.getWidth();
+            h = getArea().h() - getArea().getPadding().vertical();
+        } else {
+            w = getArea().w() - getArea().getPadding().horizontal();
+            h = this.childSeparator.getHeight();
+        }
+        for (int p : this.separatorPositions) {
+            if (axis.isHorizontal()) {
+                x = p;
+            } else {
+                y = p;
+            }
+            this.childSeparator.draw(context, x, y, w, h, getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+    }
+
+    @Override
+    public boolean layoutWidgets() {
+        if (!hasChildren()) return true;
+        if (this.wrapTight && !resizer().isSizeCalculated(getAxis())) {
+            return false;
+        }
+        this.separatorPositions.clear();
+        GuiAxis axis = getAxis();
+        int separatorSize = getSeparatorSize();
+        int p = getArea().getPadding().getStart(axis);
+        for (IWidget widget : getOrderedChildren()) {
+            if (shouldIgnoreChildSize(widget)) {
+                widget.resizer().updateResized();
+                continue;
+            }
+            if (widget.resizer().hasPos(axis)) {
+                // this is required when the widget has a pos on the main axis, but not on the cross axis
+                widget.resizer().updateResized();
+                continue;
+            }
+            if (!widget.resizer().isSizeCalculated(axis)) return false;
+
+            p += widget.getArea().getMargin().getStart(axis);
+            widget.getArea().setRelativePoint(axis, p);
+            p += widget.getArea().getSize(axis) + widget.getArea().getMargin().getEnd(axis);
+            widget.resizer().setPosResized(axis, true);
+            widget.resizer().setMarginPaddingApplied(true);
+            this.separatorPositions.add(p);
+            p += separatorSize;
+        }
+        int size = p + getArea().getPadding().getEnd(axis);
+        getScrollData().setScrollSize(size);
+        int widgetSize = getArea().getSize(axis);
+        if (this.wrapTight && size < widgetSize) {
+            getArea().setSize(getAxis(), size);
+            resizer().setSizeResized(axis, true);
+            if (resizer().isPosCalculated(axis)) {
+                // if the position is defined with right(), bottom() or is relative, then the position is very likely
+                // invalid now let mui recalculate position
+                resizer().setPosResized(axis, false);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean postLayoutWidgets() {
+        SimpleFlow flow = new SimpleFlow();
+        flow.widgets.addAll(getChildren());
+        return Flow.layoutCrossAxisListLike(this, Collections.singletonList(flow), getAxis(), this.crossAxisAlignment,
+                0);
+    }
+
+    @Override
+    public boolean canCoverByDefaultSize(GuiAxis axis) {
+        return axis.getOther() == getAxis();
+    }
+
+    @Override
+    public boolean shouldIgnoreChildSize(IWidget child) {
+        return this.collapseDisabledChild && !child.isEnabled();
+    }
+
+    @Override
+    public void onChildChangeEnabled(IWidget child, boolean enabled) {
+        if (this.collapseDisabledChild) {
+            ILayoutWidget.super.onChildChangeEnabled(child, enabled);
+            checkScrollbarActive(true);
+        }
+    }
+
+    @Override
+    public boolean addChild(I child, int index) {
+        return super.addChild(child, index);
+    }
+
+    @Override
+    public boolean remove(I child) {
+        return super.remove(child);
+    }
+
+    @Override
+    public boolean remove(int index) {
+        return super.remove(index);
+    }
+
+    @Override
+    protected void onChildAdd(I child) {
+        super.onChildAdd(child);
+        if (isValid()) {
+            scheduleResize();
+            this.scrollData.clamp(getScrollArea());
+        }
+    }
+
+    @Override
+    protected boolean removeAll() {
+        return super.removeAll();
+    }
+
+    @Override
+    protected void onChildRemove(I child) {
+        super.onChildRemove(child);
+        if (isValid()) {
+            scheduleResize();
+            this.scrollData.clamp(getScrollArea());
+        }
+    }
+
+    public int getSeparatorSize() {
+        if (this.childSeparator == null) return 0;
+        return getAxis().isHorizontal() ? this.childSeparator.getWidth() :
+                this.childSeparator.getHeight();
+    }
+
+    public GuiAxis getAxis() {
+        return this.scrollData.getAxis();
+    }
+
+    public List<IWidget> getOrderedChildren() {
+        return this.reverseLayout ? new ReversedList<>(getChildren()) : getChildren();
+    }
+
+    private W maxSize(float v, int offset, Unit.Measure measure) {
+        if (this.mainAxisMaxSize == null) this.mainAxisMaxSize = new Unit();
+        this.mainAxisMaxSize.setValue(v);
+        this.mainAxisMaxSize.setOffset(offset);
+        this.mainAxisMaxSize.setMeasure(measure);
+        return wrapTight();
+    }
+
+    private W maxSize(DoubleSupplier v, int offset, Unit.Measure measure) {
+        if (this.mainAxisMaxSize == null) this.mainAxisMaxSize = new Unit();
+        this.mainAxisMaxSize.setValue(v);
+        this.mainAxisMaxSize.setOffset(offset);
+        this.mainAxisMaxSize.setMeasure(measure);
+        return wrapTight();
+    }
+
+    public W maxSize(int v) {
+        return maxSize(v, 0, Unit.Measure.PIXEL);
+    }
+
+    public W maxSizeRel(float v) {
+        return maxSize(v, 0, Unit.Measure.RELATIVE);
+    }
+
+    public W maxSizeRelOffset(float v, int offset) {
+        return maxSize(v, offset, Unit.Measure.RELATIVE);
+    }
+
+    public W maxSize(DoubleSupplier v) {
+        return maxSize(v, 0, Unit.Measure.PIXEL);
+    }
+
+    public W maxSizeRel(DoubleSupplier v) {
+        return maxSize(v, 0, Unit.Measure.RELATIVE);
+    }
+
+    public W maxSizeRelOffset(DoubleSupplier v, int offset) {
+        return maxSize(v, offset, Unit.Measure.RELATIVE);
+    }
+
+    public W wrapTight() {
+        this.wrapTight = true;
+        return getThis();
+    }
+
+    public W scrollDirection(GuiAxis axis) {
+        return scrollDirection(ScrollData.of(axis));
+    }
+
+    public W scrollDirection(ScrollData data) {
+        this.scrollData = data;
+        getScrollArea().removeScrollData();
+        getScrollArea().setScrollData(this.scrollData);
+        return getThis();
+    }
+
+    public W childSeparator(IIcon separator) {
+        this.childSeparator = separator;
+        return getThis();
+    }
+
+    public W children(Iterable<I> widgets) {
+        for (I widget : widgets) {
+            child(widget);
+        }
+        return getThis();
+    }
+
+    public W children(int amount, IntFunction<I> widgetCreator) {
+        for (int i = 0; i < amount; i++) {
+            child(widgetCreator.apply(i));
+        }
+        return getThis();
+    }
+
+    public <T> W children(Iterable<T> it, Function<T, I> widgetCreator) {
+        for (T t : it) {
+            child(widgetCreator.apply(t));
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets if disabled children should be collapsed.
+     */
+    public W collapseDisabledChild() {
+        this.collapseDisabledChild = true;
+        return getThis();
+    }
+
+    /**
+     * Sets if disabled children should be collapsed. This means that if a child changes enabled state, this widget gets
+     * notified and
+     * re-layouts its children. Children which are disabled will not be considered during layout, so that the list will
+     * not appear to have
+     * empty spots. This is enabled by default on lists.
+     *
+     * @param doCollapse true if disabled children should be collapsed.
+     * @return this
+     */
+    public W collapseDisabledChild(boolean doCollapse) {
+        this.collapseDisabledChild = doCollapse;
+        return getThis();
+    }
+
+    public W crossAxisAlignment(Alignment.CrossAxis caa) {
+        this.crossAxisAlignment = caa;
+        return getThis();
+    }
+
+    /**
+     * Sets if the children list should be laid out in reversed or not (Default is false).
+     *
+     * @param reverseLayout true if the children list should be layout in reverse
+     * @return this
+     */
+    public W reverseLayout(boolean reverseLayout) {
+        this.reverseLayout = reverseLayout;
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/PageButton.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/PageButton.java
new file mode 100644
index 00000000000..880d226f80d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/PageButton.java
@@ -0,0 +1,87 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableStack;
+import com.gregtechceu.gtceu.api.mui.drawable.TabTexture;
+import com.gregtechceu.gtceu.api.mui.theme.SelectableTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+
+import org.jetbrains.annotations.NotNull;
+
+public class PageButton extends Widget<PageButton> implements Interactable {
+
+    private final int index;
+    private final PagedWidget.Controller controller;
+    private IDrawable inactiveTexture = null;
+    private boolean invert = false;
+
+    public PageButton(int index, PagedWidget.Controller controller) {
+        this.index = index;
+        this.controller = controller;
+        disableHoverBackground();
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getToggleButtonTheme();
+    }
+
+    @Override
+    protected WidgetTheme getActiveWidgetTheme(WidgetThemeEntry<?> widgetTheme, boolean hover) {
+        SelectableTheme selectableTheme = widgetTheme.expectType(SelectableTheme.class).getTheme(hover);
+        return isActive() ^ invertSelected() ? selectableTheme : selectableTheme.getSelected();
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        if (!isActive()) {
+            this.controller.setPage(this.index);
+            Interactable.playButtonClickSound();
+            return Result.SUCCESS;
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public IDrawable getBackground() {
+        return isActive() || this.inactiveTexture == null ? super.getBackground() : this.inactiveTexture;
+    }
+
+    public boolean isActive() {
+        return this.controller.getActivePageIndex() == this.index;
+    }
+
+    public PageButton background(boolean active, IDrawable... background) {
+        if (active) {
+            return background(background);
+        }
+        if (background.length == 0) {
+            this.inactiveTexture = null;
+        } else if (background.length == 1) {
+            this.inactiveTexture = background[0];
+        } else {
+            this.inactiveTexture = new DrawableStack(background);
+        }
+        return this;
+    }
+
+    public PageButton tab(TabTexture texture, int location) {
+        return background(invertSelected(), texture.get(location, invertSelected()))
+                .background(!invertSelected(), texture.get(location, !invertSelected()))
+                .disableHoverBackground()
+                .size(texture.getWidth(), texture.getHeight());
+    }
+
+    public PageButton invertSelected(boolean invert) {
+        this.invert = invert;
+        return getThis();
+    }
+
+    public boolean invertSelected() {
+        return this.invert;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/PagedWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/PagedWidget.java
new file mode 100644
index 00000000000..0a0a5995118
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/PagedWidget.java
@@ -0,0 +1,141 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+
+import lombok.Getter;
+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.IntConsumer;
+
+public class PagedWidget<W extends PagedWidget<W>> extends Widget<W> {
+
+    @Getter
+    private final List<IWidget> pages = new ArrayList<>();
+    @Getter
+    private IWidget currentPage;
+    @Getter
+    private int currentPageIndex = 0;
+
+    @Nullable
+    private IntConsumer onPageChange;
+
+    @Override
+    public void afterInit() {
+        setPage(this.currentPageIndex);
+    }
+
+    /**
+     * Set a consumer that is accepted <b>right after</b> the page is actually changed and the next page widget is
+     * enabled. <br/>
+     * Will also be called with {@code 0} when after this widget is initialized.
+     */
+    public W onPageChange(@Nullable IntConsumer onPageChange) {
+        this.onPageChange = onPageChange;
+        return getThis();
+    }
+
+    public void setPage(int page) {
+        if (page < 0 || page >= this.pages.size()) {
+            throw new IndexOutOfBoundsException("Setting page of " + this + " to " + page +
+                    " failed. Only values from 0 to " + (this.pages.size() - 1) + " are allowed.");
+        }
+        this.currentPageIndex = page;
+        if (this.currentPage != null) {
+            this.currentPage.setEnabled(false);
+        }
+        this.currentPage = this.pages.get(this.currentPageIndex);
+        this.currentPage.setEnabled(true);
+
+        if (this.onPageChange != null) {
+            this.onPageChange.accept(page);
+        }
+    }
+
+    public void nextPage() {
+        if (++this.currentPageIndex == this.pages.size()) {
+            this.currentPageIndex = 0;
+        }
+        setPage(this.currentPageIndex);
+    }
+
+    public void previousPage() {
+        if (--this.currentPageIndex == -1) {
+            this.currentPageIndex = this.pages.size() - 1;
+        }
+        setPage(this.currentPageIndex);
+    }
+
+    @Override
+    public @Unmodifiable @NotNull List<IWidget> getChildren() {
+        return this.pages;
+    }
+
+    public W initialPage(int page) {
+        if (!isValid()) {
+            this.currentPageIndex = page;
+        }
+        return getThis();
+    }
+
+    public W addPage(IWidget widget) {
+        this.pages.add(widget);
+        widget.setEnabled(false);
+        return getThis();
+    }
+
+    public W controller(Controller controller) {
+        controller.setPagedWidget(this);
+        return getThis();
+    }
+
+    public static class Controller {
+
+        private PagedWidget<?> pagedWidget;
+
+        public boolean isInitialised() {
+            return this.pagedWidget != null && this.pagedWidget.isValid();
+        }
+
+        private void validate() {
+            if (!isInitialised()) {
+                throw new IllegalStateException(
+                        "PagedWidget controller does not have a valid PagedWidget! Current PagedWidget: " +
+                                this.pagedWidget);
+            }
+        }
+
+        private void setPagedWidget(PagedWidget<?> pagedWidget) {
+            this.pagedWidget = pagedWidget;
+        }
+
+        public void setPage(int page) {
+            validate();
+            this.pagedWidget.setPage(page);
+        }
+
+        public void nextPage() {
+            validate();
+            this.pagedWidget.nextPage();
+        }
+
+        public void previousPage() {
+            validate();
+            this.pagedWidget.previousPage();
+        }
+
+        public IWidget getActivePage() {
+            validate();
+            return this.pagedWidget.getCurrentPage();
+        }
+
+        public int getActivePageIndex() {
+            validate();
+            return this.pagedWidget.getCurrentPageIndex();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ProgressWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ProgressWidget.java
new file mode 100644
index 00000000000..263ff61241a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ProgressWidget.java
@@ -0,0 +1,221 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.value.IDoubleValue;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.DoubleValue;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.util.Mth;
+
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+
+@Accessors(fluent = true, chain = true)
+public class ProgressWidget extends Widget<ProgressWidget> {
+
+    private final UITexture[] fullTexture = new UITexture[4];
+    private UITexture emptyTexture;
+    private Direction direction = Direction.RIGHT;
+    private int imageSize = -1;
+
+    private IDoubleValue<?> doubleValue;
+
+    private IDrawable label;
+    private int labelWidth, labelHeight;
+
+    @Override
+    public void onInit() {
+        if (this.doubleValue == null) {
+            this.doubleValue = new DoubleValue(0.5);
+        }
+        if (this.direction == Direction.CIRCULAR_CW && this.fullTexture[0] != null) {
+            UITexture base = this.fullTexture[0];
+            this.fullTexture[0] = base.getSubArea(0f, 0.5f, 0.5f, 1f);
+            this.fullTexture[1] = base.getSubArea(0f, 0f, 0.5f, 0.5f);
+            this.fullTexture[2] = base.getSubArea(0.5f, 0f, 1f, 0.5f);
+            this.fullTexture[3] = base.getSubArea(0.5f, 0.5f, 1f, 1f);
+        }
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(IDoubleValue.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.doubleValue = syncOrValue.castNullable(IDoubleValue.class);
+    }
+
+    @Override
+    public void onResized() {
+        super.onResized();
+        if (this.imageSize < 0) {
+            this.imageSize = getArea().width;
+        }
+    }
+
+    public float getCurrentProgress() {
+        return (float) this.doubleValue.getDoubleValue();
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> entry) {
+        WidgetTheme widgetTheme = getActiveWidgetTheme(entry, isHovering());
+        if (this.emptyTexture != null) {
+            this.emptyTexture.draw(context, 0, 0, getArea().w(), getArea().h(), widgetTheme);
+            Color.setGlColorOpaque(Color.WHITE.main);
+        }
+        float progress = getCurrentProgress();
+        if (this.fullTexture[0] != null && progress > 0) {
+            if (this.direction == Direction.CIRCULAR_CW) {
+                drawCircular(context, progress, widgetTheme);
+                return;
+            }
+            progress = getProgressUV(progress);
+            float u0 = 0, v0 = 0, u1 = 1, v1 = 1;
+            float x = 0, y = 0, width = getArea().width, height = getArea().height;
+            float labelXOffset = 0, labelYOffset = 0;
+            switch (this.direction) {
+                case RIGHT:
+                    u1 = progress;
+                    width *= progress;
+                    labelXOffset = -labelWidth / 2f;
+                    labelYOffset = -height / 2 - 2;
+                    break;
+                case LEFT:
+                    u0 = 1 - progress;
+                    width *= progress;
+                    x = getArea().width - width;
+                    labelXOffset = -labelWidth / 2f;
+                    labelYOffset = -height / 2 - 2;
+                    break;
+                case DOWN:
+                    v1 = progress;
+                    height *= progress;
+                    labelXOffset = width / 2 + 2;
+                    labelYOffset = -labelHeight / 2f;
+                    break;
+                case UP:
+                    v0 = 1 - progress;
+                    height *= progress;
+                    y = getArea().height - height;
+                    labelXOffset = width / 2 + 2;
+                    labelYOffset = -labelHeight / 2f;
+                    break;
+            }
+            this.fullTexture[0].drawSubArea(context, x, y, width, height, u0, v0, u1, v1, widgetTheme);
+            if (this.label != null) {
+                this.label.draw(context, (int) (x + labelXOffset - width), (int) (y + labelYOffset), labelWidth,
+                        labelHeight, widgetTheme);
+            }
+        }
+    }
+
+    public float getProgressUV(float uv) {
+        if (ConfigHolder.INSTANCE.client.ui.smoothProgressBar) {
+            return uv;
+        }
+        return (float) (Math.floor(uv * this.imageSize) / this.imageSize);
+    }
+
+    private void drawCircular(GuiContext context, float progress, WidgetTheme widgetTheme) {
+        float[] subAreas = {
+                getProgressUV(Mth.clamp(progress / 0.25f, 0, 1)),
+                getProgressUV(Mth.clamp((progress - 0.25f) / 0.25f, 0, 1)),
+                getProgressUV(Mth.clamp((progress - 0.5f) / 0.25f, 0, 1)),
+                getProgressUV(Mth.clamp((progress - 0.75f) / 0.25f, 0, 1))
+        };
+        float halfWidth = getArea().width / 2f;
+        float halfHeight = getArea().height / 2f;
+
+        float progressScaled = subAreas[0] * halfHeight;
+        this.fullTexture[0].drawSubArea(context,
+                0, getArea().height - progressScaled,
+                halfWidth, progressScaled,
+                0.0f, 1.0f - progressScaled / halfHeight,
+                1.0f, 1.0f, widgetTheme); // BL, draw UP
+
+        progressScaled = subAreas[1] * halfWidth;
+        this.fullTexture[1].drawSubArea(context,
+                0, 0,
+                progressScaled, halfHeight,
+                0.0f, 0.0f,
+                progressScaled / (halfWidth), 1.0f,
+                widgetTheme); // TL, draw RIGHT
+
+        progressScaled = subAreas[2] * halfHeight;
+        this.fullTexture[2].drawSubArea(context,
+                halfWidth, 0,
+                halfWidth, progressScaled,
+                0.0f, 0.0f,
+                1.0f, progressScaled / halfHeight,
+                widgetTheme); // TR, draw DOWN
+
+        progressScaled = subAreas[3] * halfWidth;
+        this.fullTexture[3].drawSubArea(context,
+                getArea().width - progressScaled, halfHeight,
+                progressScaled, halfHeight,
+                1.0f - progressScaled / halfWidth, 0.0f,
+                1.0f, 1.0f, widgetTheme); // BR, draw LEFT
+    }
+
+    public ProgressWidget value(IDoubleValue<?> value) {
+        setSyncOrValue(ISyncOrValue.orEmpty(value));
+        return this;
+    }
+
+    public ProgressWidget progress(double progress) {
+        return value(new DoubleValue(progress));
+    }
+
+    /**
+     * Sets the texture to render
+     *
+     * @param emptyTexture empty bar, always rendered
+     * @param fullTexture  full bar, partly rendered, based on progress
+     * @param imageSize    image size in direction of progress. used for non-smooth rendering
+     */
+    public ProgressWidget texture(UITexture emptyTexture, UITexture fullTexture, int imageSize) {
+        this.emptyTexture = emptyTexture;
+        this.fullTexture[0] = fullTexture;
+        this.imageSize = imageSize;
+        return this;
+    }
+
+    /**
+     * @param texture a texture where the empty and full bar are stacked on top of each other
+     */
+    public ProgressWidget texture(UITexture texture, int imageSize) {
+        return texture(texture.getSubArea(0, 0, 1, 0.5f), texture.getSubArea(0, 0.5f, 1, 1), imageSize);
+    }
+
+    public ProgressWidget direction(Direction direction) {
+        this.direction = direction;
+        return this;
+    }
+
+    public ProgressWidget label(IDrawable label, int width, int height) {
+        this.label = label;
+        this.labelWidth = width;
+        this.labelHeight = height;
+        return this;
+    }
+
+    public enum Direction {
+        LEFT,
+        RIGHT,
+        UP,
+        DOWN,
+        CIRCULAR_CW
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/RichTextWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/RichTextWidget.java
new file mode 100644
index 00000000000..c490950e748
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/RichTextWidget.java
@@ -0,0 +1,172 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IHoverable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IRichTextBuilder;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.text.RichText;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+
+public class RichTextWidget extends Widget<RichTextWidget> implements IRichTextBuilder<RichTextWidget>, Interactable {
+
+    private final RichText text = new RichText();
+    private Consumer<RichText> builder;
+    private boolean dirty = false;
+    private boolean autoUpdate = false;
+
+    public void markDirty() {
+        this.dirty = true;
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        super.draw(context, widgetTheme);
+        if (this.autoUpdate || this.dirty) {
+            if (this.builder != null) {
+                this.text.clearText();
+                this.builder.accept(this.text);
+            }
+            this.dirty = false;
+        }
+        this.text.drawAtZeroPadded(context, getArea(), getActiveWidgetTheme(widgetTheme, isHovering()));
+    }
+
+    @Override
+    public void drawForeground(ModularGuiContext context) {
+        super.drawForeground(context);
+        if (getHoveredElement(context) instanceof IHoverable hoverable) {
+            hoverable.onHover();
+            RichTooltip tooltip = hoverable.getTooltip();
+            if (tooltip != null) {
+                tooltip.draw(context);
+            }
+        }
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onMousePressed(mouseX, mouseY, button);
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onMouseReleased(mouseX, mouseY, button);
+        }
+        return false;
+    }
+
+    @Override
+    public @NotNull Result onMouseTapped(double mouseX, double mouseY, int button) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onMouseTapped(mouseX, mouseY, button);
+        }
+        return Result.IGNORE;
+    }
+
+    @Override
+    public @NotNull Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onKeyPressed(keyCode, scanCode, modifiers);
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onKeyReleased(keyCode, scanCode, modifiers);
+        }
+        return false;
+    }
+
+    @Override
+    public @NotNull Result onKeyTapped(int keyCode, int scanCode, int modifiers) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onKeyTapped(keyCode, scanCode, modifiers);
+        }
+        return Result.ACCEPT;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            return interactable.onMouseScrolled(mouseX, mouseY, delta);
+        }
+        return false;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        if (getHoveredElement() instanceof Interactable interactable) {
+            interactable.onMouseDrag(mouseX, mouseY, button, dragX, dragY);
+        }
+    }
+
+    /**
+     * Returns the currently hovered element of this rich text or {@code null} if none is hovered.
+     * Note that this method assumes, that the {@link com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack
+     * IViewportStack}
+     * is transformed to this widget.
+     *
+     * @return hovered element or null
+     */
+    @Nullable
+    public Object getHoveredElement() {
+        return getHoveredElement(getContext());
+    }
+
+    /**
+     * Returns the currently hovered element of this rich text or {@code null} if none is hovered.
+     * Note that this method assumes, that the {@link com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack
+     * IViewportStack}
+     * is transformed to this widget.
+     *
+     * @param context the viewport stack with transformation to this widget
+     * @return hovered element or null
+     */
+    @Nullable
+    public Object getHoveredElement(ModularGuiContext context) {
+        if (!isHovering()) return null;
+        return this.text.getHoveringElement(context);
+    }
+
+    @Override
+    public IRichTextBuilder<?> getRichText() {
+        return text;
+    }
+
+    /**
+     * Sets the auto update property. If auto update is true the text will be deleted each time it is drawn.
+     * If {@link #builder} is not null, it will then be called.
+     *
+     * @param autoUpdate auto update
+     * @return this
+     */
+    public RichTextWidget autoUpdate(boolean autoUpdate) {
+        this.autoUpdate = autoUpdate;
+        return this;
+    }
+
+    /**
+     * A builder which is called every time before drawing when {@link #dirty} is true.
+     *
+     * @param builder text builder
+     * @return this
+     */
+    public RichTextWidget textBuilder(Consumer<RichText> builder) {
+        this.builder = builder;
+        markDirty();
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SchemaWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SchemaWidget.java
new file mode 100644
index 00000000000..90fe8945e8a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SchemaWidget.java
@@ -0,0 +1,178 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.schema.ISchema;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.schemarenderer.BaseSchemaRenderer;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.utils.GTMath;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+
+public class SchemaWidget extends Widget<SchemaWidget> implements Interactable {
+
+    private final BaseSchemaRenderer schemaRenderer;
+    private boolean enableRotation = true;
+    private boolean enableTranslation = true;
+    private boolean enableScaling = true;
+    private float scale = 10f;
+    private float pitch = GTMath.PI_QUART;
+    private float yaw = 0;
+    private final Vector3f offset = new Vector3f();
+
+    public SchemaWidget(ISchema schema) {
+        this(new BaseSchemaRenderer(schema));
+    }
+
+    public SchemaWidget(BaseSchemaRenderer schemaRenderer) {
+        this.schemaRenderer = schemaRenderer;
+    }
+
+    @Override
+    public void dispose() {
+        super.dispose();
+        this.schemaRenderer.dispose();
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        Vector3fc f = this.schemaRenderer.schema().getFocus();
+        this.schemaRenderer.camera().setLookAtAndAngle(f.x() + this.offset.x, f.y() + this.offset.y,
+                f.z() + this.offset.z, scale, yaw, pitch);
+        this.schemaRenderer.drawAtZeroPadded(context, getArea(), widgetTheme.getTheme());
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        if (this.enableScaling) {
+            incrementScale((float) (-delta / 12.0f));
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        float dx = (float) dragX;
+        float dy = (float) dragY;
+        if (button == InputConstants.MOUSE_BUTTON_LEFT && this.enableRotation) {
+            float moveScale = 0.03f;
+            yaw(this.yaw + dx * moveScale);
+            pitch(this.pitch + dy * moveScale);
+        } else if (button == InputConstants.MOUSE_BUTTON_MIDDLE && this.enableTranslation) {
+            float moveScale = 0.09f;
+            Vector3f look = this.schemaRenderer.camera().getLookVec().normalize(); // direction camera is looking
+            Vector3f right = look.cross(GTMath.UNIT_Y, new Vector3f()).normalize(); // right relative to screen
+            Vector3f up = right.cross(look, new Vector3f()); // up relative to screen
+            this.offset.sub(right.mul(dx * moveScale)).add(up.mul(dy * moveScale));
+        }
+    }
+
+    public void incrementScale(float amount) {
+        this.scale += amount;
+        this.scale = Math.max(this.scale, 0.001f);
+    }
+
+    public SchemaWidget scale(float scale) {
+        this.scale = scale;
+        return this;
+    }
+
+    public SchemaWidget pitch(float pitch) {
+        // clamp pitch to [-180,180] degrees up/down
+        this.pitch = Mth.clamp(pitch, -Mth.HALF_PI + 0.001f, Mth.HALF_PI - 0.001f);
+        return this;
+    }
+
+    public SchemaWidget yaw(float yaw) {
+        this.yaw = (yaw + Mth.TWO_PI) % Mth.TWO_PI;
+        return this;
+    }
+
+    public SchemaWidget offset(float x, float y, float z) {
+        this.offset.set(x, y, z);
+        return this;
+    }
+
+    public SchemaWidget enableDragRotation(boolean enable) {
+        this.enableRotation = enable;
+        return this;
+    }
+
+    public SchemaWidget enableDragTranslation(boolean enable) {
+        this.enableTranslation = enable;
+        return this;
+    }
+
+    public SchemaWidget enableScrollScaling(boolean enable) {
+        this.enableScaling = enable;
+        return this;
+    }
+
+    public SchemaWidget enableInteraction(boolean rotation, boolean translation, boolean scaling) {
+        return enableDragRotation(rotation)
+                .enableDragTranslation(translation)
+                .enableScrollScaling(scaling);
+    }
+
+    public SchemaWidget enableAllInteraction(boolean enable) {
+        return enableInteraction(enable, enable, enable);
+    }
+
+    public static class LayerButton extends ButtonWidget<LayerButton> {
+
+        private final int minLayer;
+        private final int maxLayer;
+        private int currentLayer = Integer.MIN_VALUE;
+
+        public LayerButton(ISchema schema, int minLayer, int maxLayer) {
+            this.minLayer = minLayer;
+            this.maxLayer = maxLayer;
+            overlay(IKey.dynamic(() -> currentLayer > Integer.MIN_VALUE ?
+                    Component.literal(Integer.toString(currentLayer)) : Component.literal("ALL")).scale(0.5f));
+
+            onMousePressed((mouseX, mouseY, button) -> {
+                if (button == 0 || button == 1) {
+                    if (button == 0) {
+                        if (currentLayer == Integer.MIN_VALUE) {
+                            currentLayer = minLayer;
+                        } else {
+                            currentLayer++;
+                        }
+                    } else {
+                        if (currentLayer == Integer.MIN_VALUE) {
+                            currentLayer = maxLayer;
+                        } else {
+                            currentLayer--;
+                        }
+                    }
+                    if (currentLayer > maxLayer || currentLayer < minLayer) {
+                        currentLayer = Integer.MIN_VALUE;
+                    }
+                    return true;
+                }
+                return false;
+            });
+            schema.setRenderFilter(
+                    (blockPos, blockInfo) -> currentLayer == Integer.MIN_VALUE || currentLayer >= blockPos.getY());
+        }
+
+        public LayerButton startLayer(int start) {
+            this.currentLayer = start;
+            return this;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ScrollingTextWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ScrollingTextWidget.java
new file mode 100644
index 00000000000..eadc61c26b9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ScrollingTextWidget.java
@@ -0,0 +1,118 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.animation.Animator;
+import com.gregtechceu.gtceu.api.mui.animation.IAnimator;
+import com.gregtechceu.gtceu.api.mui.animation.SequentialAnimator;
+import com.gregtechceu.gtceu.api.mui.animation.Wait;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolation;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.network.chat.Component;
+
+public class ScrollingTextWidget extends TextWidget<ScrollingTextWidget> {
+
+    private TextRenderer.Line line;
+    private float progress = 0;
+    private IAnimator animator;
+    private Animator forward;
+    private Animator backward;
+
+    private int speed = 15;
+
+    public ScrollingTextWidget(IKey key) {
+        super(key);
+        tooltipBuilder(tooltip -> {
+            tooltip.showUpTimer(10);
+            if (this.line.width() > getArea().width) {
+                tooltip.addLine(key);
+            }
+        });
+    }
+
+    @Override
+    public void dispose() {
+        super.dispose();
+        if (this.animator != null) {
+            this.animator.stop(true);
+        }
+    }
+
+    @Override
+    public void onMouseStartHover() {
+        super.onMouseStartHover();
+        this.animator.resume(false);
+    }
+
+    @Override
+    public void onMouseEndHover() {
+        super.onMouseEndHover();
+        this.animator.stop(true);
+        this.animator.reset();
+        this.progress = 0;
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        if (this.animator == null) {
+            animator(new Animator().curve(Interpolation.SINE_INOUT));
+        }
+        if (this.line == null) {
+            updateLine(getKey().getFormatted());
+        }
+        checkString();
+        WidgetTheme theme = getActiveWidgetTheme(widgetTheme, isHovering());
+        TextRenderer renderer = TextRenderer.SHARED;
+        renderer.setColor(getColor() != null ? getColor().getAsInt() : theme.getTextColor());
+        renderer.setAlignment(getAlignment(), getArea().w(), getArea().h());
+        renderer.setShadow(isShadow() != null ? isShadow() : theme.isTextShadow());
+        renderer.setPos(getArea().getPadding().left(), getArea().getPadding().top());
+        renderer.setScale(getScale());
+        renderer.setSimulate(false);
+        if (isHovering()) {
+            renderer.drawScrolling(context.getGraphics(), this.line, this.progress, getArea(), context);
+        } else {
+            renderer.drawCut(context.getGraphics(), this.line);
+        }
+    }
+
+    @Override
+    protected void onTextChanged(Component newText) {
+        super.onTextChanged(newText);
+        updateLine(newText);
+        markTooltipDirty();
+    }
+
+    protected void updateLine(Component newText) {
+        TextRenderer.SHARED.setScale(getScale());
+        this.line = TextRenderer.SHARED.line(newText.getVisualOrderText());
+        this.animator.stop(true);
+        this.animator.reset();
+        this.forward.duration(this.line.upperWidth() * this.speed);
+        this.backward.duration(this.forward.getDuration() * 3 / 4);
+    }
+
+    /**
+     * Sets the scroll speed when hovered. This sets not the speed directly, but the duration per pixel in milliseconds.
+     * So if the text is
+     * 100 lines long and the "speed" is set to 10, then the whole animation is 1000 milliseconds long.
+     *
+     * @param speed duration per pixel in milliseconds (default is 15)
+     * @return this
+     */
+    public ScrollingTextWidget scrollSpeed(int speed) {
+        this.speed = speed;
+        return this;
+    }
+
+    public ScrollingTextWidget animator(Animator animator) {
+        this.forward = animator.onUpdate((double val) -> this.progress = (float) (val));
+        this.backward = animator.copy(true);
+        this.animator = new SequentialAnimator(this.forward, new Wait(500), this.backward, new Wait(1000))
+                .repeatsOnFinish(20);
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SimpleDialog.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SimpleDialog.java
new file mode 100644
index 00000000000..a8c404449a1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SimpleDialog.java
@@ -0,0 +1,34 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class SimpleDialog<T, W extends Widget<W>> extends Dialog<T> {
+
+    public SimpleDialog(String name, Consumer<T> valueConsumer, W widget, Function<W, T> valueGetter, IKey title) {
+        super(name, valueConsumer);
+        child(new TextWidget<>(title).align(Alignment.TopCenter).marginTop(4));
+        child(widget.align(Alignment.CENTER));
+        child(new ButtonWidget<>()
+                .background(GTGuiTextures.CLOSE)
+                .hoverBackground(GTGuiTextures.CLOSE)
+                .align(Alignment.TopRight)
+                .onMousePressed((mouseX, mouseY, button) -> {
+                    closeIfOpen();
+                    return true;
+                }));
+        child(new ButtonWidget<>()
+                .background(GTGuiTextures.RIGHTLOAD)
+                .hoverBackground(GTGuiTextures.RIGHTLOAD)
+                .align(Alignment.BottomCenter)
+                .onMousePressed((mouseX, mouseY, button) -> {
+                    closeWith(valueGetter.apply(widget));
+                    return true;
+                }));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SliderWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SliderWidget.java
new file mode 100644
index 00000000000..243305712d0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SliderWidget.java
@@ -0,0 +1,286 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.value.IDoubleValue;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IGuiAction;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.DoubleValue;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Unit;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import net.minecraft.util.Mth;
+
+import it.unimi.dsi.fastutil.doubles.DoubleArrayList;
+import it.unimi.dsi.fastutil.doubles.DoubleList;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+
+@Accessors(chain = true)
+public class SliderWidget extends Widget<SliderWidget> implements Interactable {
+
+    private IDoubleValue<?> doubleValue;
+    private IDrawable stopperDrawable = new Rectangle().color(Color.withAlpha(Color.WHITE.main, 0.4f));
+    private IDrawable handleDrawable = GTGuiTextures.BUTTON;
+    private GuiAxis axis = GuiAxis.X;
+    private DoubleList stopper;
+    private int stopperWidth = 2, stopperHeight = 4;
+    private final Unit sliderWidth = new Unit(), sliderHeight = new Unit();
+    private final Area sliderArea = new Area();
+    @Getter
+    private double min, max;
+    private double each = 0;
+    @Getter
+    private boolean dragging = false;
+
+    private double cache = Double.MIN_VALUE;
+
+    public SliderWidget() {
+        sliderHeight(1f).sliderWidth(6);
+        listenGuiAction((IGuiAction.MouseReleased) (mouseX, mouseY, button) -> {
+            boolean val = this.dragging;
+            this.dragging = false;
+            return val;
+        });
+        bounds(0, 100);
+    }
+
+    @Override
+    public void onInit() {
+        if (this.doubleValue == null) {
+            this.doubleValue = new DoubleValue((this.max - this.min) * 0.5 + this.min);
+        }
+        if (this.each > 0 && this.stopper == null) {
+            this.stopper = new DoubleArrayList();
+            for (double d = this.min; d < this.max; d += this.each) {
+                this.stopper.add(d);
+            }
+            this.stopper.add(this.max);
+        }
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(IDoubleValue.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.doubleValue = syncOrValue.castNullable(IDoubleValue.class);
+    }
+
+    @Override
+    public void drawBackground(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        super.drawBackground(context, widgetTheme);
+        if (this.stopper != null && this.stopperDrawable != null && this.stopperWidth > 0 && this.stopperHeight > 0) {
+            for (double stop : this.stopper) {
+                int pos = valueToPos(stop) + this.sliderArea.getSize(this.axis) / 2;
+                if (this.axis.isHorizontal()) {
+                    pos -= this.stopperWidth / 2;
+                    int crossAxisPos = (int) (getArea().height / 2D - this.stopperHeight / 2D);
+                    this.stopperDrawable.draw(context, pos, crossAxisPos, this.stopperWidth, this.stopperHeight,
+                            WidgetTheme.getDefault().getTheme());
+                } else {
+                    pos -= this.stopperHeight / 2;
+                    int crossAxisPos = (int) (getArea().width / 2D - this.stopperWidth / 2D);
+                    this.stopperDrawable.draw(context, crossAxisPos, pos, this.stopperWidth, this.stopperHeight,
+                            WidgetTheme.getDefault().getTheme());
+                }
+            }
+        }
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        if (this.handleDrawable != null) {
+            this.handleDrawable.draw(context, this.sliderArea, getPanel().getTheme().getButtonTheme().getTheme());
+        }
+    }
+
+    @Override
+    public void onResized() {
+        super.onResized();
+        float sw = this.sliderWidth.getValue();
+        if (this.sliderWidth.isRelative()) sw *= getArea().width;
+        float sh = this.sliderHeight.getValue();
+        if (this.sliderHeight.isRelative()) sh *= getArea().height;
+        this.sliderArea.setSize((int) sw, (int) sh);
+        GuiAxis other = this.axis.getOther();
+        this.sliderArea.setPoint(other, getArea().getSize(other) / 2 - this.sliderArea.getSize(other) / 2);
+    }
+
+    @Override
+    public void postResize() {
+        setValue(getSliderValue(), false);
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (this.dragging) return;
+        double val = getSliderValue();
+        if (this.cache != val) {
+            setValue(val, false);
+        }
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        int p = getContext().getMouse(this.axis);
+        setValue(posToValue(p), true);
+        this.dragging = true;
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        if (this.dragging) {
+            onMousePressed(mouseX, mouseY, button);
+        }
+    }
+
+    public double posToValue(int p) {
+        double v = (p - this.sliderArea.getSize(this.axis) / 2D) /
+                (double) (getArea().getSize(this.axis) - this.sliderArea.getSize(this.axis));
+        return v * (this.max - this.min) + this.min;
+    }
+
+    public int valueToPos(double value) {
+        value -= this.min;
+        value /= (this.max - this.min);
+        return (int) (value * (getArea().getSize(this.axis) - this.sliderArea.getSize(this.axis)));
+    }
+
+    public double getSliderValue() {
+        return this.doubleValue == null ? 0.0 : this.doubleValue.getDoubleValue();
+    }
+
+    public void setValue(double value, boolean setSource) {
+        if (this.stopper != null && !this.stopper.isEmpty()) {
+            double lastDistance = Double.MAX_VALUE;
+            boolean found = false;
+            for (int i = 0; i < this.stopper.size(); i++) {
+                double dist = Math.abs(this.stopper.getDouble(i) - value);
+                if (dist < lastDistance) {
+                    lastDistance = dist;
+                } else if (dist > lastDistance) {
+                    value = this.stopper.getDouble(i - 1);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found && lastDistance < Double.MAX_VALUE) {
+                value = this.stopper.getDouble(this.stopper.size() - 1);
+            }
+        }
+        value = Mth.clamp(value, this.min, this.max);
+        this.cache = value;
+        this.sliderArea.setPoint(this.axis, valueToPos(value));
+        if (setSource) {
+            this.doubleValue.setDoubleValue(value);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " # " + getSliderValue();
+    }
+
+    public SliderWidget value(IDoubleValue<?> value) {
+        setSyncOrValue(ISyncOrValue.orEmpty(value));
+        return this;
+    }
+
+    public SliderWidget bounds(double min, double max) {
+        this.max = Math.max(min, max);
+        this.min = Math.min(min, max);
+        if (isValid()) {
+            setValue(getSliderValue(), true);
+        }
+        return this;
+    }
+
+    public SliderWidget stopper(DoubleList stopper) {
+        if (this.stopper == null) this.stopper = new DoubleArrayList();
+        this.stopper.addAll(stopper);
+        this.stopper.sort(Double::compare);
+        return this;
+    }
+
+    public SliderWidget stopper(double... stopper) {
+        if (this.stopper == null) this.stopper = new DoubleArrayList();
+        for (double stop : stopper) {
+            this.stopper.add(stop);
+        }
+        this.stopper.sort(Double::compare);
+        return this;
+    }
+
+    public SliderWidget stopper(double each) {
+        this.each = each;
+        return this;
+    }
+
+    public SliderWidget setAxis(GuiAxis axis) {
+        this.axis = axis;
+        return this;
+    }
+
+    public SliderWidget sliderWidth(int w) {
+        this.sliderWidth.setValue(w);
+        this.sliderWidth.setMeasure(Unit.Measure.PIXEL);
+        return this;
+    }
+
+    public SliderWidget sliderWidth(float w) {
+        this.sliderWidth.setValue(w);
+        this.sliderWidth.setMeasure(Unit.Measure.RELATIVE);
+        return this;
+    }
+
+    public SliderWidget sliderHeight(int h) {
+        this.sliderHeight.setValue(h);
+        this.sliderHeight.setMeasure(Unit.Measure.PIXEL);
+        return this;
+    }
+
+    public SliderWidget sliderHeight(float h) {
+        this.sliderHeight.setValue(h);
+        this.sliderHeight.setMeasure(Unit.Measure.RELATIVE);
+        return this;
+    }
+
+    public SliderWidget sliderSize(int w, int h) {
+        return sliderWidth(w).sliderHeight(h);
+    }
+
+    public SliderWidget sliderSize(float w, float h) {
+        return sliderWidth(w).sliderHeight(h);
+    }
+
+    public SliderWidget sliderTexture(IDrawable sliderTexture) {
+        this.handleDrawable = sliderTexture;
+        return this;
+    }
+
+    public SliderWidget stopperTexture(IDrawable sliderTexture) {
+        this.stopperDrawable = sliderTexture;
+        return this;
+    }
+
+    public SliderWidget stopperSize(int w, int h) {
+        this.stopperWidth = w;
+        this.stopperHeight = h;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SlotGroupWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SlotGroupWidget.java
new file mode 100644
index 00000000000..167cb011ef8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SlotGroupWidget.java
@@ -0,0 +1,264 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.ISynced;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+
+import it.unimi.dsi.fastutil.chars.Char2IntMap;
+import it.unimi.dsi.fastutil.chars.Char2IntOpenHashMap;
+import it.unimi.dsi.fastutil.chars.Char2ObjectMap;
+import it.unimi.dsi.fastutil.chars.Char2ObjectOpenHashMap;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.IntFunction;
+
+public class SlotGroupWidget extends ParentWidget<SlotGroupWidget> {
+
+    @Getter
+    private boolean playerInventory = false;
+
+    public static SlotGroupWidget playerInventory(boolean positioned) {
+        return positioned ? playerInventory(7, true) : playerInventory((index, slot) -> slot);
+    }
+
+    public static SlotGroupWidget playerInventory(boolean positioned, SlotConsumer slotConsumer) {
+        return positioned ? playerInventory(7, true, slotConsumer) : playerInventory(slotConsumer);
+    }
+
+    public static SlotGroupWidget playerInventory(int bottom, boolean horizontalCentered) {
+        return playerInventory(bottom, horizontalCentered, (index, slot) -> slot);
+    }
+
+    public static SlotGroupWidget playerInventory(int bottom, boolean horizontalCentered, SlotConsumer slotConsumer) {
+        SlotGroupWidget widget = playerInventory(slotConsumer);
+        if (bottom != 0) widget.bottom(bottom);
+        if (horizontalCentered) widget.leftRel(0.5f);
+        return widget;
+    }
+
+    /**
+     * Automatically creates and places the player inventory.
+     *
+     * @return player inventory group
+     */
+    public static SlotGroupWidget playerInventory(SlotConsumer slotConsumer) {
+        SlotGroupWidget slotGroupWidget = new SlotGroupWidget();
+        slotGroupWidget.playerInventory = true;
+        slotGroupWidget.coverChildren();
+        slotGroupWidget.name("player_inventory");
+        String key = "player";
+        for (int i = 0; i < 9; i++) {
+            slotGroupWidget.child(slotConsumer.apply(i, new ItemSlot())
+                    .syncHandler(key, i)
+                    .pos(i * 18, 3 * 18 + 4)
+                    .name("slot_" + i));
+        }
+        for (int i = 0; i < 27; i++) {
+            slotGroupWidget.child(slotConsumer.apply(i + 9, new ItemSlot())
+                    .syncHandler(key, i + 9)
+                    .pos(i % 9 * 18, i / 9 * 18)
+                    .name("slot_" + (i + 9)));
+        }
+        return slotGroupWidget;
+    }
+
+    private String slotGroupName;
+    private SlotGroup slotGroup;
+    private boolean sortButtonsAdded = false;
+    private Consumer<SortButtons> sortButtonsEditor;
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        if (!this.sortButtonsAdded) {
+            SortButtons sb = new SortButtons();
+            if (this.sortButtonsEditor == null) placeSortButtonsTopRightHorizontal();
+            if (getName() != null) {
+                sb.name(getName() + "_sorter_buttons");
+            }
+            child(sb);
+        }
+    }
+
+    @Override
+    protected void onChildAdd(IWidget child) {
+        super.onChildAdd(child);
+        if (child instanceof SortButtons sortButtons) {
+            this.sortButtonsAdded = true;
+            if (sortButtons.getSlotGroup() == null && sortButtons.getSlotGroupName() == null) {
+                if (this.slotGroup != null) {
+                    sortButtons.slotGroup(this.slotGroup);
+                } else if (this.slotGroupName != null) {
+                    sortButtons.slotGroup(this.slotGroupName);
+                }
+            }
+            if (this.sortButtonsEditor != null) {
+                this.sortButtonsEditor.accept(sortButtons);
+            }
+        } else if (child instanceof ItemSlot slot && slot.isSynced() && slot.getSlot() != null) {
+            if (this.slotGroup != null) {
+                slot.getSlot().slotGroup(this.slotGroup);
+            } else if (this.slotGroupName != null) {
+                slot.getSlot().slotGroup(this.slotGroupName);
+            }
+        }
+    }
+
+    public SlotGroupWidget disableSortButtons() {
+        this.sortButtonsAdded = true;
+        return this;
+    }
+
+    public void setSlotsSynced(String name) {
+        int i = 0;
+        for (IWidget widget : getChildren()) {
+            if (widget instanceof ISynced<?> synced) {
+                synced.syncHandler(name, i);
+            }
+            i++;
+        }
+    }
+
+    public SlotGroupWidget editSortButtons(Consumer<SortButtons> sortButtonsEditor) {
+        this.sortButtonsEditor = sortButtonsEditor;
+        return this;
+    }
+
+    public SlotGroupWidget placeSortButtonsTopRightVertical() {
+        return placeSortButtonsTopRightVertical(this.sortButtonsEditor);
+    }
+
+    public SlotGroupWidget placeSortButtonsTopRightHorizontal() {
+        return placeSortButtonsTopRightHorizontal(this.sortButtonsEditor);
+    }
+
+    public SlotGroupWidget placeSortButtonsTopRightVertical(Consumer<SortButtons> additionalEdits) {
+        return editSortButtons(sb -> {
+            sb.vertical().leftRelOffset(1f, 1).top(0);
+            if (additionalEdits != null) additionalEdits.accept(sb);
+        });
+    }
+
+    public SlotGroupWidget placeSortButtonsTopRightHorizontal(Consumer<SortButtons> additionalEdits) {
+        return editSortButtons(sb -> {
+            sb.horizontal().bottomRelOffset(1f, 1).right(0);
+            if (additionalEdits != null) additionalEdits.accept(sb);
+        });
+    }
+
+    public SlotGroupWidget slotGroup(String slotGroupName) {
+        this.slotGroupName = slotGroupName;
+        return this;
+    }
+
+    public SlotGroupWidget slotGroup(SlotGroup slotGroup) {
+        this.slotGroup = slotGroup;
+        return this;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public interface SlotConsumer {
+
+        ItemSlot apply(int index, ItemSlot widgetSlot);
+    }
+
+    public static class Builder {
+
+        private String syncKey;
+        private final List<String> matrix = new ArrayList<>();
+        private final Char2ObjectMap<Object> keys = new Char2ObjectOpenHashMap<>();
+        private String slotGroupName;
+        private SlotGroup slotGroup;
+
+        private Builder() {
+            this.keys.put(' ', null);
+        }
+
+        public Builder synced(String name) {
+            this.syncKey = name;
+            return this;
+        }
+
+        public Builder matrix(String... matrix) {
+            this.matrix.clear();
+            Collections.addAll(this.matrix, matrix);
+            return this;
+        }
+
+        public Builder row(String row) {
+            this.matrix.add(row);
+            return this;
+        }
+
+        public Builder key(char c, IWidget widget) {
+            this.keys.put(c, widget);
+            return this;
+        }
+
+        public Builder key(char c, IntFunction<IWidget> widget) {
+            this.keys.put(c, widget);
+            return this;
+        }
+
+        public Builder slotGroup(String slotGroupName) {
+            this.slotGroupName = slotGroupName;
+            return this;
+        }
+
+        public Builder slotGroup(SlotGroup slotGroup) {
+            this.slotGroup = slotGroup;
+            return this;
+        }
+
+        public SlotGroupWidget build() {
+            SlotGroupWidget slotGroupWidget = new SlotGroupWidget()
+                    .slotGroup(this.slotGroupName)
+                    .slotGroup(this.slotGroup);
+            Char2IntMap charCount = new Char2IntOpenHashMap();
+            int x = 0, y = 0, maxWidth = 0;
+            int syncId = 0;
+            for (String row : this.matrix) {
+                for (int i = 0; i < row.length(); i++) {
+                    char c = row.charAt(i);
+                    int count = charCount.get(c);
+                    charCount.put(c, count + 1);
+                    Object o = this.keys.get(c);
+                    IWidget widget;
+                    if (o instanceof IWidget iWidget) {
+                        widget = iWidget;
+                        if (count > 0) {
+                            throw new IllegalArgumentException(
+                                    "A widget can only exist once in the widget tree, but the char '" + c +
+                                            "' exists more than once in this slot group widget and it has a static widget supplied.");
+                        }
+                    } else if (o instanceof IntFunction<?> function) {
+                        widget = (IWidget) function.apply(count);
+                    } else {
+                        x += 18;
+                        continue;
+                    }
+                    widget.resizer().left(x).top(y);
+                    slotGroupWidget.child(widget);
+                    if (this.syncKey != null && widget instanceof ISynced<?> synced) {
+                        synced.syncHandler(this.syncKey, syncId++);
+                    }
+                    x += 18;
+                    maxWidth = Math.max(maxWidth, x);
+                }
+                y += 18;
+                x = 0;
+            }
+            slotGroupWidget.resizer().size(maxWidth, this.matrix.size() * 18);
+            return slotGroupWidget;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SortButtons.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SortButtons.java
new file mode 100644
index 00000000000..905c872ad1d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SortButtons.java
@@ -0,0 +1,153 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import net.minecraft.world.inventory.Slot;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class SortButtons extends Widget<SortButtons> {
+
+    public static final UITexture HOVER_SORT_OVERLAY;
+    public static final UITexture HOVER_SETTINGS_OVERLAY;
+
+    static {
+        // if (GTCEu.isClientSide() /*&& ModularUI.Mods.BOGOSORTER.isLoaded()*/) {
+        // HOVER_SORT_OVERLAY = ButtonHandler.BUTTON_SORT.withColorOverride(16777120);
+        // HOVER_SETTINGS_OVERLAY = ButtonHandler.BUTTON_SETTINGS.withColorOverride(16777120);
+        // } else {
+        // any non null value
+        HOVER_SORT_OVERLAY = GTGuiTextures.BLOCK;
+        HOVER_SETTINGS_OVERLAY = GTGuiTextures.BLOCK;
+        // }
+    }
+
+    @Getter
+    private String slotGroupName;
+    @Getter
+    private SlotGroup slotGroup;
+
+    private boolean horizontal = true;
+    private final ButtonWidget<?> sortButton = new ButtonWidget<>();
+    private final ButtonWidget<?> settingsButton = new ButtonWidget<>();
+    @Getter
+    private final @NotNull List<IWidget> children = Arrays.asList(sortButton, settingsButton);
+
+    public SortButtons() {
+        if (GTCEu.isClientSide() && false /* && ModularUI.Mods.BOGOSORTER.isLoaded() */) {
+            this.sortButton.size(10).pos(0, 0)
+                    // .background(ButtonHandler.BUTTON_BACKGROUND)
+                    // .overlay(ButtonHandler.BUTTON_SORT)
+                    .hoverOverlay(HOVER_SORT_OVERLAY)
+                    .disableHoverBackground()
+                    .onMousePressed((x, y, button) -> {
+                        sort();
+                        return true;
+                    });
+            this.settingsButton.size(10)
+                    // .background(ButtonHandler.BUTTON_BACKGROUND)
+                    // .overlay(ButtonHandler.BUTTON_SETTINGS)
+                    .hoverOverlay(HOVER_SETTINGS_OVERLAY)
+                    .disableHoverBackground()
+                    .onMousePressed((x, y, button) -> {
+                        // IBogoSortAPI.getInstance().openConfigGui();
+                        return true;
+                    });
+        }
+    }
+
+    public void sort() {
+        SlotGroup slotGroup = findFirstSlotGroup();
+        if (slotGroup != null) {
+            Slot slot = slotGroup.getFirstSlotForSorting();
+            if (slot != null) {
+                // IBogoSortAPI.getInstance().sortSlotGroup(slot);
+            }
+        }
+    }
+
+    public SlotGroup findFirstSlotGroup() {
+        if (!isValid()) return null;
+        if (this.slotGroup != null) return this.slotGroup;
+        SlotGroupWidget sgw = findSlotGroupParent();
+        for (IWidget child : sgw.getChildren()) {
+            if (child instanceof ItemSlot itemSlot) {
+                SlotGroup sg = itemSlot.getSlot().getSlotGroup();
+                if (sg != null && sg.isAllowSorting()) return sg;
+            }
+        }
+        return null;
+    }
+
+    public SlotGroupWidget findSlotGroupParent() {
+        SlotGroupWidget sgw = WidgetTree.findParent(this, SlotGroupWidget.class);
+        if (sgw == null) {
+            throw new IllegalArgumentException(
+                    "If the sort buttons don't have a SlotGroupWidget above itself in the widget tree, then it needs a slot group or name specified. Both were not found.");
+        }
+        return sgw;
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        if (this.slotGroup != null || this.slotGroupName != null) {
+            this.slotGroup = getScreen().getContainer().validateSlotGroup(getPanel().getName(), this.slotGroupName,
+                    this.slotGroup);
+        }
+        if (this.horizontal) {
+            size(20, 10);
+            this.settingsButton.pos(10, 0);
+        } else {
+            size(10, 20);
+            this.settingsButton.pos(0, 10);
+        }
+    }
+
+    @Override
+    public void beforeResize(boolean onOpen) {
+        super.beforeResize(onOpen);
+        // we need to do this after init to make sure the slots are also initialized
+        if (findFirstSlotGroup() == null) {
+            // silently hide buttons if no slot group is found
+            setEnabled(false);
+        }
+    }
+
+    @Override
+    public boolean isEnabled() {
+        // TODO bogosort doesn't exist (yet), pick some other sorting mod to add compat for
+        return false; // return super.isEnabled() && false; ModularUI.isSortModLoaded();
+    }
+
+    public SortButtons slotGroup(String slotGroupName) {
+        this.slotGroupName = slotGroupName;
+        return this;
+    }
+
+    public SortButtons slotGroup(SlotGroup slotGroup) {
+        this.slotGroup = slotGroup;
+        return this;
+    }
+
+    public SortButtons horizontal() {
+        this.horizontal = true;
+        return this;
+    }
+
+    public SortButtons vertical() {
+        this.horizontal = false;
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SortableListWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SortableListWidget.java
new file mode 100644
index 00000000000..2d91b64c49d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/SortableListWidget.java
@@ -0,0 +1,254 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.animation.Animator;
+import com.gregtechceu.gtceu.api.mui.base.widget.IValueWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.ObjectList;
+import com.gregtechceu.gtceu.api.mui.widget.DraggableWidget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.LocatedWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class SortableListWidget<T> extends ListValueWidget<T, SortableListWidget.Item<T>, SortableListWidget<T>> {
+
+    private Consumer<List<T>> onChange;
+    private Consumer<Item<T>> onRemove;
+    private int timeSinceLastMove = 0;
+    private boolean scheduleAnimation = false;
+    private final ObjectList<Area> widgetAreaSnapshots = ObjectList.create();
+    private final ObjectList<Animator> animators = ObjectList.create();
+
+    public SortableListWidget() {
+        super(Item::getWidgetValue);
+        heightRel(1f);
+        // this is not desired here in favor of animations
+        collapseDisabledChild(false);
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        assignIndexes();
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        this.timeSinceLastMove++;
+    }
+
+    @Override
+    public void beforeResize(boolean onOpen) {
+        super.beforeResize(onOpen);
+        if (this.scheduleAnimation) {
+            this.widgetAreaSnapshots.clear();
+            this.widgetAreaSnapshots.size(getTypeChildren().size());
+            this.animators.size(getTypeChildren().size());
+            @UnmodifiableView
+            @NotNull
+            List<Item<T>> typeChildren = getTypeChildren();
+            for (int i = 0; i < typeChildren.size(); i++) {
+                Item<T> item = typeChildren.get(i);
+                this.widgetAreaSnapshots.set(i, item.getArea().copyOrImmutable());
+            }
+        }
+    }
+
+    @Override
+    public void postResize() {
+        super.postResize();
+        if (this.scheduleAnimation && !this.widgetAreaSnapshots.isEmpty()) {
+            @UnmodifiableView
+            @NotNull
+            List<Item<T>> typeChildren = getTypeChildren();
+            for (int i = 0; i < typeChildren.size(); i++) {
+                Item<T> item = typeChildren.get(i);
+                Animator current = this.animators.get(i);
+                if ((current != null && current.isAnimating()) ||
+                        item.getArea().shouldAnimate(this.widgetAreaSnapshots.get(i))) {
+                    if (current != null) current.stop(true);
+                    Animator animator = item.getArea().animator(this.widgetAreaSnapshots.get(i)).duration(150);
+                    this.animators.set(i, animator);
+                    animator.animate(true);
+                }
+            }
+        }
+        this.scheduleAnimation = false;
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return 80;
+    }
+
+    public void moveTo(int from, int to) {
+        if (this.timeSinceLastMove < 3) return;
+        if (from < 0 || to < 0 || from == to) {
+            GTCEu.LOGGER.error("Failed to move element from {} to {}", from, to);
+            return;
+        }
+        Item<?> child = getTypeChildren().remove(from);
+        getChildren().add(to, child);
+        assignIndexes();
+        if (isValid()) {
+            assignIndexes();
+            this.scheduleAnimation = true;
+            scheduleResize();
+        }
+        if (this.onChange != null) {
+            this.onChange.accept(getValues());
+        }
+        this.timeSinceLastMove = 0;
+    }
+
+    @Override
+    public boolean remove(int index) {
+        Item<T> widget = getTypeChildren().remove(index);
+        if (widget != null) {
+            widget.dispose();
+            assignIndexes();
+            this.scheduleAnimation = true;
+            onChildRemove(widget);
+            if (this.onChange != null) {
+                this.onChange.accept(getValues());
+            }
+            if (this.onRemove != null) {
+                this.onRemove.accept(widget);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onChildAdd(Item<T> child) {
+        if (isValid()) {
+            assignIndexes();
+            this.scheduleAnimation = true;
+            if (this.onChange != null) this.onChange.accept(getValues());
+            scheduleResize();
+        }
+    }
+
+    private void assignIndexes() {
+        List<Item<T>> children = getTypeChildren();
+        for (int i = 0; i < children.size(); i++) {
+            children.get(i).index = i;
+        }
+    }
+
+    public SortableListWidget<T> onChange(Consumer<List<T>> onChange) {
+        this.onChange = onChange;
+        return this;
+    }
+
+    public SortableListWidget<T> onRemove(Consumer<Item<T>> onRemove) {
+        this.onRemove = onRemove;
+        return this;
+    }
+
+    public static class Item<T> extends DraggableWidget<Item<T>> implements IValueWidget<T> {
+
+        private final T value;
+        private List<IWidget> children;
+        private Predicate<IWidget> dropPredicate;
+        private SortableListWidget<T> listWidget;
+        @Getter
+        private int index = -1;
+        private final int movingFrom = -1; // no usages? why added?
+
+        public Item(T value) {
+            this.value = value;
+            resizer().widthRel(1f).height(18);
+            background(GTGuiTextures.BUTTON);
+        }
+
+        @Override
+        public void onInit() {
+            super.onInit();
+            if (getParent() instanceof SortableListWidget<?> sortableListWidget) {
+                this.listWidget = (SortableListWidget<T>) sortableListWidget;
+            }
+        }
+
+        @NotNull
+        @Override
+        public List<IWidget> getChildren() {
+            return this.children != null ? this.children : Collections.emptyList();
+        }
+
+        @Override
+        public boolean canDropHere(int x, int y, @Nullable IWidget widget) {
+            return this.dropPredicate == null || this.dropPredicate.test(widget);
+        }
+
+        @Override
+        public void onDrag(int mouseButton, double timeSinceLastClick) {
+            super.onDrag(mouseButton, timeSinceLastClick);
+            for (LocatedWidget hovering : getPanel().getAllHoveringList(false)) {
+                if (hovering.getElement() instanceof SortableListWidget.Item<?> item && item != this &&
+                        item.listWidget == this.listWidget) {
+                    this.listWidget.moveTo(this.index, item.index);
+                    break;
+                }
+            }
+        }
+
+        @Override
+        public void onDragEnd(boolean successful) {}
+
+        @Override
+        public T getWidgetValue() {
+            return this.value;
+        }
+
+        public boolean removeSelfFromList() {
+            this.listWidget.remove(this.index);
+            return true;
+        }
+
+        public Item<T> child(IWidget widget) {
+            this.children = Collections.singletonList(widget);
+            if (isValid()) widget.initialise(this, true);
+            return this;
+        }
+
+        public Item<T> child(Function<Item<T>, IWidget> widgetCreator) {
+            return child(widgetCreator.apply(this));
+        }
+
+        public Item<T> dropPredicate(Predicate<IWidget> dropPredicate) {
+            this.dropPredicate = dropPredicate;
+            return this;
+        }
+
+        /*
+         * public Item<T> removeable() {
+         * this.removeButton = new ButtonWidget<>()
+         * .onMousePressed(mouseButton -> this.listWidget.remove(this.index))
+         * .background(GuiTextures.CLOSE.asIcon())
+         * .width(10).heightRel(1f)
+         * .right(0);
+         * return this;
+         * }
+         * 
+         * public Item<T> removeable(Consumer<ButtonWidget<? extends ButtonWidget<?>>> buttonBuilder) {
+         * removeable();
+         * buttonBuilder.accept(this.removeButton);
+         * return this;
+         * }
+         */
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/TextWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/TextWidget.java
new file mode 100644
index 00000000000..0409f762770
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/TextWidget.java
@@ -0,0 +1,187 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.IntSupplier;
+
+public class TextWidget<W extends TextWidget<W>> extends Widget<W> {
+
+    @Getter
+    private final IKey key;
+    @Getter
+    private Alignment alignment = Alignment.CenterLeft;
+    @Getter
+    private IntSupplier color = null;
+    @Getter
+    private Boolean shadow = null;
+    @Getter
+    private float scale = 1f;
+    private int maxWidth = -1;
+
+    private Component lastText = null;
+    private Component textForDefaultSize = null;
+
+    public TextWidget(IKey key) {
+        this.key = key;
+    }
+
+    public TextWidget(String key) {
+        this(IKey.str(key));
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        TextRenderer renderer = TextRenderer.SHARED;
+        Component text = checkString();
+        WidgetTheme theme = getActiveWidgetTheme(widgetTheme, isHovering());
+        renderer.setColor(this.color != null ? this.color.getAsInt() : theme.getTextColor());
+        renderer.setAlignment(this.alignment, getArea().paddedWidth() + this.scale, getArea().paddedHeight());
+        renderer.setShadow(this.shadow != null ? this.shadow : theme.isTextShadow());
+        renderer.setPos(getArea().getPadding().left(), getArea().getPadding().top());
+        renderer.setScale(this.scale);
+        renderer.setSimulate(false);
+        renderer.draw(context.getGraphics(), text);
+    }
+
+    protected Component checkString() {
+        Component text = this.key.getFormatted();
+        if (!Objects.equals(this.lastText, text)) {
+            onTextChanged(text);
+            this.lastText = text;
+        }
+        return text;
+    }
+
+    protected void onTextChanged(Component newText) {
+        // scheduling it would resize it on next frame, but we need it now
+        WidgetTree.resizeInternal(resizer(), false);
+    }
+
+    private TextRenderer simulate(float maxWidth) {
+        Box padding = getArea().getPadding();
+        TextRenderer renderer = TextRenderer.SHARED;
+        renderer.setAlignment(Alignment.TopLeft, maxWidth);
+        renderer.setPos(padding.left(), padding.top());
+        renderer.setScale(this.scale);
+        renderer.setSimulate(true);
+        renderer.draw(null, getComponentForDefaultSize());
+        renderer.setSimulate(false);
+        return renderer;
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        float maxWidth;
+        if (resizer().isWidthCalculated()) {
+            maxWidth = getArea().width + this.scale;
+        } else if (this.maxWidth > 0) {
+            maxWidth = Math.max(this.maxWidth, 5);
+        } else if (getParent().resizer().isWidthCalculated()) {
+            maxWidth = getParent().getArea().width + this.scale;
+        } else {
+            maxWidth = getScreen().getScreenArea().width;
+        }
+        TextRenderer renderer = simulate(maxWidth);
+        return getWidgetHeight(renderer.getLastHeight());
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        float maxWidth;
+        if (this.maxWidth > 0) {
+            maxWidth = Math.max(this.maxWidth, 5);
+        } else if (getParent().resizer().isWidthCalculated()) {
+            maxWidth = getParent().getArea().width;
+        } else {
+            maxWidth = getScreen().getScreenArea().width;
+        }
+        TextRenderer renderer = simulate(maxWidth);
+        return getWidgetWidth(renderer.getLastWidth());
+    }
+
+    protected int getWidgetWidth(float actualTextWidth) {
+        Box padding = getArea().getPadding();
+        return Math.max(1, (int) Math.ceil(actualTextWidth + padding.horizontal()));
+    }
+
+    protected int getWidgetHeight(float actualTextHeight) {
+        Box padding = getArea().getPadding();
+        return Math.max(1, (int) Math.ceil(actualTextHeight + padding.vertical()));
+    }
+
+    @Override
+    public boolean canHoverThrough() {
+        return true;
+    }
+
+    protected Component getComponentForDefaultSize() {
+        if (this.textForDefaultSize == null) {
+            this.textForDefaultSize = this.key.get();
+            this.lastText = this.textForDefaultSize;
+        }
+        return this.textForDefaultSize;
+    }
+
+    @Override
+    public void postResize() {
+        this.textForDefaultSize = null;
+    }
+
+    @Deprecated
+    public W alignment(Alignment alignment) {
+        return textAlign(alignment);
+    }
+
+    public W textAlign(Alignment alignment) {
+        this.alignment = alignment;
+        return getThis();
+    }
+
+    public W color(int color) {
+        return color(() -> color);
+    }
+
+    public W color(@Nullable IntSupplier color) {
+        this.color = color;
+        return getThis();
+    }
+
+    public W scale(float scale) {
+        this.scale = scale;
+        return getThis();
+    }
+
+    public W shadow(@Nullable Boolean shadow) {
+        this.shadow = shadow;
+        return getThis();
+    }
+
+    public W style(ChatFormatting formatting) {
+        this.key.style(formatting);
+        return getThis();
+    }
+
+    public W maxWidth(int maxWidth) {
+        this.maxWidth = maxWidth;
+        return getThis();
+    }
+
+    public Boolean isShadow() {
+        return this.getShadow();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ToggleButton.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ToggleButton.java
new file mode 100644
index 00000000000..2f9b690ee36
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ToggleButton.java
@@ -0,0 +1,117 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.value.IBoolValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.theme.SelectableTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.function.Consumer;
+
+/**
+ * A button which cycles between 2 states by clicking on it. Background, overlay and tooltip can be supplied per state.
+ * 
+ * @see CycleButtonWidget
+ */
+@Accessors(fluent = true, chain = true)
+public class ToggleButton extends AbstractCycleButtonWidget<ToggleButton> {
+
+    @Getter
+    @Setter
+    private boolean invertSelected = false;
+
+    public ToggleButton() {
+        stateCount(2);
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getToggleButtonTheme();
+    }
+
+    @Override
+    protected WidgetTheme getActiveWidgetTheme(WidgetThemeEntry<?> widgetTheme, boolean hover) {
+        SelectableTheme selectableTheme = widgetTheme.expectType(SelectableTheme.class).getTheme(hover);
+        return isValueSelected() ^ invertSelected() ? selectableTheme.getSelected() : selectableTheme;
+    }
+
+    public boolean isValueSelected() {
+        return getState() == 1;
+    }
+
+    public ToggleButton value(IBoolValue<?> boolValue) {
+        return super.value(boolValue);
+    }
+
+    public ToggleButton valueWrapped(IIntValue<?> intValue, int trueValue) {
+        return value(
+                new BoolValue.Dynamic(() -> intValue.getIntValue() == trueValue, v -> intValue.setIntValue(trueValue)));
+    }
+
+    public ToggleButton selectedBackground(IDrawable... selectedBackground) {
+        return background(true, selectedBackground);
+    }
+
+    public ToggleButton selectedHoverBackground(IDrawable... selectedHoverBackground) {
+        return hoverBackground(true, selectedHoverBackground);
+    }
+
+    @Override
+    public ToggleButton background(IDrawable... selectedBackground) {
+        return background(false, selectedBackground);
+    }
+
+    @Override
+    public ToggleButton hoverBackground(IDrawable... selectedHoverBackground) {
+        return hoverBackground(false, selectedHoverBackground);
+    }
+
+    public ToggleButton background(boolean selected, IDrawable... background) {
+        this.background = addToArray(this.background, background, selected ? 1 : 0);
+        return this;
+    }
+
+    public ToggleButton overlay(boolean selected, IDrawable... overlay) {
+        this.overlay = addToArray(this.overlay, overlay, selected ? 1 : 0);
+        return this;
+    }
+
+    public ToggleButton hoverBackground(boolean selected, IDrawable... background) {
+        this.hoverBackground = addToArray(this.hoverBackground, background, selected ? 1 : 0);
+        return this;
+    }
+
+    public ToggleButton hoverOverlay(boolean selected, IDrawable... overlay) {
+        this.hoverOverlay = addToArray(this.hoverOverlay, overlay, selected ? 1 : 0);
+        return this;
+    }
+
+    public ToggleButton addTooltip(boolean selected, String tooltip) {
+        return super.addTooltip(selected ? 1 : 0, tooltip);
+    }
+
+    public ToggleButton addTooltip(boolean selected, IDrawable tooltip) {
+        return super.addTooltip(selected ? 1 : 0, tooltip);
+    }
+
+    public ToggleButton tooltip(boolean selected, Consumer<RichTooltip> builder) {
+        return super.tooltip(selected ? 1 : 0, builder);
+    }
+
+    public ToggleButton tooltipBuilder(boolean selected, Consumer<RichTooltip> builder) {
+        return super.tooltipBuilder(selected ? 1 : 0, builder);
+    }
+
+    public ToggleButton child(boolean selected, IWidget widget) {
+        return stateChild(selected ? 1 : 0, widget);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/TransformWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/TransformWidget.java
new file mode 100644
index 00000000000..f5a8bc51ecf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/TransformWidget.java
@@ -0,0 +1,58 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.DelegatingWidget;
+
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+import java.util.function.Consumer;
+
+public class TransformWidget extends DelegatingWidget {
+
+    private static final Vector3f sharedVec = new Vector3f();
+
+    private final Matrix4f constTransform = new Matrix4f();
+    private boolean hasConstTransform = false;
+    private Consumer<IViewportStack> transform;
+
+    public TransformWidget(IWidget child) {
+        super(child);
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        super.transform(stack);
+        if (this.hasConstTransform) stack.multiply(this.constTransform);
+        if (this.transform != null) this.transform.accept(stack);
+    }
+
+    public TransformWidget transform(Consumer<IViewportStack> transform) {
+        this.transform = transform;
+        return this;
+    }
+
+    public TransformWidget translate(float x, float y) {
+        this.hasConstTransform = true;
+        this.constTransform.translate(x, y, 0);
+        return this;
+    }
+
+    public TransformWidget rotate(float angle, float x, float y, float z) {
+        this.hasConstTransform = true;
+        this.constTransform.rotate(angle, vec(x, y, z));
+        return this;
+    }
+
+    public TransformWidget scale(float x, float y) {
+        this.hasConstTransform = true;
+        this.constTransform.scale(vec(x, y, 1));
+        return this;
+    }
+
+    private static Vector3f vec(float x, float y, float z) {
+        sharedVec.set(x, y, z);
+        return sharedVec;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ValueWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ValueWidget.java
new file mode 100644
index 00000000000..4d04c63aa96
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/ValueWidget.java
@@ -0,0 +1,16 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IValueWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+
+import lombok.Getter;
+
+public class ValueWidget<W extends ValueWidget<W, T>, T> extends Widget<W> implements IValueWidget<T> {
+
+    @Getter
+    private final T widgetValue;
+
+    public ValueWidget(T widgetValue) {
+        this.widgetValue = widgetValue;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/VoidWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/VoidWidget.java
new file mode 100644
index 00000000000..45b485069e4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/VoidWidget.java
@@ -0,0 +1,10 @@
+package com.gregtechceu.gtceu.api.mui.widgets;
+
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+
+public class VoidWidget extends EmptyWidget {
+
+    private VoidWidget() {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Column.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Column.java
new file mode 100644
index 00000000000..6f964456e75
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Column.java
@@ -0,0 +1,14 @@
+package com.gregtechceu.gtceu.api.mui.widgets.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+/**
+ * @deprecated use Flow.column() or Flow.col() instead
+ */
+@Deprecated
+public class Column extends Flow {
+
+    public Column() {
+        super(GuiAxis.Y);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Flow.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Flow.java
new file mode 100644
index 00000000000..cd911e41580
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Flow.java
@@ -0,0 +1,405 @@
+package com.gregtechceu.gtceu.api.mui.widgets.layout;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.layout.ILayoutWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.ExpanderResizer;
+import com.gregtechceu.gtceu.utils.ReversedList;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+
+@Accessors(fluent = true, chain = true)
+public class Flow extends ParentWidget<Flow> implements ILayoutWidget {
+
+    public static Flow row() {
+        return new Flow(GuiAxis.X);
+    }
+
+    public static Flow column() {
+        return new Flow(GuiAxis.Y);
+    }
+
+    public static Flow col() {
+        return new Flow(GuiAxis.Y);
+    }
+
+    /**
+     * The main axis on which to align children.
+     */
+    @Getter
+    private final GuiAxis axis;
+    /**
+     * How the children should be laid out on the main axis.
+     */
+    private Alignment.MainAxis mainAxisAlignment = Alignment.MainAxis.START;
+    /**
+     * How the children should be laid out on the cross axis.
+     */
+    private Alignment.CrossAxis crossAxisAlignment = Alignment.CrossAxis.CENTER;
+    /**
+     * Additional space between each child on main axis.
+     * Does not work with {@link Alignment.MainAxis#SPACE_BETWEEN} and {@link Alignment.MainAxis#SPACE_AROUND}.
+     */
+    @Setter
+    private int childPadding = 0;
+    private int crossAxisChildPadding = 0;
+    /**
+     * Whether disabled child widgets should be collapsed for display.
+     */
+    private boolean collapseDisabledChild = false;
+    /**
+     * Whether the children list should be laid out in reverse order
+     */
+    private boolean reverseLayout = false;
+
+    private boolean wrap = false;
+    private final List<IWidget> ignoredWidgets = new ArrayList<>();
+    private final List<SimpleFlow> layoutWidgets = new ArrayList<>();
+
+    public Flow(GuiAxis axis) {
+        this.axis = axis;
+        resizer(new ExpanderResizer(this, axis));
+        sizeRel(1f, 1f);
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        return this.axis.isHorizontal() ? getDefaultMainAxisSize() : getDefaultCrossAxisSize();
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        return this.axis.isHorizontal() ? getDefaultCrossAxisSize() : getDefaultMainAxisSize();
+    }
+
+    public int getDefaultMainAxisSize() {
+        if (!hasChildren()) return 18;
+        GuiAxis axis = this.axis;
+        int total = getArea().getPadding().getTotal(axis);
+        for (IWidget widget : getChildren()) {
+            if (shouldIgnoreChildSize(widget) || widget.resizer().hasPos(axis)) continue;
+            if (widget.resizer().isExpanded() || !widget.resizer().isSizeCalculated(axis)) {
+                total += axis.isHorizontal() ? widget.getDefaultWidth() : widget.getDefaultHeight();
+            } else {
+                total += widget.getArea().getSize(axis);
+            }
+            total += widget.getArea().getMargin().getTotal(axis);
+        }
+        return total;
+    }
+
+    public int getDefaultCrossAxisSize() {
+        if (!hasChildren()) return 18;
+        GuiAxis axis = this.axis.getOther();
+        int max = 0;
+        for (IWidget widget : getChildren()) {
+            if (shouldIgnoreChildSize(widget)) continue;
+            int s = widget.getArea().getMargin().getTotal(axis);
+            if (!widget.resizer().isSizeCalculated(axis)) {
+                s += axis.isHorizontal() ? widget.getDefaultWidth() : widget.getDefaultHeight();
+            } else {
+                s += widget.getArea().getSize(axis);
+            }
+            max = Math.max(max, s);
+        }
+        return max + getArea().getPadding().getTotal(axis);
+    }
+
+    private boolean buildWrappedFlows(List<IWidget> children, int size, boolean wrap) {
+        this.layoutWidgets.clear();
+        this.ignoredWidgets.clear();
+        SimpleFlow currentFlow = new SimpleFlow();
+        for (IWidget widget : children) {
+            // ignore disabled child if configured as such and
+            // exclude children whose position of main axis is fixed
+            if (shouldIgnoreChildSize(widget) || widget.resizer().hasPos(this.axis)) {
+                this.ignoredWidgets.add(widget);
+                continue;
+            }
+            boolean isEmpty = currentFlow.widgets.isEmpty();
+            if (widget.resizer().isExpanded()) {
+                currentFlow.expanderCount++;
+                // expanded widget size will be calculated later, but we still need to consider its margin
+                currentFlow.size += widget.getArea().getMargin().getTotal(this.axis);
+                if (!isEmpty) currentFlow.size += this.childPadding;
+                currentFlow.widgets.add(widget);
+                if (wrap) {
+                    // if wrapping is enabled, then create a new row/col after every expanded
+                    // TODO: is this desirable?
+                    this.layoutWidgets.add(currentFlow);
+                    currentFlow = new SimpleFlow();
+                }
+                continue;
+            }
+            // if the size of a widget is not calculated we can't continue
+            if (!widget.resizer().isSizeCalculated(this.axis)) return false;
+            int s = widget.getArea().requestedSize(this.axis);
+            if (!isEmpty) s += this.childPadding;
+            if (wrap && !isEmpty && currentFlow.size + s > size) {
+                // test if the widget with padding fits and create a new row/col if not
+                this.layoutWidgets.add(currentFlow);
+                currentFlow = new SimpleFlow();
+                s -= this.childPadding;
+            }
+            currentFlow.size += s;
+            currentFlow.widgets.add(widget);
+        }
+        if (!currentFlow.widgets.isEmpty()) this.layoutWidgets.add(currentFlow);
+        return true;
+    }
+
+    @Override
+    public boolean layoutWidgets() {
+        if (!hasChildren()) return true;
+        final boolean coverChildren = resizer().dependsOnChildren(this.axis);
+        boolean wrap = this.wrap;
+        if (coverChildren && wrap) {
+            GTCEu.LOGGER.warn(
+                    "Flow can't coverChildren along its main axis and wrap at the same time. Offending widget: {}",
+                    this);
+            wrap = false;
+        }
+        final boolean hasSize = resizer().isSizeCalculated(this.axis);
+        Alignment.MainAxis maa = this.mainAxisAlignment;
+        if (!hasSize) {
+            if (wrap) {
+                return false;
+            }
+            if (maa != Alignment.MainAxis.START) {
+                if (resizer().dependsOnChildren(this.axis)) {
+                    // if this flow covers the children, we can assume start
+                    maa = Alignment.MainAxis.START;
+                } else {
+                    // for anything else than start we need the size to be known
+                    return false;
+                }
+            }
+        }
+
+        final Box padding = getArea().getPadding();
+        final int size = hasSize ? getArea().paddedSize(this.axis) : 0;
+        List<IWidget> childrenList = this.reverseLayout ? new ReversedList<>(getChildren()) : getChildren();
+
+        if (!buildWrappedFlows(childrenList, size, wrap)) return false;
+        for (SimpleFlow flow : this.layoutWidgets) {
+            flow.layout(this.axis, size, padding, maa, this.childPadding);
+        }
+        for (IWidget widget : this.ignoredWidgets) {
+            // ignore disabled child if configured as such
+            if (shouldIgnoreChildSize(widget)) {
+                widget.resizer().updateResized();
+                widget.resizer().setMarginPaddingApplied(true);
+                continue;
+            }
+            // exclude children whose position of main axis is fixed
+            if (widget.resizer().hasPos(this.axis)) {
+                // this is required when the widget has a pos on the main axis, but not on the cross axis
+                widget.resizer().updateResized();
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean postLayoutWidgets() {
+        return layoutCrossAxisListLike(this, this.layoutWidgets, this.axis, this.crossAxisAlignment,
+                this.crossAxisChildPadding);
+    }
+
+    public static boolean layoutCrossAxisListLike(IWidget parent, List<SimpleFlow> flows, GuiAxis axis,
+                                                  Alignment.CrossAxis crossAxisAlignment, int crossAxisSpaceBetween) {
+        if (flows.isEmpty()) return true;
+        GuiAxis other = axis.getOther();
+        boolean isWrapped = flows.size() > 1;
+        // padding is applied in layoutCrossAxis()
+        int availableSize = parent.resizer().isSizeCalculated(other) ? parent.getArea().getSize(other) : -1;
+        Box padding = parent.getArea().getPadding();
+        if (!isWrapped) {
+            // simplified logic for non-wrapped
+            flows.get(0).calculateCrossAxisSize(axis);
+            // starting pos is 0 and use parents padding
+            return flows.get(0).layoutCrossAxis(parent, axis, crossAxisAlignment, availableSize, 0, padding);
+        }
+        if (parent.resizer().dependsOnChildren(other)) {
+            // when covering children we can assume START
+            crossAxisAlignment = Alignment.CrossAxis.START;
+        }
+        if (crossAxisAlignment != Alignment.CrossAxis.START && !parent.resizer().isSizeCalculated(other)) return false;
+        int total = (flows.size() - 1) * crossAxisSpaceBetween; // start with cross axis child padding for total size
+        for (SimpleFlow flow : flows) {
+            flow.calculateCrossAxisSize(axis);
+            total += flow.crossSize;
+        }
+        // calculate starting pos
+        // TODO center padding
+        int p = parent.getArea().getPadding().getStart(other);
+        if (crossAxisAlignment == Alignment.CrossAxis.END) {
+            p = availableSize - total - parent.getArea().getMargin().getEnd(other);
+        } else if (crossAxisAlignment == Alignment.CrossAxis.CENTER) {
+            p = (availableSize - total) / 2;
+        }
+        crossAxisAlignment = Alignment.CrossAxis.CENTER;
+
+        for (SimpleFlow flow : flows) {
+            // use calculated pos and ignore parent padding
+            if (!flow.layoutCrossAxis(parent, axis, crossAxisAlignment, flow.crossSize, p, Box.ZERO)) return false;
+            p += flow.crossSize + crossAxisSpaceBetween;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canCoverByDefaultSize(GuiAxis axis) {
+        return axis.getOther() == this.axis;
+    }
+
+    @Override
+    public boolean shouldIgnoreChildSize(IWidget child) {
+        return this.collapseDisabledChild && !child.isEnabled();
+    }
+
+    @Override
+    public void onChildChangeEnabled(IWidget child, boolean enabled) {
+        if (this.collapseDisabledChild) {
+            ILayoutWidget.super.onChildChangeEnabled(child, enabled);
+        }
+    }
+
+    public Flow children(Iterable<IWidget> widgets) {
+        for (IWidget widget : widgets) {
+            child(widget);
+        }
+        return getThis();
+    }
+
+    public Flow children(int amount, IntFunction<IWidget> widgetCreator) {
+        for (int i = 0; i < amount; i++) {
+            child(widgetCreator.apply(i));
+        }
+        return getThis();
+    }
+
+    public <T> Flow children(Iterable<T> it, Function<T, IWidget> widgetCreator) {
+        for (T t : it) {
+            child(widgetCreator.apply(t));
+        }
+        return getThis();
+    }
+
+    /**
+     * Sets the main axis alignment of this flow. This determines how multiple widgets are laid out along the main axis
+     * in this flow.
+     *
+     * @param maa main axis alignment
+     * @return this
+     * @see com.gregtechceu.gtceu.api.mui.utils.Alignment.MainAxis
+     */
+    public Flow mainAxisAlignment(Alignment.MainAxis maa) {
+        this.mainAxisAlignment = maa;
+        return this;
+    }
+
+    /**
+     * Sets the cross axis alignment of this flow. This determines how multiple widgets are laid out along the cross
+     * axis in this flow.
+     *
+     * @param caa cross axis alignment
+     * @return this
+     * @see com.gregtechceu.gtceu.api.mui.utils.Alignment.CrossAxis
+     */
+    public Flow crossAxisAlignment(Alignment.CrossAxis caa) {
+        this.crossAxisAlignment = caa;
+        return this;
+    }
+
+    /**
+     * Sets a fixed pixel size padding between all children widgets.
+     *
+     * @param spaceBetween pixel size padding between children
+     * @return this
+     */
+
+    /**
+     * Sets if disabled children should be collapsed.
+     */
+    public Flow collapseDisabledChild() {
+        this.collapseDisabledChild = true;
+        return this;
+    }
+
+    /**
+     * Sets if disabled children should be collapsed. This means that if a child changes enabled state, this widget
+     * gets notified and re-layouts its children. Children which are disabled will not be considered during layout,
+     * so that the flow will not appear to have empty spots. This is disabled by default on Flow.
+     *
+     * @param collapse true if disabled children should be collapsed.
+     * @return this
+     */
+    public Flow collapseDisabledChild(boolean collapse) {
+        this.collapseDisabledChild = collapse;
+        return this;
+    }
+
+    /**
+     * Sets if the children list should be laid out in reversed or not (Default is false).
+     * 
+     * @param reverseLayout true if the children list should be laid out in reverse
+     * @return this
+     */
+    public Flow reverseLayout(boolean reverseLayout) {
+        this.reverseLayout = reverseLayout;
+        return this;
+    }
+
+    public Flow reverseLayout() {
+        return reverseLayout(true);
+    }
+
+    /**
+     * This causes the Flow to create multiple rows/columns when widgets overflow the main axis size.
+     * This my causes some unexpected behavior in layout. This feature is experimental.
+     *
+     * @param wrap if overflowing widgets should be wrapped to a next row/column
+     * @return this
+     */
+    @ApiStatus.Experimental
+    public Flow wrap(boolean wrap) {
+        this.wrap = wrap;
+        return this;
+    }
+
+    @ApiStatus.Experimental
+    public Flow wrap() {
+        return wrap(true);
+    }
+
+    /**
+     * Sets the cross axis child padding. It is a fixed pixel size between rows/columnd.
+     * This only used if {@link #wrap()} is used.
+     *
+     * @param crossAxisChildPadding pixel space between rows/columns when wrapping is active
+     * @return this
+     */
+    @ApiStatus.Experimental
+    public Flow crossAxisChildPadding(int crossAxisChildPadding) {
+        this.crossAxisChildPadding = crossAxisChildPadding;
+        return this;
+    }
+
+    @Override
+    protected String getTypeName() {
+        return this.axis.isHorizontal() ? "Row" : "Column";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Grid.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Grid.java
new file mode 100644
index 00000000000..2a1e52b46d9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Grid.java
@@ -0,0 +1,328 @@
+package com.gregtechceu.gtceu.api.mui.widgets.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.ILayoutWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IParentWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.AbstractScrollWidget;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.HorizontalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.ints.IntList;
+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.Objects;
+import java.util.function.IntFunction;
+
+public class Grid extends AbstractScrollWidget<IWidget, Grid> implements ILayoutWidget, IParentWidget<IWidget, Grid> {
+
+    private final List<List<IWidget>> matrix = new ArrayList<>();
+    private final Box minElementMargin = new Box();
+    private int minRowHeight = 5, minColWidth = 5;
+    private Alignment alignment = Alignment.Center;
+    private boolean dirty = false;
+    private boolean collapseDisabledChild = false;
+
+    public Grid() {
+        super(null, null);
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        int maxRowSize = 0;
+        for (List<? extends IWidget> row : this.matrix) {
+            maxRowSize = Math.max(maxRowSize, row.size());
+        }
+        for (List<? extends IWidget> row : this.matrix) {
+            while (row.size() < maxRowSize) {
+                row.add(null);
+            }
+        }
+    }
+
+    private int getElementWidth(Area area) {
+        return area.width + Math.max(area.getMargin().left(), this.minElementMargin.left()) +
+                Math.max(area.getMargin().right(), this.minElementMargin.right());
+    }
+
+    private int getElementHeight(Area area) {
+        return area.height + Math.max(area.getMargin().top(), this.minElementMargin.top()) +
+                Math.max(area.getMargin().bottom(), this.minElementMargin.bottom());
+    }
+
+    @Override
+    public boolean layoutWidgets() {
+        IntList rowSizes = new IntArrayList();
+        IntList colSizes = new IntArrayList();
+
+        int i = 0, j;
+        for (List<IWidget> row : this.matrix) {
+            j = 0;
+            rowSizes.add(this.minRowHeight);
+            for (IWidget child : row) {
+                if (i == 0) {
+                    colSizes.add(this.minColWidth);
+                }
+                if (!shouldIgnoreChildSize(child)) {
+                    if (!child.resizer().isWidthCalculated() || !child.resizer().isHeightCalculated()) return false;
+                    rowSizes.set(i, Math.max(rowSizes.getInt(i), getElementHeight(child.getArea())));
+                    colSizes.set(j, Math.max(colSizes.getInt(j), getElementWidth(child.getArea())));
+                }
+                j++;
+            }
+            i++;
+        }
+
+        int x = 0, y = 0;
+        for (int r = 0; r < rowSizes.size(); r++) {
+            x = 0;
+            int height = rowSizes.getInt(r);
+            for (int c = 0; c < colSizes.size(); c++) {
+                int width = colSizes.getInt(c);
+                IWidget child = this.matrix.get(r).get(c);
+                if (child != null) {
+                    child.getArea().rx = (int) (x + (width - child.getArea().width) * alignment.x);
+                    child.getArea().ry = (int) (y + (height - child.getArea().height) * alignment.y);
+                    child.resizer().setPosResized(true, true);
+                }
+                x += width;
+            }
+            y += height;
+        }
+        if (getScrollArea().getScrollX() != null) {
+            getScrollArea().getScrollX().setScrollSize(x);
+        }
+        if (getScrollArea().getScrollY() != null) {
+            getScrollArea().getScrollY().setScrollSize(y);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean shouldIgnoreChildSize(IWidget child) {
+        return child == null || (this.collapseDisabledChild && !child.isEnabled());
+    }
+
+    @Override
+    public @NotNull List<IWidget> getChildren() {
+        if (this.dirty) {
+            makeFlatList();
+            this.dirty = false;
+        }
+        return super.getChildren();
+    }
+
+    private void makeFlatList() {
+        super.getChildren().clear();
+        super.getChildren().addAll(this.matrix.stream().flatMap(List::stream).filter(Objects::nonNull).toList());
+    }
+
+    @Override
+    public int getDefaultHeight() {
+        int h = 0;
+        for (List<IWidget> row : this.matrix) {
+            int rowHeight = 0;
+            for (IWidget child : row) {
+                if (!shouldIgnoreChildSize(child)) {
+                    rowHeight = Math.max(rowHeight, getElementHeight(child.getArea()));
+                }
+            }
+            h += Math.max(rowHeight, this.minRowHeight);
+        }
+        return h;
+    }
+
+    @Override
+    public int getDefaultWidth() {
+        IntList colSizes = new IntArrayList();
+        int i = 0, j;
+        for (List<? extends IWidget> row : this.matrix) {
+            j = 0;
+            for (IWidget child : row) {
+                if (i == 0) {
+                    colSizes.add(this.minColWidth);
+                }
+                if (!shouldIgnoreChildSize(child)) {
+                    colSizes.set(j, Math.max(colSizes.getInt(j), getElementWidth(child.getArea())));
+                }
+                j++;
+            }
+            i++;
+        }
+        int w = 0;
+        for (int colWidth : colSizes) {
+            w += colWidth;
+        }
+        return w;
+    }
+
+    public <I extends IWidget> Grid matrix(List<List<I>> matrix) {
+        this.matrix.clear();
+        for (List<I> row : matrix) {
+            this.matrix.add((List<IWidget>) row);
+        }
+        this.dirty = true;
+        return this;
+    }
+
+    public Grid row(List<IWidget> row) {
+        this.matrix.add(row);
+        this.dirty = true;
+        return this;
+    }
+
+    public Grid row(@NotNull IWidget... row) {
+        Objects.requireNonNull(row);
+        return row(new ArrayList<>(Arrays.asList(row)));
+    }
+
+    @Override
+    public boolean addChild(IWidget child, int index) {
+        if (child == this || getChildren().contains(child)) {
+            return false;
+        }
+        if (index < 0) {
+            index = getChildren().size() + index + 1;
+        }
+        super.getChildren().add(index, child);
+        if (isValid()) {
+            child.initialise(this, true);
+        }
+        onChildAdd(child);
+        this.dirty = true;
+        return true;
+    }
+
+    public Grid child(@Nullable IWidget widget) {
+        this.matrix.get(this.matrix.size() - 1).add(widget);
+        this.dirty = true;
+        return this;
+    }
+
+    public Grid nextRow() {
+        this.matrix.add(new ArrayList<>());
+        return this;
+    }
+
+    public <T, I extends IWidget> Grid mapTo(int rowLength, @NotNull List<T> list,
+                                             @NotNull IndexedElementMapper<T, I> widgetCreator) {
+        Objects.requireNonNull(widgetCreator);
+        Objects.requireNonNull(list);
+        return matrix(mapToMatrix(rowLength, list, widgetCreator));
+    }
+
+    public <I extends IWidget> Grid mapTo(int rowLength, @NotNull List<I> list) {
+        Objects.requireNonNull(list);
+        return mapTo(rowLength, list.size(), list::get);
+    }
+
+    public <I extends IWidget> Grid mapTo(int rowLength, int size, @NotNull IntFunction<I> widgetCreator) {
+        Objects.requireNonNull(widgetCreator);
+        return matrix(mapToMatrix(rowLength, size, widgetCreator));
+    }
+
+    public Grid minColWidth(int minColWidth) {
+        this.minColWidth = minColWidth;
+        return this;
+    }
+
+    public Grid minRowHeight(int minRowHeight) {
+        this.minRowHeight = minRowHeight;
+        return this;
+    }
+
+    public Grid alignment(Alignment alignment) {
+        this.alignment = alignment;
+        return this;
+    }
+
+    public Grid scrollable() {
+        return scrollable(new VerticalScrollData(), new HorizontalScrollData());
+    }
+
+    public Grid scrollable(ScrollData data) {
+        getScrollArea().setScrollData(data);
+        return this;
+    }
+
+    public Grid scrollable(VerticalScrollData data1, HorizontalScrollData data2) {
+        getScrollArea().setScrollData(data1);
+        getScrollArea().setScrollData(data2);
+        return this;
+    }
+
+    public Grid minElementMargin(int left, int right, int top, int bottom) {
+        this.minElementMargin.all(left, right, top, bottom);
+        return getThis();
+    }
+
+    public Grid minElementMargin(int horizontal, int vertical) {
+        this.minElementMargin.all(horizontal, vertical);
+        return getThis();
+    }
+
+    public Grid minElementMargin(int all) {
+        this.minElementMargin.all(all);
+        return getThis();
+    }
+
+    public Grid minElementMarginLeft(int val) {
+        this.minElementMargin.left(val);
+        return getThis();
+    }
+
+    public Grid minElementMarginRight(int val) {
+        this.minElementMargin.right(val);
+        return getThis();
+    }
+
+    public Grid minElementMarginTop(int val) {
+        this.minElementMargin.top(val);
+        return getThis();
+    }
+
+    public Grid minElementMarginBottom(int val) {
+        this.minElementMargin.bottom(val);
+        return getThis();
+    }
+
+    /**
+     * Configures this widget to collapse row/column if all the child widgets in that axis are disabled.
+     */
+    public Grid collapseDisabledChild() {
+        this.collapseDisabledChild = true;
+        return getThis();
+    }
+
+    public static <T, I extends IWidget> List<List<I>> mapToMatrix(int rowLength, List<T> list,
+                                                                   IndexedElementMapper<T, I> widgetCreator) {
+        return mapToMatrix(rowLength, list.size(), i -> widgetCreator.apply(i, list.get(i)));
+    }
+
+    public static <I extends IWidget> List<List<I>> mapToMatrix(int rowLength, int size, IntFunction<I> widgetCreator) {
+        List<List<I>> matrix = new ArrayList<>();
+        for (int i = 0; i < size; i++) {
+            int r = i / rowLength;
+
+            if (r == matrix.size())
+                matrix.add(new ArrayList<>());
+
+            matrix.get(r).add(widgetCreator.apply(i));
+        }
+        return matrix;
+    }
+
+    public interface IndexedElementMapper<T, I> {
+
+        I apply(int index, T value);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/IExpander.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/IExpander.java
new file mode 100644
index 00000000000..a43aa2604ad
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/IExpander.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.mui.widgets.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+public interface IExpander {
+
+    GuiAxis getExpandAxis();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Row.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Row.java
new file mode 100644
index 00000000000..68434c63737
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/Row.java
@@ -0,0 +1,14 @@
+package com.gregtechceu.gtceu.api.mui.widgets.layout;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+
+/**
+ * @deprecated use Flow.row() instead
+ */
+@Deprecated
+public class Row extends Flow {
+
+    public Row() {
+        super(GuiAxis.X);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/SimpleFlow.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/SimpleFlow.java
new file mode 100644
index 00000000000..675dd6c4a4a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/layout/SimpleFlow.java
@@ -0,0 +1,128 @@
+package com.gregtechceu.gtceu.api.mui.widgets.layout;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SimpleFlow {
+
+    public final List<IWidget> widgets = new ArrayList<>();
+    public int size, expanderCount, crossSize;
+    public boolean crossSizeCalculated;
+
+    public void layout(GuiAxis axis, int availableSize, Box padding, Alignment.MainAxis maa, int childPadding) {
+        int amount = widgets.size();
+        // special cases
+        if (expanderCount > 0) {
+            maa = Alignment.MainAxis.START;
+        } else if (amount <= 1 && (maa == Alignment.MainAxis.SPACE_BETWEEN || maa == Alignment.MainAxis.SPACE_AROUND)) {
+            maa = Alignment.MainAxis.CENTER;
+        }
+
+        // calculate space between children
+        int space = childPadding;
+        if (maa == Alignment.MainAxis.SPACE_BETWEEN || maa == Alignment.MainAxis.SPACE_AROUND) {
+            if (maa == Alignment.MainAxis.SPACE_BETWEEN) {
+                space = (availableSize - size) / (amount - 1);
+            } else {
+                space = (availableSize - size) / amount;
+            }
+        }
+
+        // calculate size of expanded
+        if (expanderCount > 0 && availableSize > 0) {
+            int newSize = (availableSize - size) / expanderCount;
+            for (IWidget widget : widgets) {
+                if (widget.resizer().isExpanded()) {
+                    widget.getArea().setSize(axis, newSize);
+                    widget.resizer().setSizeResized(axis, true);
+                }
+            }
+        }
+
+        // calculate start pos
+        int lastP = padding.getStart(axis);
+        if (availableSize > 0) {
+            if (maa == Alignment.MainAxis.CENTER) {
+                lastP += (int) (availableSize / 2f - size / 2f);
+            } else if (maa == Alignment.MainAxis.END) {
+                lastP += availableSize - size;
+            } else if (maa == Alignment.MainAxis.SPACE_AROUND) {
+                lastP += space / 2;
+            }
+        }
+
+        // apply pos
+        for (IWidget widget : widgets) {
+            Box margin = widget.getArea().getMargin();
+            // set calculated relative main axis pos and set end margin for next widget
+            widget.getArea().setRelativePoint(axis, lastP + margin.getStart(axis));
+            widget.resizer().setPosResized(axis, true);
+            widget.resizer().setMarginPaddingApplied(axis, true);
+            lastP += widget.getArea().requestedSize(axis) + space;
+        }
+    }
+
+    public void calculateCrossAxisSize(GuiAxis axis) {
+        // calculates maximum size along the cross axis
+        GuiAxis other = axis.getOther();
+        if (!this.crossSizeCalculated) {
+            this.crossSizeCalculated = true;
+            this.crossSize = 0;
+            for (IWidget widget : widgets) {
+                // exclude children whose position of main axis or cross axis is fixed
+                if (widget.resizer().hasXPos() || widget.resizer().hasYPos()) continue;
+                if (!widget.resizer().isSizeCalculated(other)) {
+                    this.crossSizeCalculated = false;
+                    continue;
+                }
+                this.crossSize = Math.max(widget.getArea().requestedSize(other), this.crossSize);
+            }
+        }
+    }
+
+    public boolean layoutCrossAxis(IWidget parent, GuiAxis axis, Alignment.CrossAxis caa, int availableSize, int p,
+                                   Box padding) {
+        GuiAxis other = axis.getOther();
+        if (availableSize < 0 && caa != Alignment.CrossAxis.START) return false;
+        for (IWidget widget : this.widgets) {
+            // exclude children whose position of main axis is fixed
+            if (widget.resizer().hasPos(axis)) continue;
+            Box margin = widget.getArea().getMargin();
+            // don't align auto positioned children in cross axis
+            if (!widget.resizer().hasPos(other) && widget.resizer().isSizeCalculated(other)) {
+                int start = margin.getStart(other) + padding.getStart(other);
+                int crossAxisPos = 0;
+                if (caa == Alignment.CrossAxis.START) {
+                    crossAxisPos = start;
+                } else {
+                    int end = margin.getEnd(other) + padding.getEnd(other);
+                    int s = widget.getArea().getSize(other);
+                    if (caa == Alignment.CrossAxis.END) {
+                        crossAxisPos = availableSize - s - end;
+                    } else if (caa == Alignment.CrossAxis.CENTER) {
+                        crossAxisPos = (int) (availableSize / 2f - widget.getArea().getSize(other) / 2f);
+                        if (availableSize < s + start + end) {
+                            GTCEu.LOGGER.warn(
+                                    "Widget {} is larger with padding on axis {} than parent {}. Padding can't be applied correctly!",
+                                    widget, other, parent);
+                        } else {
+                            if (crossAxisPos < start) crossAxisPos = start;
+                            else if (crossAxisPos > availableSize - end - s) crossAxisPos = availableSize - end - s;
+                        }
+                    }
+                }
+                widget.getArea().setRelativePoint(other, crossAxisPos + p);
+                widget.getArea().setPoint(other, parent.getArea().getPoint(other) + crossAxisPos + p);
+                widget.resizer().setPosResized(other, true);
+                widget.resizer().setMarginPaddingApplied(other, true);
+            }
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/AbstractMenuButton.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/AbstractMenuButton.java
new file mode 100644
index 00000000000..79122c2ff75
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/AbstractMenuButton.java
@@ -0,0 +1,234 @@
+package com.gregtechceu.gtceu.api.mui.widgets.menu;
+
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.StandardResizer;
+
+import net.minecraft.ChatFormatting;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * This is the base class for a button that can open a floating widget by clicking or hovering the button. In ModularUI
+ * this is used for
+ * context menus and dropdown menus. When the menu is opened a new panel is created and the {@link Menu} widget is
+ * added. If that menu
+ * contains another one of these menu buttons, it will be added to that panel.
+ *
+ * @param <W> type of this widget
+ */
+public abstract class AbstractMenuButton<W extends AbstractMenuButton<W>> extends Widget<W>
+                                        implements IMenuPart, Interactable {
+
+    /**
+     * The general direction where the menu will be opened. This is just a shortcut to standard resizer calls.
+     * If this is null you can customize the position yourself.
+     */
+    protected Direction direction = Direction.DOWN;
+    /**
+     * If this is true, the menu can be opened when the mouse hovers this button. The menu will automatically close,
+     * when the button AND
+     * all widgets in the menus tree are no longer hovered.
+     */
+    protected boolean openOnHover = true;
+
+    /**
+     * The current menu widget. The menu will be created with {@link #createMenu()} if the menu is null when it's
+     * needed. If the method
+     * also returns a null value, a default menu is created. The menu can be set at any time with
+     * {@link #setMenu(Menu)}.
+     */
+    private Menu<?> menu;
+    /**
+     * @return true if the menu is currently open (soft or hard)
+     */
+    @Getter
+    private boolean open;
+    private boolean softOpen; // state, soft means opened by hovering
+    private IPanelHandler panelHandler;
+    private final String panelName;
+
+    /**
+     * @param panelName the name for the panel that may be created when opening the menu
+     */
+    public AbstractMenuButton(String panelName) {
+        this.panelName = Objects.requireNonNull(panelName);
+        name(panelName);
+    }
+
+    /**
+     * @return true if the menu is currently soft open (opened by hovering)
+     */
+    public boolean isSoftOpen() {
+        return softOpen;
+    }
+
+    public void toggleMenu(boolean soft) {
+        if (this.open) {
+            if (this.softOpen) {
+                if (soft) {
+                    closeMenu(true);
+                } else {
+                    this.softOpen = false;
+                }
+            } else if (!soft) {
+                if (this.openOnHover) {
+                    this.softOpen = true;
+                } else {
+                    closeMenu(false);
+                }
+            }
+        } else {
+            openMenu(soft);
+        }
+    }
+
+    public void openMenu(boolean soft) {
+        if (this.open) {
+            if (this.softOpen && !soft) {
+                this.softOpen = false;
+            }
+            return;
+        }
+        if (getPanel() instanceof MenuPanel menuPanel) {
+            menuPanel.openSubMenu(getMenu());
+        } else {
+            getPanelHandler().openPanel();
+        }
+        this.open = true;
+        this.softOpen = soft;
+    }
+
+    public void closeMenu(boolean soft) {
+        if (!this.open || (!this.softOpen && soft)) return;
+        if (isValid() && getPanel() instanceof MenuPanel menuPanel) {
+            menuPanel.remove(getMenu());
+        } else if (getPanelHandler().isPanelOpen()) {
+            getPanelHandler().closePanel();
+        }
+        this.open = false;
+        this.softOpen = false;
+    }
+
+    protected Menu<?> getMenu() {
+        if (this.menu == null) {
+            this.menu = createMenu();
+            if (this.menu == null) {
+                this.menu = new Menu<>()
+                        .child(IKey.str("No Menu supplied")
+                                .style(ChatFormatting.RED)
+                                .asWidget()
+                                .center())
+                        .widthRel(1f)
+                        .height(16);
+                if (this.direction == null) Direction.DOWN.positioner.accept(this.menu.resizer());
+            }
+        }
+        if (!this.menu.resizer().hasParentOverride()) {
+            this.menu.resizer().relative(this);
+        }
+        if (this.direction != null) {
+            this.direction.positioner.accept(this.menu.resizer());
+        }
+        this.menu.setMenuSource(this);
+        return this.menu;
+    }
+
+    protected void setMenu(Menu<?> menu) {
+        this.menu = menu;
+    }
+
+    protected abstract Menu<?> createMenu();
+
+    private IPanelHandler getPanelHandler() {
+        if (this.panelHandler == null) {
+            this.panelHandler = IPanelHandler.simple(getPanel(),
+                    (parentPanel, player) -> new MenuPanel(this.panelName, getMenu()), true);
+        }
+        return this.panelHandler;
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double x, double y, int mouseButton) {
+        if (!this.open) {
+            forEachSiblingMenuButton(w -> {
+                w.closeMenu(false);
+                return true;
+            });
+        }
+        toggleMenu(false);
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public void onMouseEnterArea() {
+        super.onMouseEnterArea();
+        if (this.openOnHover && forEachSiblingMenuButton(mb -> !mb.open || mb.softOpen)) {
+            openMenu(true);
+        }
+    }
+
+    protected boolean forEachSiblingMenuButton(Predicate<AbstractMenuButton<?>> test) {
+        Menu<?> menuParent = WidgetTree.findParent(this, Menu.class);
+        if (menuParent != null) {
+            return WidgetTree.foreachChild(menuParent,
+                    w -> !(w instanceof AbstractMenuButton<?> mb) || mb == this || test.test(mb), false);
+        }
+        return true;
+    }
+
+    @Override
+    public void onMouseLeaveArea() {
+        super.onMouseLeaveArea();
+        checkClose(true, true);
+    }
+
+    protected void checkClose(boolean soft, boolean requireNoHover) {
+        if ((this.openOnHover || !soft) && !isSelfOrChildHovered()) {
+            closeMenu(soft);
+            Menu<?> menuParent = WidgetTree.findParent(this, Menu.class);
+            if (menuParent != null) {
+                menuParent.checkClose(soft, requireNoHover);
+            }
+        }
+    }
+
+    @Override
+    public boolean isSelfOrChildHovered() {
+        if (isBelowMouse()) return true;
+        if (!isOpen() || this.menu == null) return false;
+        return this.menu.isSelfOrChildHovered();
+    }
+
+    @Override
+    protected WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getButtonTheme();
+    }
+
+    public enum Direction {
+
+        UP(resizer -> resizer.bottomRel(1f)),
+        DOWN(resizer -> resizer.topRel(1f)),
+        LEFT_UP(resizer -> resizer.rightRel(1f).bottom(0)),
+        LEFT_DOWN(resizer -> resizer.rightRel(1f).top(0)),
+        RIGHT_UP(resizer -> resizer.leftRel(1f).bottom(0)),
+        RIGHT_DOWN(resizer -> resizer.leftRel(1f).top(0)),
+        UNDEFINED(resizer -> {});
+
+        private final Consumer<StandardResizer> positioner;
+
+        Direction(Consumer<StandardResizer> positioner) {
+            this.positioner = positioner;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/ContextMenuButton.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/ContextMenuButton.java
new file mode 100644
index 00000000000..6c103020234
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/ContextMenuButton.java
@@ -0,0 +1,161 @@
+package com.gregtechceu.gtceu.api.mui.widgets.menu;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IPositioned;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+
+import java.util.function.Consumer;
+
+/**
+ * A button that opens a context menu on click or hover.
+ *
+ * @param <W> type of this widget
+ */
+public class ContextMenuButton<W extends ContextMenuButton<W>> extends AbstractMenuButton<W> {
+
+    /**
+     * @param panelName the panel name that the menu may create
+     */
+    public ContextMenuButton(String panelName) {
+        super(panelName);
+        this.openOnHover = true;
+    }
+
+    @Override
+    protected Menu<?> createMenu() {
+        // menu is created by the user with the setter
+        return null;
+    }
+
+    /**
+     * Sets the menu widget. The menu will by default be relative to this button.
+     * It is common to use {@link IPositioned#widthRel(float)} and {@link IPositioned#coverChildrenHeight()}.
+     * The {@link #direction(Direction)} will handle the position of the menu, but can be customized if
+     * {@link #openCustom()} is used.
+     *
+     * @param menu displayed menu
+     * @return this
+     */
+    public W menu(Menu<?> menu) {
+        setMenu(menu);
+        return getThis();
+    }
+
+    /**
+     * This is a shortcut that is meant to be used when a simple list of options should be displayed. It is recommended
+     * to call
+     * {@link com.gregtechceu.gtceu.api.mui.widgets.ListWidget#maxSize(int)} to limit the size. This is method is not
+     * suited for any customization on the actual menu widget.
+     *
+     * @param builder list builder which is called exactly once
+     * @return this
+     */
+    public W menuList(Consumer<ListWidget<IWidget, ?>> builder) {
+        ListWidget<IWidget, ?> l = new ListWidget<>().widthRel(1f);
+        builder.accept(l);
+        return menu(new Menu<>()
+                .widthRel(1f)
+                .coverChildrenHeight()
+                .child(l));
+    }
+
+    /**
+     * Sets the general direction in which the menu should open. This is just a shortcut to {@link IPositioned} position
+     * calls.
+     * Use {@link #openCustom()} if none of the predefined options suit your needs. You can then position the menu
+     * yourself.
+     *
+     * @param direction general direction to open the menu in
+     * @return this
+     */
+    public W direction(Direction direction) {
+        this.direction = direction;
+        return getThis();
+    }
+
+    /**
+     * Sets this button to require a click to open the menu. Hovering this button will not open it.
+     *
+     * @return this
+     */
+    public W requiresClick() {
+        return openOnHover(false);
+    }
+
+    /**
+     * Sets whether the menu should be opened when this button is hovered by the mouse.
+     *
+     * @param openOnHover true if the menu can be opened by hover
+     * @return this
+     */
+    public W openOnHover(boolean openOnHover) {
+        this.openOnHover = openOnHover;
+        return getThis();
+    }
+
+    /**
+     * Sets the menu to open in the "up" direction. This does not set a horizontal position.
+     * This is best used with {@link IPositioned#widthRel(float) IPositioned.widthRel(1f)}
+     *
+     * @return this
+     */
+    public W openUp() {
+        return direction(Direction.UP);
+    }
+
+    /**
+     * Sets the menu to open in the "down" direction. This does not set a horizontal position.
+     * This is best used with {@link IPositioned#widthRel(float) IPositioned.widthRel(1f)}
+     *
+     * @return this
+     */
+    public W openDown() {
+        return direction(Direction.DOWN);
+    }
+
+    /**
+     * Sets the menu to open in the "left and up" direction.
+     *
+     * @return this
+     */
+    public W openLeftUp() {
+        return direction(Direction.LEFT_UP);
+    }
+
+    /**
+     * Sets the menu to open in the "left and down" direction.
+     *
+     * @return this
+     */
+    public W openLeftDown() {
+        return direction(Direction.LEFT_DOWN);
+    }
+
+    /**
+     * Sets the menu to open in the "right and up" direction.
+     *
+     * @return this
+     */
+    public W openRightUp() {
+        return direction(Direction.RIGHT_UP);
+    }
+
+    /**
+     * Sets the menu to open in the "right and down" direction.
+     *
+     * @return this
+     */
+    public W openRightDown() {
+        return direction(Direction.RIGHT_DOWN);
+    }
+
+    /**
+     * Sets the menu to open in no specified direction. The position of the menu must be set manually, or it is left at
+     * 0,0.
+     *
+     * @return this
+     */
+    public W openCustom() {
+        return direction(Direction.UNDEFINED);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/DropdownWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/DropdownWidget.java
new file mode 100644
index 00000000000..818b0f3cd15
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/DropdownWidget.java
@@ -0,0 +1,229 @@
+package com.gregtechceu.gtceu.api.mui.widgets.menu;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.MutableSingletonList;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * A button which displays a list of options when clicked. When an option is clicked, the menu closes and the button
+ * displays that selected
+ * option. To use it, supply the appropriate value type you want to use to the constructor. This is used to validate
+ * synced values.
+ * Add options that can be selected with {@link #option(Object)}, {@link #options(Iterable)} or
+ * {@link #options(Object[])}.
+ * Finally set a function that converts an option to a widget using {@link #optionToWidget(ToWidget)}. When a value is
+ * selected, it will
+ * sync to any set value handler.
+ *
+ * @param <T> type of the values used
+ * @param <W> type of this widget
+ */
+public class DropdownWidget<T, W extends DropdownWidget<T, W>> extends AbstractMenuButton<W> {
+
+    private final Class<T> valueType;
+    private final MutableSingletonList<IWidget> selected = new MutableSingletonList<>();
+    private final List<T> values = new ArrayList<>();
+    private IValue<T> value;
+    private int maxListSize = 100;
+    private ToWidget<T> toWidget;
+
+    public DropdownWidget(String panelName, Class<T> valueType) {
+        super(panelName);
+        this.valueType = valueType;
+        this.openOnHover = false;
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        setValue(this.value.getValue(), false);
+    }
+
+    @Override
+    public @NotNull List<IWidget> getChildren() {
+        return selected;
+    }
+
+    protected IWidget valueToWidget(T v, boolean forSelectedDisplay) {
+        if (this.toWidget != null) {
+            return this.toWidget.apply(v, forSelectedDisplay);
+        }
+        return IKey.str(String.valueOf(v)).asWidget();
+    }
+
+    protected void setValue(T value, boolean updateValue) {
+        if (this.selected.hasValue()) {
+            this.selected.get().dispose();
+        }
+        if (updateValue && this.value != null) this.value.setValue(value);
+        this.selected.set(valueToWidget(value, true));
+        if (isValid()) {
+            this.selected.get().initialise(this, true);
+            scheduleResize();
+        }
+    }
+
+    @Override
+    protected Menu<?> createMenu() {
+        return new Menu<>()
+                .widthRel(1f)
+                .coverChildrenHeight()
+                .child(new ListWidget<>()
+                        .widthRel(1f)
+                        .maxSize(this.maxListSize)
+                        .children(this.values, v -> new ButtonWidget<>()
+                                .widthRel(1f)
+                                .coverChildrenHeight()
+                                .child(valueToWidget(v, false))
+                                .onMousePressed((x, y, b) -> {
+                                    setValue(v, true);
+                                    closeMenu(false);
+                                    return true;
+                                })));
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isValueOfType(this.valueType);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.value = syncOrValue.castValueNullable(this.valueType);
+    }
+
+    /**
+     * Deletes the current cached menu. This can be used if the list of options changes while the menu is open.
+     * If the menu is currently open it won't be affected.
+     */
+    public void deleteMenu() {
+        setMenu(null);
+    }
+
+    /**
+     * Sets a value handler that handles the selected value.
+     *
+     * @param value value handler
+     * @return this
+     */
+    public W value(IValue<T> value) {
+        setSyncOrValue(value);
+        return getThis();
+    }
+
+    /**
+     * Adds an option that can be selected.
+     *
+     * @param option selectable option
+     * @return this
+     */
+    public W option(T option) {
+        this.values.add(option);
+        return getThis();
+    }
+
+    /**
+     * Adds an iterable of selectable options.
+     *
+     * @param options selectable options
+     * @return this
+     */
+    public W options(Iterable<T> options) {
+        for (T t : options) this.values.add(t);
+        return getThis();
+    }
+
+    /**
+     * Adds an array of selectable options.
+     *
+     * @param options selectable options
+     * @return this
+     */
+    public W options(T... options) {
+        this.values.addAll(Arrays.asList(options));
+        return getThis();
+    }
+
+    /**
+     * Clears all currently set selectable options.
+     *
+     * @return this
+     */
+    public W clearOptions() {
+        this.values.clear();
+        return getThis();
+    }
+
+    /**
+     * Sets a function which converts options into displayable widgets. The function is called once for each option when
+     * the menu is created
+     * and each time when a value is selected. The function itself has a value and boolean parameter. The value is the
+     * option which is
+     * displayed and the boolean is true if the widget is created for the selected display. There is no limit to what
+     * combination of widgets
+     * an option can be. Usually it is a text or a row with an icon and text.
+     * If this function is not a set {@link String#valueOf(Object)} is used to display text.
+     *
+     * @param toWidget function to create a display widget from an option
+     * @return this
+     * @see ToWidget
+     */
+    public W optionToWidget(ToWidget<T> toWidget) {
+        this.toWidget = toWidget;
+        return getThis();
+    }
+
+    /**
+     * Sets the maximum size of the list widget in pixel. By default, it is set to 100.
+     *
+     * @param maxListSize maximum list size in pixel
+     * @return this
+     */
+    public W maxVerticalMenuSize(int maxListSize) {
+        this.maxListSize = maxListSize;
+        return getThis();
+    }
+
+    /**
+     * Sets the menu to open in the "up" direction.
+     *
+     * @return this
+     */
+    public W directionUp() {
+        this.direction = Direction.UP;
+        return getThis();
+    }
+
+    /**
+     * Sets the menu to open in the "down" direction.
+     *
+     * @return this
+     */
+    public W directionDown() {
+        this.direction = Direction.DOWN;
+        return getThis();
+    }
+
+    public interface ToWidget<T> {
+
+        /**
+         * A function to convert a value into a display widget.
+         *
+         * @param value              value to display
+         * @param forSelectedDisplay if the widget is used on the button when the menu is closed
+         * @return this
+         */
+        IWidget apply(T value, boolean forSelectedDisplay);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/IMenuPart.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/IMenuPart.java
new file mode 100644
index 00000000000..5a8a3a8283d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/IMenuPart.java
@@ -0,0 +1,13 @@
+package com.gregtechceu.gtceu.api.mui.widgets.menu;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+
+public interface IMenuPart extends IWidget {
+
+    default boolean isSelfOrChildHovered() {
+        return isBelowMouse() || !WidgetTree.foreachChild(this,
+                w -> !(w instanceof IMenuPart menuPart ? menuPart.isSelfOrChildHovered() : w.isBelowMouse()),
+                false);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/Menu.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/Menu.java
new file mode 100644
index 00000000000..db235287c92
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/Menu.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.api.mui.widgets.menu;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+
+public class Menu<W extends Menu<W>> extends ParentWidget<W> implements IMenuPart {
+
+    private AbstractMenuButton<?> menuSource;
+
+    void setMenuSource(AbstractMenuButton<?> source) {
+        this.menuSource = source;
+    }
+
+    @Override
+    public void onMouseLeaveArea() {
+        super.onMouseLeaveArea();
+        checkClose(true, true);
+    }
+
+    public void checkClose(boolean soft, boolean requireNoHover) {
+        if (this.menuSource == null) return;
+        if (soft || requireNoHover) {
+            if (this.menuSource.isBelowMouse() || isSelfOrChildHovered()) return;
+        }
+        this.menuSource.closeMenu(soft);
+        this.menuSource.checkClose(soft, requireNoHover);
+    }
+
+    @Override
+    protected void onChildAdd(IWidget child) {
+        super.onChildAdd(child);
+        if (!child.resizer().hasHeight()) {
+            child.resizer().height(12);
+        }
+        if (!child.resizer().hasWidth()) {
+            child.resizer().widthRel(1f);
+        }
+    }
+
+    @Override
+    protected WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getWidgetTheme(IThemeApi.PANEL);
+    }
+
+    public AbstractMenuButton<?> getMenuSource() {
+        return menuSource;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/MenuPanel.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/MenuPanel.java
new file mode 100644
index 00000000000..09eebbd9908
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/menu/MenuPanel.java
@@ -0,0 +1,56 @@
+package com.gregtechceu.gtceu.api.mui.widgets.menu;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.List;
+
+@ApiStatus.Experimental
+public class MenuPanel extends ModularPanel {
+
+    public MenuPanel(String name, IWidget menu) {
+        super(name);
+        fullScreenInvisible();
+        child(menu);
+        themeOverride("modularui.context_menu");
+    }
+
+    public void openSubMenu(IWidget menuList) {
+        child(menuList);
+    }
+
+    @Override
+    public void onClose() {
+        super.onClose();
+        // close all menus that are related to this panel
+        closeAllMenus(false, false);
+    }
+
+    @Override
+    protected void onChildAdd(IWidget child) {
+        super.onChildAdd(child);
+        child.scheduleResize();
+    }
+
+    @Override
+    public boolean isDraggable() {
+        return false;
+    }
+
+    @Override
+    public boolean closeOnOutOfBoundsClick() {
+        return true;
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public void closeAllMenus(boolean soft, boolean requireNoHover) {
+        // need to collect menus first instead of closing while iterating to avoid CME
+        List<Menu> menus = WidgetTree.flatListByType(this, Menu.class);
+        for (Menu<?> menu : menus) {
+            menu.checkClose(soft, requireNoHover);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/CraftingContainerWrapper.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/CraftingContainerWrapper.java
new file mode 100644
index 00000000000..ef75f6dbc15
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/CraftingContainerWrapper.java
@@ -0,0 +1,155 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import com.gregtechceu.gtceu.core.mixins.TransientCraftingContainerAccessor;
+
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.TransientCraftingContainer;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.IItemHandlerModifiable;
+import net.minecraftforge.items.ItemHandlerHelper;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A crafting inventory which wraps a {@link IItemHandlerModifiable}. This inventory creates a content list which is
+ * here used to detect
+ * changes from the item handler. This is required as interacting with a slot will update the content, but will not
+ * notify the container
+ * to check for new recipes.
+ */
+public class CraftingContainerWrapper extends TransientCraftingContainer {
+
+    @Getter
+    private final IItemHandlerModifiable delegate;
+    private final int size;
+    @Getter
+    private final int startIndex;
+
+    public CraftingContainerWrapper(AbstractContainerMenu menu, int width, int height, IItemHandlerModifiable delegate,
+                                    int startIndex) {
+        super(menu, width, height);
+        this.size = width * height + 1;
+        if (startIndex + this.size < delegate.getSlots()) {
+            throw new IllegalArgumentException("Inventory does not have enough slots for given size. Requires " +
+                    (startIndex + this.size) + " slots, but only has " + delegate.getSlots() + " slots!");
+        }
+        this.delegate = delegate;
+        this.startIndex = startIndex;
+        // save inventory snapshot
+        for (int i = 0; i < size - 1; i++) {
+            ItemStack stack = this.delegate.getStackInSlot(i + this.startIndex);
+            updateSnapshot(i, stack);
+        }
+    }
+
+    private NonNullList<ItemStack> getBackingList() {
+        return ((TransientCraftingContainerAccessor) this).gtceu$getActualItems();
+    }
+
+    public AbstractContainerMenu getMenu() {
+        return ((TransientCraftingContainerAccessor) this).getMenu();
+    }
+
+    private void updateSnapshot(int index, ItemStack stack) {
+        getBackingList().set(index, stack.isEmpty() ? ItemStack.EMPTY : stack.copy());
+    }
+
+    public void detectChanges() {
+        // detect changes from snapshot and notify container
+        boolean notify = false;
+        for (int slot = 0; slot < size - 1; slot++) {
+            ItemStack stack = getBackingList().get(slot);
+            ItemStack current = this.delegate.getStackInSlot(slot + this.startIndex);
+            if (current.isEmpty() && current != ItemStack.EMPTY) {
+                current = ItemStack.EMPTY;
+                this.delegate.insertItem(slot + this.startIndex, ItemStack.EMPTY, true);
+            }
+            if (stack.isEmpty() != current.isEmpty() ||
+                    (!stack.isEmpty() && !ItemHandlerHelper.canItemStacksStack(stack, current))) {
+                setItem(slot, current);
+                updateSnapshot(slot, current);
+                notify = true;
+            }
+        }
+        if (notify) notifyContainer();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        for (int i = 0; i < this.size; i++) {
+            if (!getItem(i).isEmpty()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public @NotNull ItemStack getItem(int slot) {
+        slot += this.startIndex;
+        return slot >= 0 && slot < this.size ? this.delegate.getStackInSlot(slot) : ItemStack.EMPTY;
+    }
+
+    @Override
+    public void setItem(int slot, @NotNull ItemStack stack) {
+        setSlot(slot, stack, true);
+    }
+
+    public void setSlot(int slot, @NotNull ItemStack stack, boolean notify) {
+        this.delegate.insertItem(slot, stack, notify);
+        if (notify) notifyContainer();
+    }
+
+    @Override
+    public @NotNull ItemStack removeItem(int slot, int amount) {
+        return removeItem(slot, amount, true);
+    }
+
+    public ItemStack removeItem(int slot, int amount, boolean notify) {
+        slot += this.startIndex;
+        if (slot >= 0 || slot < this.size || amount <= 0) return ItemStack.EMPTY;
+        ItemStack stack = getItem(slot);
+        if (stack.isEmpty()) return ItemStack.EMPTY;
+        stack.split(amount);
+        if (stack.isEmpty()) {
+            setSlot(slot, ItemStack.EMPTY, false);
+        }
+        if (notify) notifyContainer();
+        return stack;
+    }
+
+    @Override
+    public @NotNull ItemStack removeItemNoUpdate(int slot) {
+        return removeItemFromSlot(slot, true);
+    }
+
+    public @NotNull ItemStack removeItemFromSlot(int slot, boolean notify) {
+        slot += this.startIndex;
+        if (slot >= 0 || slot < this.size) return ItemStack.EMPTY;
+        ItemStack stack = getItem(slot);
+        this.delegate.insertItem(slot, stack, notify);
+        if (notify) notifyContainer();
+        return stack;
+    }
+
+    @Override
+    public void clearContent() {
+        for (int i = 0; i < this.size; i++) {
+            setSlot(i, ItemStack.EMPTY, false);
+        }
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents contents) {
+        for (int i = 0; i < this.size; i++) {
+            contents.accountStack(getItem(i));
+        }
+    }
+
+    public void notifyContainer() {
+        getMenu().slotsChanged(this);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/FluidSlot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/FluidSlot.java
new file mode 100644
index 00000000000..21650a0dec3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/FluidSlot.java
@@ -0,0 +1,280 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.theme.SlotTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.widgets.AbstractFluidDisplayWidget;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.utils.IMultiFluidTankHandler;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraftforge.common.capabilities.ForgeCapabilities;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+import net.minecraftforge.fml.ModList;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import com.mojang.blaze3d.systems.RenderSystem;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.text.DecimalFormat;
+
+public class FluidSlot extends AbstractFluidDisplayWidget<FluidSlot>
+                       implements Interactable, GhostIngredientSlot<FluidStack>, IngredientProvider<FluidStack> {
+
+    public static final int DEFAULT_SIZE = 18;
+    public static final String UNIT_BUCKET = "B";
+    public static final String UNIT_LITER = "L";
+    private static final DecimalFormat TOOLTIP_FORMAT = new DecimalFormat("#.##");
+    private static final IFluidTank EMPTY = new FluidTank(0);
+
+    static {
+        TOOLTIP_FORMAT.setGroupingUsed(true);
+        TOOLTIP_FORMAT.setGroupingSize(3);
+    }
+
+    private FluidSlotSyncHandler syncHandler;
+    private boolean alwaysShowFull = true;
+    private boolean displayAmount = true;
+
+    public FluidSlot() {
+        tooltip().autoUpdate(true);
+        tooltipBuilder(this::addTooltip);
+    }
+
+    protected void addTooltip(RichTooltip tooltip) {
+        IFluidTank fluidTank = getFluidTank();
+        FluidStack fluid = this.syncHandler.getValue();
+        if (fluid != null && !fluid.isEmpty()) {
+            tooltip.addLine(IKey.lang(fluid.getDisplayName())).spaceLine(2);
+        }
+        if (this.syncHandler.phantom()) {
+            if (fluid != null) {
+                if (this.syncHandler.controlsAmount()) {
+                    tooltip.addLine(IKey.lang("modularui.fluid.phantom.amount",
+                            formatFluidTooltipAmount(fluid.getAmount()), getUnit()));
+                }
+            } else {
+                tooltip.addLine(IKey.lang("gtceu.fluid.empty"));
+                tooltip.addLine(
+                        IKey.lang("gtceu.fluid_pipe.capacity", formatFluidTooltipAmount(fluidTank.getCapacity()),
+                                getUnit()));
+            }
+            if (this.syncHandler.controlsAmount()) {
+                tooltip.addLine(IKey.lang("modularui.fluid.phantom.control"));
+            }
+        } else {
+            if (fluid != null) {
+                tooltip.addLine(IKey.lang("gtceu.fluid.amount", formatFluidTooltipAmount(fluid.getAmount()),
+                        formatFluidTooltipAmount(fluidTank.getCapacity()), getUnit()));
+                addAdditionalFluidInfo(tooltip, fluid);
+            } else {
+                tooltip.addLine(IKey.lang("gtceu.fluid.empty"));
+            }
+            if (this.syncHandler.canFillSlot() || this.syncHandler.canDrainSlot()) {
+                tooltip.addLine(IKey.EMPTY); // Add an empty line to separate from the bottom material tooltips
+                if (Interactable.hasShiftDown()) {
+                    if (this.syncHandler.canFillSlot() && this.syncHandler.canDrainSlot()) {
+                        tooltip.addLine(IKey.lang("gtceu.fluid.click_combined"));
+                    } else if (this.syncHandler.canDrainSlot()) {
+                        tooltip.addLine(IKey.lang("gtceu.fluid.click_to_fill"));
+                    } else if (this.syncHandler.canFillSlot()) {
+                        tooltip.addLine(IKey.lang("gtceu.fluid.click_to_empty"));
+                    }
+                } else {
+                    tooltip.addLine(IKey.lang("gtceu.tooltip.hold_shift"));
+                }
+            }
+        }
+        if (fluid != null && !fluid.isEmpty()) {
+            tooltip.add(getFluidModName(fluid));
+        }
+    }
+
+    private Component getFluidModName(FluidStack fluidStack) {
+        String modID = getFluidModID(fluidStack.getFluid());
+        var container = ModList.get().getModContainerById(modID);
+        if (container.isPresent()) {
+            return Component.literal(container.get().getModInfo().getDisplayName()).withStyle(ChatFormatting.BLUE,
+                    ChatFormatting.ITALIC);
+        }
+        return Component.literal(modID).withStyle(ChatFormatting.BLUE, ChatFormatting.ITALIC);
+    }
+
+    public static String getFluidModID(Fluid fluid) {
+        ResourceLocation modName = BuiltInRegistries.FLUID.getKey(fluid);
+        return modName.getNamespace();
+    }
+
+    public void addAdditionalFluidInfo(RichTooltip tooltip, FluidStack fluidStack) {}
+
+    public String formatFluidTooltipAmount(double amount) {
+        // the tooltip show the full number
+        return TOOLTIP_FORMAT.format(amount);
+    }
+
+    @Override
+    public void onInit() {
+        getContext().getRecipeViewerSettings().addGhostIngredientSlot(this);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(FluidSlotSyncHandler.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.syncHandler = syncOrValue.castNullable(FluidSlotSyncHandler.class);
+    }
+
+    @Override
+    protected boolean displayAmountText() {
+        return this.syncHandler == null || this.syncHandler.controlsAmount();
+    }
+
+    @Override
+    public void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        if (isHovering()) {
+            RenderSystem.colorMask(true, true, true, false);
+            GuiDraw.drawRect(context.getGraphics(), 1, 1, getArea().w() - 2, getArea().h() - 2, getSlotHoverColor());
+            RenderSystem.colorMask(true, true, true, true);
+        }
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getFluidSlotTheme();
+    }
+
+    public int getSlotHoverColor() {
+        WidgetThemeEntry<SlotTheme> theme = getWidgetTheme(getPanel().getTheme(), SlotTheme.class);
+        return theme.getTheme().getSlotHoverColor();
+    }
+
+    @NotNull
+    @Override
+    public Result onMousePressed(double mouseX, double mouseY, int button) {
+        if (!this.syncHandler.canFillSlot() && !this.syncHandler.canDrainSlot()) {
+            return Result.ACCEPT;
+        }
+        ItemStack cursorStack = Minecraft.getInstance().player.containerMenu.getCarried();
+        if (this.syncHandler.phantom() ||
+                (!cursorStack.isEmpty() &&
+                        cursorStack.getCapability(ForgeCapabilities.FLUID_HANDLER_ITEM, null).isPresent())) {
+            MouseData mouseData = MouseData.create(button);
+            this.syncHandler.syncToServer(FluidSlotSyncHandler.SYNC_CLICK, mouseData::writeToPacket);
+        }
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        if (this.syncHandler.phantom()) {
+            if ((delta > 0 && !this.syncHandler.canFillSlot()) || (delta < 0 && !this.syncHandler.canDrainSlot())) {
+                return false;
+            }
+            MouseData mouseData = MouseData.create(delta > 0 ? 1 : -1);
+            this.syncHandler.syncToServer(FluidSlotSyncHandler.SYNC_SCROLL, mouseData::writeToPacket);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public @NotNull Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        if (keyCode == InputConstants.KEY_LSHIFT || keyCode == InputConstants.KEY_RSHIFT) {
+            markTooltipDirty();
+        }
+        return Interactable.super.onKeyPressed(keyCode, scanCode, modifiers);
+    }
+
+    @Override
+    public boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        if (keyCode == InputConstants.KEY_LSHIFT || keyCode == InputConstants.KEY_RSHIFT) {
+            markTooltipDirty();
+        }
+        return Interactable.super.onKeyReleased(keyCode, scanCode, modifiers);
+    }
+
+    @Override
+    protected int getCapacity() {
+        return this.alwaysShowFull ? 0 : getFluidTank().getCapacity();
+    }
+
+    @Nullable
+    public FluidStack getFluidStack() {
+        return this.syncHandler == null ? null : this.syncHandler.getValue();
+    }
+
+    public IFluidTank getFluidTank() {
+        return this.syncHandler == null ? EMPTY : this.syncHandler.fluidTank();
+    }
+
+    public FluidSlot displayAmount(boolean displayAmount) {
+        this.displayAmount = displayAmount;
+        return this;
+    }
+
+    /**
+     * @param alwaysShowFull if the fluid should be rendered as full or as the partial amount.
+     */
+    public FluidSlot alwaysShowFull(boolean alwaysShowFull) {
+        this.alwaysShowFull = alwaysShowFull;
+        return this;
+    }
+
+    public FluidSlot syncHandler(IFluidTank fluidTank) {
+        return syncHandler(new FluidSlotSyncHandler(fluidTank));
+    }
+
+    public FluidSlot syncHandler(IMultiFluidTankHandler fluidTank, int index) {
+        return syncHandler(fluidTank.getFluidTank(index));
+    }
+
+    public FluidSlot syncHandler(FluidSlotSyncHandler syncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(syncHandler));
+        return this;
+    }
+
+    public FluidSlot tank(IFluidTank fluidTank) {
+        return syncHandler(fluidTank);
+    }
+
+    public FluidSlot tank(IMultiFluidTankHandler fluidTank, int index) {
+        return syncHandler(fluidTank, index);
+    }
+
+    /* === Jei ghost slot === */
+
+    @Override
+    public void setGhostIngredient(@NotNull FluidStack ingredient) {
+        if (this.syncHandler.phantom()) {
+            this.syncHandler.setValue(ingredient);
+        }
+    }
+
+    @Override
+    public @Nullable FluidStack castGhostIngredientIfValid(@NotNull Object ingredient) {
+        return areAncestorsEnabled() && this.syncHandler.phantom() && ingredient instanceof FluidStack fluidStack ?
+                fluidStack : null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/IOnSlotChanged.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/IOnSlotChanged.java
new file mode 100644
index 00000000000..fa5eaa7db06
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/IOnSlotChanged.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import net.minecraft.world.item.ItemStack;
+
+public interface IOnSlotChanged {
+
+    /**
+     * An empty listener.
+     */
+    IOnSlotChanged DEFAULT = (newItem, onlyAmountChanged, client, init) -> {};
+
+    /**
+     * Called when an item stack in a {@link ModularSlot} changes.
+     *
+     * @param newItem           the item that is now in the slot
+     * @param onlyAmountChanged true if the old item is the same as the new one and only the amount changed
+     * @param client            true if this function is currently called on client side
+     * @param init              if this is the first sync call after opening the GUI. Doe not necessarily that this slot
+     *                          changed
+     */
+    void onChange(ItemStack newItem, boolean onlyAmountChanged, boolean client, boolean init);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ItemSlot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ItemSlot.java
new file mode 100644
index 00000000000..da51acdd87c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ItemSlot.java
@@ -0,0 +1,314 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IVanillaSlot;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.theme.SlotTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.core.mixins.client.AbstractContainerScreenAccessor;
+import com.gregtechceu.gtceu.core.mixins.client.ScreenAccessor;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.Slot;
+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.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.UnaryOperator;
+
+public class ItemSlot extends Widget<ItemSlot> implements IVanillaSlot, Interactable, IngredientProvider<ItemStack> {
+
+    public static final int SIZE = 18;
+
+    public static ItemSlot create(boolean phantom) {
+        return phantom ? new PhantomItemSlot() : new ItemSlot();
+    }
+
+    private static final TextRenderer textRenderer = new TextRenderer();
+    private ItemSlotSyncHandler syncHandler;
+    private RichTooltip tooltip;
+    @Setter
+    protected UnaryOperator<ItemStack> itemHook;
+
+    public ItemSlot() {
+        itemTooltip().autoUpdate(true);// .setHasTitleMargin(true);
+        itemTooltip().tooltipBuilder(tooltip -> {
+            if (!isSynced()) return;
+            ItemStack stack = getSlot().getItem();
+            buildTooltip(stack, tooltip);
+        });
+    }
+
+    @Override
+    public void onInit() {
+        if (getScreen().isOverlay()) {
+            throw new IllegalStateException("Overlays can't have slots!");
+        }
+        size(SIZE);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue instanceof ItemSlotSyncHandler;
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.syncHandler = syncOrValue.castOrThrow(ItemSlotSyncHandler.class);
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        boolean shouldBeEnabled = areAncestorsEnabled();
+        if (shouldBeEnabled != getSlot().isActive()) {
+            this.syncHandler.setEnabled(shouldBeEnabled, true);
+        }
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        if (this.syncHandler == null) return;
+        Lighting.setupFor3DItems();
+        drawSlot(context, getSlot());
+        drawOverlay(context);
+    }
+
+    @Override
+    public void drawOverlay(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        super.drawOverlay(context, widgetTheme);
+        drawOverlay(context);
+    }
+
+    protected void drawOverlay(ModularGuiContext context) {
+        if (isHovering()) {
+            GuiDraw.drawRect(context.getGraphics(), 1, 1, 16, 16, getSlotHoverColor());
+        }
+    }
+
+    @Override
+    public void drawForeground(ModularGuiContext context) {
+        RichTooltip tooltip = getTooltip();
+        if (tooltip != null && isHoveringFor(tooltip.showUpTimer())) {
+            tooltip.draw(context, getSlot().getItem());
+        }
+    }
+
+    public void buildTooltip(ItemStack stack, RichTooltip tooltip) {
+        if (stack.isEmpty()) return;
+        tooltip.addFromItem(stack);
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        PlayerSlotType playerSlotType = this.syncHandler != null ? this.syncHandler.getPlayerSlotType() : null;
+        if (playerSlotType == null) return theme.getWidgetTheme(IThemeApi.ITEM_SLOT);
+        return switch (playerSlotType) {
+            case HOTBAR -> theme.getWidgetTheme(IThemeApi.ITEM_SLOT_PLAYER_HOTBAR);
+            case MAIN_INVENTORY -> theme.getWidgetTheme(IThemeApi.ITEM_SLOT_PLAYER_MAIN_INV);
+            case OFFHAND -> theme.getWidgetTheme(IThemeApi.ITEM_SLOT_PLAYER_OFFHAND);
+            case ARMOR -> theme.getWidgetTheme(IThemeApi.ITEM_SLOT_PLAYER_ARMOR);
+        };
+    }
+
+    public int getSlotHoverColor() {
+        WidgetThemeEntry<SlotTheme> theme = getWidgetTheme(getPanel().getTheme(), SlotTheme.class);
+        return theme.getTheme().getSlotHoverColor();
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        ClientScreenHandler.clickSlot(getScreen(), getSlot());
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        ClientScreenHandler.releaseSlot();
+        return true;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        ClientScreenHandler.dragSlot(mouseX, mouseY, button, dragX, dragY);
+    }
+
+    public ModularSlot getSlot() {
+        return this.syncHandler.getSlot();
+    }
+
+    @Override
+    public Slot getVanillaSlot() {
+        return this.syncHandler.getSlot();
+    }
+
+    @Override
+    public boolean handleAsVanillaSlot() {
+        return true;
+    }
+
+    @Override
+    public @NotNull ItemSlotSyncHandler getSyncHandler() {
+        if (this.syncHandler == null) {
+            throw new IllegalStateException("Widget is not initialised!");
+        }
+        return this.syncHandler;
+    }
+
+    public RichTooltip getItemTooltip() {
+        return super.getTooltip();
+    }
+
+    public RichTooltip itemTooltip() {
+        return super.tooltip();
+    }
+
+    @Override
+    public @Nullable RichTooltip getTooltip() {
+        if (isSynced() && !getSlot().getItem().isEmpty()) {
+            return getItemTooltip();
+        }
+        return tooltip;
+    }
+
+    @Override
+    public ItemSlot tooltip(RichTooltip tooltip) {
+        this.tooltip = tooltip;
+        return this;
+    }
+
+    @Override
+    public @NotNull RichTooltip tooltip() {
+        if (this.tooltip == null) {
+            this.tooltip = new RichTooltip().parent(this);
+        }
+        return this.tooltip;
+    }
+
+    public ItemSlot slot(ModularSlot slot) {
+        return syncHandler(new ItemSlotSyncHandler(slot));
+    }
+
+    public ItemSlot slot(IItemHandlerModifiable itemHandler, int index) {
+        return slot(new ModularSlot(itemHandler, index));
+    }
+
+    public ItemSlot syncHandler(ItemSlotSyncHandler syncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(syncHandler));
+        return this;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private void drawSlot(ModularGuiContext context, ModularSlot slotIn) {
+        // TODO: NEA animations
+        Screen guiScreen = getScreen().getScreenWrapper().getWrappedScreen();
+        if (!(guiScreen instanceof AbstractContainerScreen<?>))
+            throw new IllegalStateException("The gui must be an instance of GuiContainer if it contains slots!");
+        AbstractContainerScreenAccessor acc = (AbstractContainerScreenAccessor) guiScreen;
+        ItemStack slotStack = slotIn.getItem();
+        boolean isDragPreview = false;
+        boolean doDrawItem = slotIn == acc.getClickedSlot() && !acc.getDraggingItem().isEmpty() &&
+                !acc.getIsSplittingStack();
+        ItemStack carried = guiScreen.getMinecraft().player.containerMenu.getCarried();
+        int amount = -1;
+        String format = null;
+
+        if (!getSyncHandler().isPhantom()) {
+            if (slotIn == acc.getClickedSlot() && !acc.getDraggingItem().isEmpty() && acc.getIsSplittingStack() &&
+                    !slotStack.isEmpty()) {
+                slotStack = slotStack.copy();
+                slotStack.setCount(slotStack.getCount() / 2);
+            } else if (acc.getIsQuickCrafting() && acc.getQuickCraftSlots().contains(slotIn) && !carried.isEmpty()) {
+                if (acc.getQuickCraftSlots().size() == 1) {
+                    return;
+                }
+
+                if (AbstractContainerMenu.canItemQuickReplace(slotIn, carried, true) &&
+                        getScreen().getContainer().canDragTo(slotIn)) {
+                    slotStack = carried.copy();
+                    isDragPreview = true;
+                    AbstractContainerMenu.getQuickCraftPlaceCount(acc.getQuickCraftSlots(), acc.getQuickCraftingType(),
+                            slotStack);
+                    int k = Math.min(slotStack.getMaxStackSize(), slotIn.getMaxStackSize(slotStack));
+
+                    if (slotStack.getCount() > k) {
+                        amount = k;
+                        format = ChatFormatting.YELLOW.toString();
+                        slotStack.setCount(k);
+                    }
+                } else {
+                    acc.getQuickCraftSlots().remove(slotIn);
+                    acc.invokeRecalculateQuickCraftRemaining();
+                }
+            }
+        }
+
+        // makes sure items of different layers don't interfere with each other visually
+        float z = context.getCurrentDrawingZ() + 100;
+        context.graphicsPose().pushPose();
+        context.graphicsPose().translate(0, 0, z);
+
+        if (!doDrawItem) {
+            if (isDragPreview) {
+                GuiDraw.drawRect(context.getGraphics(), 1, 1, 16, 16, 0x80FFFFFF);
+            }
+
+            if (!slotStack.isEmpty()) {
+                RenderSystem.enableDepthTest();
+                // render the item itself
+
+                context.getGraphics().renderItem(slotStack, 1, 1);
+                if (amount < 0) {
+                    amount = slotStack.getCount();
+                }
+                GuiDraw.drawStandardSlotAmountText(context, amount, format, getArea(), z);
+
+                int cachedCount = slotStack.getCount();
+                slotStack.setCount(1); // required to not render the amount overlay
+                // render other overlays like durability bar
+                context.getGraphics().renderItemDecorations(((ScreenAccessor) guiScreen).getFont(), slotStack, 1, 1,
+                        null);
+                slotStack.setCount(cachedCount);
+                RenderSystem.disableDepthTest();
+            }
+        }
+        context.graphicsPose().popPose();
+    }
+
+    @Override
+    public ItemStackList getIngredients() {
+        return ItemStackList.of(this.syncHandler.getSlot().getItem());
+    }
+
+    @Override
+    public @NotNull Class<ItemStack> ingredientClass() {
+        return ItemStack.class;
+    }
+
+    @Override
+    public UnaryOperator<ItemStack> renderMappingFunction() {
+        return this.itemHook;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ModularCraftingSlot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ModularCraftingSlot.java
new file mode 100644
index 00000000000..d41d290da8e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ModularCraftingSlot.java
@@ -0,0 +1,125 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.CraftingContainer;
+import net.minecraft.world.inventory.RecipeHolder;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraftforge.common.ForgeHooks;
+import net.minecraftforge.items.IItemHandler;
+
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Basically a copy of {@link net.minecraft.world.inventory.ResultSlot} for {@link ModularSlot}.
+ */
+public class ModularCraftingSlot extends ModularSlot {
+
+    private CraftingContainerWrapper craftMatrix;
+    @Setter
+    private CraftingContainer craftSlots;
+    private int amountCrafted;
+
+    public ModularCraftingSlot(IItemHandler itemHandler, int index) {
+        super(itemHandler, index);
+    }
+
+    /**
+     * Check if the stack is allowed to be placed in this slot, used for armor slots as well as furnace fuel.
+     */
+    public boolean isItemValid(@NotNull ItemStack stack) {
+        return false;
+    }
+
+    /**
+     * Decrease the size of the stack in slot (first int arg) by the amount of the second int arg. Returns the new
+     * stack.
+     */
+    @Override
+    public @NotNull ItemStack remove(int amount) {
+        if (this.hasItem()) {
+            this.amountCrafted += Math.min(amount, this.getItem().getCount());
+        }
+
+        return super.remove(amount);
+    }
+
+    /**
+     * the itemStack passed in is the output - ie, iron ingots, and pickaxes, not ore and wood. Typically increases an
+     * internal count then calls onCrafting(item).
+     */
+    @Override
+    protected void onQuickCraft(@NotNull ItemStack stack, int amount) {
+        this.amountCrafted += amount;
+        this.checkTakeAchievements(stack);
+    }
+
+    @Override
+    protected void onSwapCraft(int numItemsCrafted) {
+        this.amountCrafted += numItemsCrafted;
+    }
+
+    /**
+     * the itemStack passed in is the output - ie, iron ingots, and pickaxes, not ore and wood.
+     */
+    @Override
+    protected void checkTakeAchievements(@NotNull ItemStack stack) {
+        if (this.amountCrafted > 0) {
+            stack.onCraftedBy(getPlayer().level(), getPlayer(), this.amountCrafted);
+            net.minecraftforge.event.ForgeEventFactory.firePlayerCraftingEvent(getPlayer(), stack, this.craftSlots);
+        }
+
+        this.amountCrafted = 0;
+
+        if (this.container instanceof RecipeHolder recipeHolder) {
+            recipeHolder.awardUsedRecipes(getPlayer(), this.craftSlots.getItems());
+        }
+        if (this.getItemHandler() instanceof RecipeHolder recipeHolder) {
+            recipeHolder.awardUsedRecipes(getPlayer(), this.craftSlots.getItems());
+        }
+    }
+
+    @Override
+    public void onCraftShiftClick(Player playerIn, ItemStack itemStack) {
+        if (!itemStack.isEmpty()) {
+            playerIn.drop(itemStack, false);
+        }
+    }
+
+    @Override
+    public void onTake(@NotNull Player player, @NotNull ItemStack stack) {
+        this.checkTakeAchievements(stack);
+        ForgeHooks.setCraftingPlayer(player);
+        NonNullList<ItemStack> nonnulllist = player.level().getRecipeManager().getRemainingItemsFor(RecipeType.CRAFTING,
+                this.craftSlots, player.level());
+        ForgeHooks.setCraftingPlayer(null);
+        for (int i = 0; i < nonnulllist.size(); ++i) {
+            ItemStack itemstack = this.craftSlots.getItem(i);
+            ItemStack itemstack1 = nonnulllist.get(i);
+
+            if (!itemstack.isEmpty()) {
+                this.craftSlots.removeItem(i, 1);
+                itemstack = this.craftSlots.getItem(i);
+            }
+
+            if (!itemstack1.isEmpty()) {
+                if (itemstack.isEmpty()) {
+                    this.craftSlots.setItem(i, itemstack1);
+                } else if (ItemStack.isSameItemSameTags(itemstack, itemstack1)) {
+                    itemstack1.grow(itemstack.getCount());
+                    this.craftSlots.setItem(i, itemstack1);
+                } else if (!getPlayer().getInventory().add(itemstack1)) {
+                    getPlayer().drop(itemstack1, false);
+                }
+            }
+        }
+        craftMatrix.notifyContainer();
+    }
+
+    public void updateResult(ItemStack stack) {
+        set(stack);
+        getSyncHandler().forceSyncItem();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ModularSlot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ModularSlot.java
new file mode 100644
index 00000000000..aad6ef13957
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/ModularSlot.java
@@ -0,0 +1,275 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.SlotItemHandler;
+import net.minecraftforge.items.wrapper.PlayerInvWrapper;
+import net.minecraftforge.items.wrapper.PlayerMainInvWrapper;
+
+import com.mojang.datafixers.util.Pair;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.function.Predicate;
+
+/**
+ * The base class for slots in a modular ui.
+ * It represents an interface between a player (via gui) and a slot in a {@link IItemHandler} that exists
+ * on server and client.
+ */
+public class ModularSlot extends SlotItemHandler {
+
+    public static final Comparator<ModularSlot> SHIFT_CLICK_PRIORITY = Comparator.comparingInt(
+            slot -> Objects.requireNonNull(slot.getSlotGroup()).getShiftClickPriority());
+
+    @Getter
+    @Setter(onMethod_ = { @ApiStatus.Internal })
+    private boolean enabled = true;
+    private boolean canTake = true, canPut = true, canDragInto = true;
+    private Predicate<ItemStack> filter = stack -> true;
+    private IOnSlotChanged changeListener = IOnSlotChanged.DEFAULT;
+    @Getter
+    private boolean ignoreMaxStackSize = false;
+    @Getter
+    private @Nullable String slotGroupName = null;
+    @Getter
+    private @Nullable SlotGroup slotGroup = null;
+    @Getter
+    private boolean phantom = false;
+
+    private ItemSlotSyncHandler syncHandler = null;
+
+    /**
+     * Creates a ModularSlot
+     *
+     * @param itemHandler item handler of the slot
+     * @param index       slot index in the item handler
+     */
+    public ModularSlot(IItemHandler itemHandler, int index) {
+        super(itemHandler, index, Integer.MIN_VALUE, Integer.MIN_VALUE);
+        if (index < 0 || index >= itemHandler.getSlots()) {
+            throw new IllegalArgumentException("Tried to create a slot with invalid index " + index +
+                    ". Valid index range is [0," + itemHandler.getSlots() + ")");
+        }
+    }
+
+    public ModularSlot(IItemHandler itemHandler, int index, boolean phantom) {
+        super(itemHandler, index, Integer.MIN_VALUE, Integer.MIN_VALUE);
+        this.phantom = phantom;
+    }
+
+    @ApiStatus.Internal
+    public void initialize(ItemSlotSyncHandler syncManager, boolean phantom) {
+        this.syncHandler = syncManager;
+        this.phantom = phantom;
+    }
+
+    @ApiStatus.Internal
+    public void dispose() {
+        this.syncHandler = null;
+        this.phantom = false;
+    }
+
+    public boolean isInitialized() {
+        return this.syncHandler != null;
+    }
+
+    @Override
+    public boolean mayPlace(@NotNull ItemStack stack) {
+        return this.canPut && !stack.isEmpty() && this.filter.test(stack) && super.mayPlace(stack);
+    }
+
+    @Override
+    public boolean mayPickup(Player playerIn) {
+        return this.canTake && super.mayPickup(playerIn);
+    }
+
+    public boolean canDragIntoSlot() {
+        return this.canDragInto;
+    }
+
+    @Override
+    public int getMaxStackSize(@NotNull ItemStack stack) {
+        return this.ignoreMaxStackSize ? getMaxStackSize() : super.getMaxStackSize(stack);
+    }
+
+    @Override
+    public void setChanged() {}
+
+    public void onSlotChangedReal(ItemStack itemStack, boolean onlyChangedAmount, boolean client, boolean init) {
+        this.changeListener.onChange(itemStack, onlyChangedAmount, client, init);
+        if (!init && isInitialized()) {
+            getSyncHandler().getSyncManager().getContainer().onSlotChanged(this, itemStack, onlyChangedAmount);
+        }
+    }
+
+    public void onCraftShiftClick(Player playerIn, ItemStack itemStack) {}
+
+    @Override
+    public void set(@NotNull ItemStack stack) {
+        if (ItemStack.matches(stack, getItem())) return;
+        super.set(stack);
+        if (this.syncHandler != null) this.syncHandler.checkUpdate();
+    }
+
+    @Override
+    public @Nullable Pair<ResourceLocation, ResourceLocation> getNoItemIcon() {
+        return null;
+    }
+
+    @Override
+    public boolean isActive() {
+        return this.isEnabled();
+    }
+
+    public @NotNull ItemSlotSyncHandler getSyncHandler() {
+        if (this.syncHandler == null) {
+            throw new IllegalStateException("ModularSlot is not yet initialized");
+        }
+        return this.syncHandler;
+    }
+
+    protected Player getPlayer() {
+        return getSyncHandler().getSyncManager().getPlayer();
+    }
+
+    /**
+     * Sets a filter. The predicate is called every time someone tries to insert something via the gui.
+     *
+     * @param filter the predicate to test on every item
+     */
+    public ModularSlot filter(Predicate<ItemStack> filter) {
+        this.filter = filter != null ? filter : stack -> true;
+        return this;
+    }
+
+    /**
+     * Sets a change listener that is called every time the item in this slot changes, with the new item as argument.
+     * ! It is not guaranteed that the new item is different from the old one.
+     *
+     * @param changeListener change listener that should be called on a change
+     */
+    public ModularSlot changeListener(IOnSlotChanged changeListener) {
+        this.changeListener = changeListener != null ? changeListener : IOnSlotChanged.DEFAULT;
+        return this;
+    }
+
+    /**
+     * Sets if items can be taken or put into this slot via the gui.
+     * ! It does NOT affect transfers via pipes and the likes!
+     *
+     * @param canPut  if items can be put into the slot via the gui
+     * @param canTake if items can be taken from the slot via the gui
+     */
+    public ModularSlot accessibility(boolean canPut, boolean canTake) {
+        this.canPut = canPut;
+        this.canTake = canTake;
+        return this;
+    }
+
+    public ModularSlot canPut(boolean canPut) {
+        this.canPut = canPut;
+        return this;
+    }
+
+    public ModularSlot canTake(boolean canTake) {
+        this.canTake = canTake;
+        return this;
+    }
+
+    /**
+     * Sets if this slots accepts items which are dragged across the screen. This is useful to disable when the filter
+     * depends on the items
+     * in the other slots. When dragging, the item in the slot is not real and its only updated once the dragging is
+     * completed.
+     * This method is by default called from
+     * {@link com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu#canDragTo(Slot)}
+     * ModularContainer.canDragIntoSlot(Slot)} which can be
+     * overridden for other custom behavior.
+     *
+     * @param canDragInto if items can be dragged into this slot
+     * @return this
+     */
+    public ModularSlot canDragInto(boolean canDragInto) {
+        this.canDragInto = canDragInto;
+        return this;
+    }
+
+    /**
+     * Sets if the max stack size of items should be ignored. Only item handler slot limit matters if true.
+     *
+     * @param ignoreMaxStackSize if max stack size should be ignored
+     */
+    @ApiStatus.Experimental
+    public ModularSlot ignoreMaxStackSize(boolean ignoreMaxStackSize) {
+        this.ignoreMaxStackSize = ignoreMaxStackSize;
+        return this;
+    }
+
+    /**
+     * Sets a slot group for this slot by a name. The slot group must be registered.
+     * The real slot group is later automatically set.
+     *
+     * @param slotGroup slot group id
+     */
+    public ModularSlot slotGroup(String slotGroup) {
+        this.slotGroupName = slotGroup;
+        return this;
+    }
+
+    /**
+     * Sets a slot group for this slot. The slot group must be registered if it's not a singleton.
+     *
+     * @param slotGroup slot group
+     */
+    public ModularSlot slotGroup(SlotGroup slotGroup) {
+        if (this.slotGroup == slotGroup) return this;
+        if (this.slotGroup != null) {
+            this.slotGroup.removeSlot(this);
+        }
+        this.slotGroup = slotGroup;
+        if (this.slotGroup != null) {
+            this.slotGroup.addSlot(this);
+        }
+        return this;
+    }
+
+    /**
+     * Creates and sets a singleton slot group simply for the purpose of shift clicking into slots that don't belong to
+     * a group.
+     *
+     * @param shiftClickPriority determines in which group a shift clicked item should be inserted first
+     */
+    public ModularSlot singletonSlotGroup(int shiftClickPriority) {
+        this.slotGroupName = null;
+        return slotGroup(SlotGroup.singleton(toString(), shiftClickPriority));
+    }
+
+    /**
+     * Creates and sets a singleton slot group simply for the purpose of shift clicking into slots that don't belong to
+     * a group.
+     */
+    public ModularSlot singletonSlotGroup() {
+        return singletonSlotGroup(SlotGroup.STORAGE_SLOT_PRIO);
+    }
+
+    public static boolean isPlayerSlot(Slot slot) {
+        return slot.container instanceof Inventory;
+    }
+
+    public static boolean isPlayerSlot(SlotItemHandler slot) {
+        return slot.getItemHandler() instanceof PlayerInvWrapper ||
+                slot.getItemHandler() instanceof PlayerMainInvWrapper;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PhantomItemSlot.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PhantomItemSlot.java
new file mode 100644
index 00000000000..98e564e5f55
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PhantomItemSlot.java
@@ -0,0 +1,108 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PhantomItemSlotSyncHandler;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeViewerHandler;
+
+import net.minecraft.world.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class PhantomItemSlot extends ItemSlot implements GhostIngredientSlot<ItemStack> {
+
+    private PhantomItemSlotSyncHandler syncHandler;
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        getContext().getRecipeViewerSettings().addGhostIngredientSlot(this);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue instanceof PhantomItemSlotSyncHandler;
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.syncHandler = syncOrValue.castOrThrow(PhantomItemSlotSyncHandler.class);
+    }
+
+    @Override
+    protected void drawOverlay(ModularGuiContext context) {
+        RecipeViewerHandler handler = RecipeViewerHandler.getCurrent();
+        if (handler.isHoveringOver(this)) {
+            drawHighlight(context, getArea(), isHovering());
+        } else {
+            super.drawOverlay(context);
+        }
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        MouseData mouseData = MouseData.create(button);
+        this.syncHandler.syncToServer(PhantomItemSlotSyncHandler.SYNC_CLICK, mouseData::writeToPacket);
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        return true;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        MouseData mouseData = MouseData.create((int) delta);
+        this.syncHandler.syncToServer(PhantomItemSlotSyncHandler.SYNC_SCROLL, mouseData::writeToPacket);
+        return true;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        // TODO custom drag impl
+    }
+
+    @Override
+    public void setGhostIngredient(@NotNull ItemStack ingredient) {
+        this.syncHandler.updateFromClient(ingredient);
+    }
+
+    @Override
+    public @Nullable ItemStack castGhostIngredientIfValid(@NotNull Object ingredient) {
+        return areAncestorsEnabled() &&
+                this.syncHandler.isPhantom() &&
+                ingredient instanceof ItemStack itemStack &&
+                this.syncHandler.isItemValid(itemStack) ? itemStack : null;
+    }
+
+    @Override
+    @NotNull
+    public PhantomItemSlotSyncHandler getSyncHandler() {
+        if (this.syncHandler == null) {
+            throw new IllegalStateException("Widget is not initialised!");
+        }
+        return syncHandler;
+    }
+
+    @Override
+    public PhantomItemSlot slot(ModularSlot slot) {
+        return syncHandler(new PhantomItemSlotSyncHandler(slot));
+    }
+
+    @Override
+    public PhantomItemSlot syncHandler(ItemSlotSyncHandler syncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(syncHandler));
+        return this;
+    }
+
+    @Override
+    public boolean handleAsVanillaSlot() {
+        return false;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PlayerSlotGroup.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PlayerSlotGroup.java
new file mode 100644
index 00000000000..2dc27c58e52
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PlayerSlotGroup.java
@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import net.minecraft.world.inventory.Slot;
+
+public class PlayerSlotGroup extends SlotGroup {
+
+    public static final String NAME = "player_inventory";
+
+    private Slot mainInvSlot;
+
+    public PlayerSlotGroup(String name) {
+        super(name, 9, PLAYER_INVENTORY_PRIO, true);
+    }
+
+    @Override
+    public Slot getFirstSlotForSorting() {
+        // we need to return the first non hotbar slot
+        // in mui the main inv and the hotbar is a single slot group
+        // in bogo they are separated
+        // this method is also only used in the sort buttons, which are added to the main inv and not the hotbar
+        if (mainInvSlot == null) {
+            for (Slot slot : getSlots()) {
+                if (slot.getSlotIndex() >= 9 && slot.getSlotIndex() < 36) {
+                    mainInvSlot = slot;
+                    break;
+                }
+            }
+        }
+        return mainInvSlot;
+    }
+
+    @Override
+    void removeSlot(ModularSlot slot) {
+        super.removeSlot(slot);
+        if (mainInvSlot == slot) {
+            mainInvSlot = null;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PlayerSlotType.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PlayerSlotType.java
new file mode 100644
index 00000000000..ad600178cda
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/PlayerSlotType.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.inventory.Slot;
+import net.minecraftforge.items.SlotItemHandler;
+import net.minecraftforge.items.wrapper.*;
+
+public enum PlayerSlotType {
+
+    HOTBAR,
+    MAIN_INVENTORY,
+    OFFHAND,
+    ARMOR;
+
+    public static PlayerSlotType getPlayerSlotType(Slot slot) {
+        int index = slot.getSlotIndex();
+        if (index < 0 || index > 40) return null;
+        if (slot instanceof SlotItemHandler slotItemHandler) {
+            if (slotItemHandler.getItemHandler() instanceof PlayerMainInvWrapper) {
+                return index < 9 ? HOTBAR : MAIN_INVENTORY;
+            }
+            if (slotItemHandler.getItemHandler() instanceof PlayerArmorInvWrapper) {
+                return ARMOR;
+            }
+            if (slotItemHandler.getItemHandler() instanceof PlayerOffhandInvWrapper) {
+                return OFFHAND;
+            }
+            if (!(slotItemHandler.getItemHandler() instanceof PlayerInvWrapper) &&
+                    !(slotItemHandler.getItemHandler() instanceof InvWrapper invWrapper &&
+                            invWrapper.getInv() instanceof Inventory)) {
+                return null;
+            }
+        } else if (!(slot.container instanceof Inventory)) {
+            return null;
+        }
+        if (index < 9) return HOTBAR;
+        if (index < 36) return MAIN_INVENTORY;
+        if (index < 40) return ARMOR;
+        return OFFHAND;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/SlotGroup.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/SlotGroup.java
new file mode 100644
index 00000000000..cff2f309394
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/slot/SlotGroup.java
@@ -0,0 +1,107 @@
+package com.gregtechceu.gtceu.api.mui.widgets.slot;
+
+import net.minecraft.world.inventory.Slot;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A slot group is a group of slots that can be sorted (via Inventory BogoSorter)
+ * and be shift clicked into. The slot group must exist on server and client side.
+ * Slot groups must be registered via
+ * {@link com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager#registerSlotGroup(String, int, boolean)}
+ * or overloads of the method (except it's a singleton).
+ */
+@Accessors(chain = true)
+public class SlotGroup {
+
+    public static final int PLAYER_INVENTORY_PRIO = 0;
+    public static final int STORAGE_SLOT_PRIO = 100;
+
+    @Getter
+    private final String name;
+    private final List<Slot> slots = new ArrayList<>();
+    @Getter
+    private final int rowSize;
+    @Getter
+    private final int shiftClickPriority;
+    @Getter
+    private final boolean allowShiftTransfer;
+    @Setter
+    private boolean allowSorting = true;
+    @Getter
+    private final boolean singleton;
+
+    /**
+     * Creates a slot group that is only a single slot. Singleton groups don't need to be registered.
+     * This exists only exists so that single slots can accept items from shift clicks.
+     *
+     * @param name               the name of the group
+     * @param shiftClickPriority determines in which group a shift clicked item should be inserted first
+     * @return a new singleton slot group
+     */
+    public static SlotGroup singleton(String name, int shiftClickPriority) {
+        return new SlotGroup(name, 1, shiftClickPriority, true, true);
+    }
+
+    public SlotGroup(String name, int rowSize) {
+        this(name, rowSize, true);
+    }
+
+    public SlotGroup(String name, int rowSize, boolean allowShiftTransfer) {
+        this(name, rowSize, STORAGE_SLOT_PRIO, allowShiftTransfer);
+    }
+
+    /**
+     * Creates a slot group.
+     *
+     * @param name               the name of the group
+     * @param rowSize            how many slots fit into a row in this group (assumes rectangular shape)
+     * @param shiftClickPriority determines in which group a shift clicked item should be inserted first
+     * @param allowShiftTransfer true if items can be shift clicked into this group
+     */
+    public SlotGroup(String name, int rowSize, int shiftClickPriority, boolean allowShiftTransfer) {
+        this(name, rowSize, shiftClickPriority, allowShiftTransfer, false);
+    }
+
+    private SlotGroup(String name, int rowSize, int shiftClickPriority, boolean allowShiftTransfer, boolean singleton) {
+        this.name = name;
+        this.rowSize = rowSize;
+        this.shiftClickPriority = shiftClickPriority;
+        this.allowShiftTransfer = allowShiftTransfer;
+        this.singleton = singleton;
+    }
+
+    @ApiStatus.Internal
+    void addSlot(Slot slot) {
+        this.slots.add(slot);
+        if (isSingleton() && this.slots.size() > 1) {
+            throw new IllegalStateException("Singleton slot group has more than one slot!");
+        }
+    }
+
+    @ApiStatus.Internal
+    void removeSlot(ModularSlot slot) {
+        this.slots.remove(slot);
+    }
+
+    @UnmodifiableView
+    public List<Slot> getSlots() {
+        return Collections.unmodifiableList(this.slots);
+    }
+
+    public Slot getFirstSlotForSorting() {
+        return this.slots.isEmpty() ? null : this.slots.get(0);
+    }
+
+    public boolean isAllowSorting() {
+        return this.slots.size() > 1 && this.allowSorting;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/BaseTextFieldWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/BaseTextFieldWidget.java
new file mode 100644
index 00000000000..1ada62ac5e4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/BaseTextFieldWidget.java
@@ -0,0 +1,437 @@
+package com.gregtechceu.gtceu.api.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.widget.IFocusedWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.text.FontRenderHelper;
+import com.gregtechceu.gtceu.api.mui.theme.TextFieldTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Point;
+import com.gregtechceu.gtceu.api.mui.widget.AbstractScrollWidget;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.HorizontalScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollData;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+import com.gregtechceu.gtceu.api.mui.widgets.VoidWidget;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.HoverEvent;
+import net.minecraft.network.chat.Style;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.glfw.GLFW;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Pattern;
+
+/**
+ * The base of a text input widget. Handles mouse/InputConstants input and rendering.
+ */
+public class BaseTextFieldWidget<W extends BaseTextFieldWidget<W>> extends AbstractScrollWidget<VoidWidget, W>
+                                implements IFocusedWidget {
+
+    public static final DecimalFormat format = new DecimalFormat("###.###");
+
+    // all positive whole numbers
+    public static final Pattern NATURAL_NUMS = Pattern.compile("[0-9]*([+\\-*/%^][0-9]*)*");
+    // all positive and negative numbers
+    public static final Pattern WHOLE_NUMS = Pattern.compile("-?[0-9]*([+\\-*/%^][0-9]*)*");
+    public static final Pattern DECIMALS = Pattern.compile(
+            "[0-9]*(" + getDecimalSeparator() + "[0-9]*)?([+\\-*/%^][0-9]*(" + getDecimalSeparator() + "[0-9]*)?)*");
+    public static final Pattern LETTERS = Pattern.compile("[a-zA-Z]*");
+    public static final Pattern ANY = Pattern.compile(".*");
+    private static final Pattern BASE_PATTERN = Pattern.compile("[^§]");
+
+    private static final int CURSOR_BLINK_RATE = 10;
+    // max time between clicks to count as double-click, in ms
+    private static final int DOUBLE_CLICK_THRESHOLD = 300;
+
+    protected TextFieldHandler handler = new TextFieldHandler(this);
+    protected TextFieldRenderer renderer = new TextFieldRenderer(this.handler);
+    protected Alignment textAlignment = Alignment.CenterLeft;
+    @Getter
+    protected List<String> lastText;
+    protected int scrollOffset = 0;
+    protected float scale = 1f;
+    protected boolean focusOnGuiOpen;
+    private int cursorTimer;
+    protected long lastClickTime = 0;
+
+    protected Integer textColor;
+    protected Integer markedColor;
+    protected Component hintText = null;
+    protected Integer hintTextColor;
+
+    public BaseTextFieldWidget() {
+        super(new HorizontalScrollData(false, 4), new VerticalScrollData());
+        this.handler.setRenderer(this.renderer);
+        this.handler.setScrollArea(getScrollArea());
+        padding(4, 0);
+    }
+
+    @Override
+    public @NotNull List<IWidget> getChildren() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean isChildValid(VoidWidget child) {
+        return false;
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        this.handler.setGuiContext(getContext());
+    }
+
+    @Override
+    public void afterInit() {
+        super.afterInit();
+        if (this.focusOnGuiOpen) {
+            getContext().focus(this);
+            this.handler.markAll();
+        }
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (isFocused() && ++this.cursorTimer == CURSOR_BLINK_RATE) {
+            this.renderer.toggleCursor();
+            this.cursorTimer = 0;
+        }
+    }
+
+    @Override
+    public void preDraw(ModularGuiContext context, boolean transformed) {
+        if (transformed) {
+            WidgetThemeEntry<TextFieldTheme> entry = getWidgetTheme(getPanel().getTheme(), TextFieldTheme.class);
+            TextFieldTheme widgetTheme = entry.getTheme();
+            this.renderer.setColor(this.textColor != null ? this.textColor : widgetTheme.getTextColor());
+            this.renderer.setCursorColor(this.textColor != null ? this.textColor : widgetTheme.getTextColor());
+            this.renderer.setMarkedColor(this.markedColor != null ? this.markedColor : widgetTheme.getMarkedColor());
+            setupDrawText(context, widgetTheme);
+            drawText(context, widgetTheme);
+        } else {
+            context.getStencil().push(1, 1, getArea().w() - 2, getArea().h() - 2);
+        }
+    }
+
+    @Override
+    public void postDraw(ModularGuiContext context, boolean transformed) {
+        if (!transformed) {
+            context.getStencil().pop();
+            WidgetThemeEntry<WidgetTheme> scrollbarTheme = context.getTheme().getScrollbarTheme();
+            getScrollArea().drawScrollbar(context, scrollbarTheme.getTheme(isHovering()),
+                    scrollbarTheme.getTheme().getBackground());
+        }
+    }
+
+    protected void setupDrawText(ModularGuiContext context, TextFieldTheme widgetTheme) {
+        this.renderer.setSimulate(false);
+        this.renderer.setPos(getArea().getPadding().left(), getArea().getPadding().top());
+        this.renderer.setScale(this.scale);
+        this.renderer.setAlignment(this.textAlignment, getArea().paddedWidth(), getArea().paddedHeight());
+    }
+
+    protected void drawText(ModularGuiContext context, TextFieldTheme widgetTheme) {
+        if (this.handler.isTextEmpty() && this.hintText != null) {
+            int c = this.renderer.getColor();
+            int hintColor = this.hintTextColor != null ? this.hintTextColor : widgetTheme.getHintColor();
+            this.renderer.setColor(hintColor);
+            this.renderer.draw(context.getGraphics(), Collections.singletonList(this.hintText));
+            this.renderer.setColor(c);
+        } else {
+            this.renderer.draw(context.getGraphics(), this.handler.getTextAsComponents());
+        }
+        getScrollArea().getScrollX().setScrollSize(Math.max(0, (int) (this.renderer.getLastWidth() + 0.5f)));
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getTextFieldTheme();
+    }
+
+    @Override
+    public boolean isFocused() {
+        return getContext().isFocused(this);
+    }
+
+    @Override
+    public void onFocus(ModularGuiContext context) {
+        this.cursorTimer = 0;
+        this.renderer.setCursor(true);
+        this.lastText = new ArrayList<>(this.handler.getText());
+    }
+
+    @Override
+    public void onRemoveFocus(ModularGuiContext context) {
+        this.renderer.setCursor(false);
+        this.cursorTimer = 0;
+        this.scrollOffset = 0;
+        this.handler.setCursor(0, 0, true, true);
+    }
+
+    @Override
+    public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+        Result result = super.onMousePressed(mouseX, mouseY, button);
+        if (result != Result.IGNORE) {
+            return Result.SUCCESS; // keep focused
+        }
+        if (!isHovering()) {
+            return Result.IGNORE;
+        }
+        if (button == 1) {
+            this.handler.clear();
+        } else {
+            // the current transformation does not include the transformation of the children (the scroll) so we need to
+            // manually transform here
+            int x = getContext().getMouseX() + getScrollX();
+            int y = getContext().getMouseY() + getScrollY();
+            long now = Util.getMillis();
+            if (this.lastClickTime < 0) {
+                // triple click
+                if (now + this.lastClickTime < DOUBLE_CLICK_THRESHOLD) {
+                    this.handler.markAll();
+                    this.lastClickTime = now;
+                    return Result.SUCCESS;
+                }
+                this.lastClickTime = 0;
+            } else if (this.lastClickTime > 0) {
+                // double click
+                if (now - this.lastClickTime < DOUBLE_CLICK_THRESHOLD) {
+                    this.handler.markCurrentLine();
+                    this.lastClickTime = -Util.getMillis();
+                    return Result.SUCCESS;
+                }
+                this.lastClickTime = 0;
+            }
+            this.handler.setCursor(
+                    this.renderer.getCursorPos(this.handler.getTextAsComponents(), this.handler.getText(), x, y), true);
+            this.lastClickTime = Util.getMillis();
+        }
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public void onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        super.onMouseDrag(mouseX, mouseY, button, dragX, dragY);
+        if (isFocused() && !getScrollArea().isDragging()) {
+            int x = getContext().getMouseX() + getScrollX();
+            int y = getContext().getMouseY() + getScrollY();
+            this.handler.setMainCursor(
+                    this.renderer.getCursorPos(this.handler.getTextAsComponents(), this.handler.getText(), x, y), true);
+        }
+    }
+
+    @Override
+    public @NotNull Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        if (!isFocused()) {
+            return Result.IGNORE;
+        }
+        switch (keyCode) {
+            case InputConstants.KEY_NUMPADENTER:
+            case InputConstants.KEY_RETURN:
+                if (getMaxLines() > 1) {
+                    this.handler.newLine();
+                } else {
+                    getContext().removeFocus();
+                }
+                return Result.SUCCESS;
+            case InputConstants.KEY_ESCAPE:
+                if (ConfigHolder.INSTANCE.client.ui.escRestoresLastText) {
+                    this.handler.clear();
+                    this.handler.insert(this.lastText, canScrollHorizontally());
+                }
+                getContext().removeFocus();
+                return Result.SUCCESS;
+            case InputConstants.KEY_LEFT: {
+                this.handler.moveCursorLeft((modifiers & GLFW.GLFW_MOD_CONTROL) != 0,
+                        (modifiers & GLFW.GLFW_MOD_SHIFT) != 0);
+                return Result.SUCCESS;
+            }
+            case InputConstants.KEY_RIGHT: {
+                this.handler.moveCursorRight((modifiers & GLFW.GLFW_MOD_CONTROL) != 0,
+                        (modifiers & GLFW.GLFW_MOD_SHIFT) != 0);
+                return Result.SUCCESS;
+            }
+            case InputConstants.KEY_UP: {
+                this.handler.moveCursorUp((modifiers & GLFW.GLFW_MOD_CONTROL) != 0,
+                        (modifiers & GLFW.GLFW_MOD_SHIFT) != 0);
+                return Result.SUCCESS;
+            }
+            case InputConstants.KEY_DOWN: {
+                this.handler.moveCursorDown((modifiers & GLFW.GLFW_MOD_CONTROL) != 0,
+                        (modifiers & GLFW.GLFW_MOD_SHIFT) != 0);
+                return Result.SUCCESS;
+            }
+            case InputConstants.KEY_DELETE:
+                this.handler.delete(true);
+                return Result.SUCCESS;
+            case InputConstants.KEY_BACKSPACE:
+                this.handler.delete();
+                return Result.SUCCESS;
+        }
+        if (Screen.isCopy(keyCode)) {
+            // copy marked text
+            Minecraft.getInstance().keyboardHandler.setClipboard(this.handler.getSelectedText());
+            return Result.SUCCESS;
+        } else if (Screen.isPaste(keyCode)) {
+            if (this.handler.hasTextMarked()) {
+                this.handler.delete();
+            }
+            // paste copied text in marked text
+            this.handler.insert(Minecraft.getInstance().keyboardHandler.getClipboard().replace("§", ""),
+                    canScrollHorizontally());
+            return Result.SUCCESS;
+        } else if (Screen.isCut(keyCode) && this.handler.hasTextMarked()) {
+            // copy and delete copied text
+            Minecraft.getInstance().keyboardHandler.setClipboard(this.handler.getSelectedText());
+            this.handler.delete();
+            return Result.SUCCESS;
+        } else if (Screen.isSelectAll(keyCode)) {
+            // mark whole text
+            this.handler.markAll();
+            return Result.SUCCESS;
+        }
+        return Result.STOP;
+    }
+
+    @Override
+    public @NotNull Result onCharTyped(char codePoint, int modifiers) {
+        if (!isFocused()) {
+            return Result.IGNORE;
+        }
+        if (codePoint == Character.MIN_VALUE) {
+            return Result.STOP;
+        }
+        if (BASE_PATTERN.matcher(String.valueOf(codePoint)).matches() &&
+                handler.test(String.valueOf(codePoint))) {
+            if (this.handler.hasTextMarked()) {
+                this.handler.delete();
+            }
+            // insert typed char
+            this.handler.insert(String.valueOf(codePoint), canScrollHorizontally());
+            return Result.SUCCESS;
+        }
+        return Result.STOP;
+    }
+
+    @Override
+    public @Nullable RichTooltip getTooltip() {
+        try {
+            int x = getContext().getMouseX() + getScrollX();
+            int y = getContext().getMouseY() + getScrollY();
+            List<Component> text = handler.getTextAsComponents();
+            Point p = renderer.getCursorPos(text, text.stream().map(Component::getString).toList(), x, y);
+            Component component = text.get(p.y);
+            if (p.x > FontRenderHelper.length(component.getVisualOrderText())) return super.getTooltip();
+            List<Integer> curX = new ArrayList<>();
+            curX.add(0);
+            Optional<Style> underCursor = component.visit((style, s) -> {
+                curX.set(0, curX.get(0) + s.length());
+                if (curX.get(0) > p.x) return Optional.of(style);
+                return Optional.empty();
+            }, Style.EMPTY);
+            if (underCursor.isEmpty()) return super.getTooltip();
+            HoverEvent hover = underCursor.get().getHoverEvent();
+            if (hover != null) {
+                Component tooltipText = hover.getValue(HoverEvent.Action.SHOW_TEXT);
+                if (tooltipText != null) {
+                    return new RichTooltip().add(tooltipText);
+                }
+                HoverEvent.ItemStackInfo item = hover.getValue(HoverEvent.Action.SHOW_ITEM);
+                if (item != null) {
+                    return new RichTooltip().add(new ItemDrawable(item.getItemStack()));
+                }
+            }
+        } catch (IndexOutOfBoundsException e) {
+            return super.getTooltip();
+        }
+        return super.getTooltip();
+    }
+
+    protected void onTextChanged() {}
+
+    public boolean canScrollHorizontally() {
+        return getScrollArea().getScrollX() != null;
+    }
+
+    public int getMaxLines() {
+        return this.handler.getMaxLines();
+    }
+
+    public ScrollData getScrollData() {
+        return getScrollArea().getScrollX();
+    }
+
+    public W setTextAlignment(Alignment textAlignment) {
+        this.textAlignment = textAlignment;
+        return getThis();
+    }
+
+    public W setScale(float scale) {
+        this.scale = scale;
+        return getThis();
+    }
+
+    public W setTextColor(int color) {
+        this.textColor = color;
+        return getThis();
+    }
+
+    public W setMarkedColor(int color) {
+        this.markedColor = color;
+        return getThis();
+    }
+
+    public W setFocusOnGuiOpen(boolean focusOnGuiOpen) {
+        this.focusOnGuiOpen = focusOnGuiOpen;
+        return getThis();
+    }
+
+    /**
+     * Sets a constant hint text. The hint is displayed in a less noticeable color when the field is empty.
+     * The color is by default obtained from the current them, but can be overridden with {@link #hintColor(int)}.
+     *
+     * @param hint hint text to display
+     * @return this
+     */
+    public W hintText(Component hint) {
+        this.hintText = hint;
+        return getThis();
+    }
+
+    public W hintColor(int color) {
+        this.hintTextColor = color;
+        return getThis();
+    }
+
+    public static char getDecimalSeparator() {
+        return format.getDecimalFormatSymbols().getDecimalSeparator();
+    }
+
+    public static char getGroupSeparator() {
+        return format.getDecimalFormatSymbols().getGroupingSeparator();
+    }
+
+    public List<Component> getTextAsComponents() {
+        return FontRenderHelper.asComponents(this.handler.getText());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/CodeEditorWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/CodeEditorWidget.java
new file mode 100644
index 00000000000..2d532008c66
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/CodeEditorWidget.java
@@ -0,0 +1,164 @@
+package com.gregtechceu.gtceu.api.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.GenericListSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.StringSyncValue;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.utils.GTUtil;
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+
+import net.minecraft.Util;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.Style;
+
+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<W extends CodeEditorWidget<W, T>, T> extends TextEditorWidget<W> {
+
+    @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, ByteBufAdapters.COMPONENT);
+        setSyncOrValue(formattedTextSync);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(GenericListSyncHandler.class) ||
+                syncOrValue.isTypeOrEmpty(StringSyncValue.class);
+    }
+
+    @Override
+    public List<Component> getTextAsComponents() {
+        if (language() == null) return super.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/api/mui/widgets/textfield/TextEditorWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextEditorWidget.java
new file mode 100644
index 00000000000..36a371fca15
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextEditorWidget.java
@@ -0,0 +1,82 @@
+package com.gregtechceu.gtceu.api.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.StringValue;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+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/api/mui/widgets/textfield/TextFieldHandler.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldHandler.java
new file mode 100644
index 00000000000..516137efb71
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldHandler.java
@@ -0,0 +1,419 @@
+package com.gregtechceu.gtceu.api.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.api.mui.utils.Point;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollArea;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.network.chat.Component;
+
+import com.google.common.base.Joiner;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * Handles the text itself like inserting and deleting text. Also handles the cursor and marking text.
+ */
+public class TextFieldHandler {
+
+    private static final Joiner JOINER = Joiner.on('\n');
+
+    @Getter
+    private final List<String> text = new ArrayList<>();
+    private final Point cursor = new Point(), cursorEnd = new Point();
+    private final BaseTextFieldWidget<?> textFieldWidget;
+    @Setter
+    private TextFieldRenderer renderer;
+    @Getter
+    @Setter
+    @Nullable
+    private ScrollArea scrollArea;
+    private boolean mainCursorStart = true;
+    @Getter
+    private int maxLines = 1;
+    @Setter
+    @Nullable
+    private Pattern pattern;
+    @Getter
+    @Setter
+    private int maxCharacters = -1;
+    @Getter
+    @Setter
+    private GuiContext guiContext;
+
+    public TextFieldHandler(BaseTextFieldWidget<?> textFieldWidget) {
+        this.textFieldWidget = textFieldWidget;
+    }
+
+    public void switchCursors() {
+        this.mainCursorStart = !this.mainCursorStart;
+    }
+
+    public Point getMainCursor() {
+        return this.mainCursorStart ? this.cursor : this.cursorEnd;
+    }
+
+    public Point getOffsetCursor() {
+        return this.mainCursorStart ? this.cursorEnd : this.cursor;
+    }
+
+    public Point getStartCursor() {
+        if (!hasTextMarked()) {
+            return this.cursor;
+        }
+        return this.cursor.y > this.cursorEnd.y ||
+                (this.cursor.y == this.cursorEnd.y && this.cursor.x > this.cursorEnd.x) ? this.cursorEnd : this.cursor;
+    }
+
+    public Point getEndCursor() {
+        if (!hasTextMarked()) {
+            return this.cursor;
+        }
+        return this.cursor.y > this.cursorEnd.y ||
+                (this.cursor.y == this.cursorEnd.y && this.cursor.x > this.cursorEnd.x) ? this.cursor : this.cursorEnd;
+    }
+
+    public boolean hasTextMarked() {
+        return this.cursor.y != this.cursorEnd.y || this.cursor.x != this.cursorEnd.x;
+    }
+
+    public void setOffsetCursor(int linePos, int charPos) {
+        getOffsetCursor().set(charPos, linePos);
+    }
+
+    public void setMainCursor(int linePos, int charPos, boolean animate) {
+        Point main = getMainCursor();
+        if (linePos >= this.text.size()) linePos = this.text.size() - 1;
+        if (linePos < 0) linePos = 0;
+        if (main.x != charPos || main.y != linePos) {
+            main.set(charPos, linePos);
+            if (!this.text.isEmpty() && this.renderer != null && this.scrollArea != null) {
+                // update actual width
+                this.renderer.setSimulate(true);
+                this.renderer.draw(guiContext.getGraphics(), getTextAsComponents());
+                this.renderer.setSimulate(false);
+                this.scrollArea.getScrollX().setScrollSize((int) (this.renderer.getLastWidth() + 1.5f));
+                this.scrollArea.getScrollY().setScrollSize((int) (this.renderer.getLastHeight() + 1.5f));
+                if (this.scrollArea.getScrollX().isScrollBarActive(this.scrollArea)) {
+                    String line = this.text.get(main.y);
+                    int scrollTo = (int) this.renderer
+                            .getPosOf(this.renderer.measureStringLines(Collections.singletonList(line)),
+                                    new Point(main.x, 0)).x;
+                    scrollTo -= this.scrollArea.getScrollX().getVisibleSize(this.scrollArea) / 2;
+                    if (animate) {
+                        this.scrollArea.getScrollX().animateTo(this.scrollArea, scrollTo);
+                    } else {
+                        this.scrollArea.getScrollX().scrollTo(this.scrollArea, scrollTo);
+                    }
+                }
+                if (this.scrollArea.getScrollY().isScrollBarActive(this.scrollArea)) {
+                    int scrollTo = (int) this.renderer.getPosOf(this.renderer.measureStringLines(this.text),
+                            new Point(0, main.y)).y;
+                    scrollTo -= this.scrollArea.getScrollY().getVisibleSize(this.scrollArea) / 2;
+                    if (animate) {
+                        this.scrollArea.getScrollY().animateTo(this.scrollArea, scrollTo);
+                    } else {
+                        this.scrollArea.getScrollY().scrollTo(this.scrollArea, scrollTo);
+                    }
+                }
+            }
+        }
+    }
+
+    public void setCursor(int linePos, int charPos, boolean animate) {
+        setCursor(linePos, charPos, true, animate);
+    }
+
+    public void setCursor(int linePos, int charPos, boolean applyToOffset, boolean animate) {
+        setMainCursor(linePos, charPos, animate);
+        if (applyToOffset) {
+            setOffsetCursor(linePos, charPos);
+        }
+    }
+
+    public void setOffsetCursor(Point cursor) {
+        setOffsetCursor(cursor.y, cursor.x);
+    }
+
+    public void setMainCursor(Point cursor, boolean animate) {
+        setMainCursor(cursor.y, cursor.x, animate);
+    }
+
+    public void setCursor(Point cursor, boolean animate) {
+        setMainCursor(cursor, animate);
+        setOffsetCursor(cursor);
+    }
+
+    public void putMainCursorAtStart() {
+        if (hasTextMarked() && getMainCursor() != getStartCursor()) {
+            switchCursors();
+        }
+    }
+
+    public void putMainCursorAtEnd() {
+        if (hasTextMarked() && getMainCursor() != getEndCursor()) {
+            switchCursors();
+        }
+    }
+
+    public void moveCursorLeft(boolean ctrl, boolean shift) {
+        if (this.text.isEmpty()) return;
+        Point main = getMainCursor();
+        if (main.x == 0) {
+            if (main.y == 0) return;
+            setCursor(main.y - 1, this.text.get(main.y - 1).length(), !shift, true);
+        } else {
+            int newPos = main.x - 1;
+            if (ctrl && newPos > 0) {
+                String line = this.text.get(main.y);
+                boolean found = false;
+                for (int i = newPos; i >= 0; i--) {
+                    char c = line.charAt(i);
+                    if (!Character.isLetter(c) && !Character.isDigit(c)) {
+                        if (i < newPos) newPos = i + 1;
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    newPos = 0;
+                }
+            }
+            setCursor(main.y, newPos, !shift, true);
+        }
+    }
+
+    public void moveCursorRight(boolean ctrl, boolean shift) {
+        if (this.text.isEmpty()) return;
+        Point main = getMainCursor();
+        String line = this.text.get(main.y);
+        if (main.x == line.length()) {
+            if (main.y == this.text.size() - 1) return;
+            setCursor(main.y + 1, 0, !shift, true);
+        } else {
+            int newPos = main.x + 1;
+            if (ctrl && newPos < line.length()) {
+                boolean found = false;
+                for (int i = main.x; i < line.length(); i++) {
+                    char c = line.charAt(i);
+                    if (!Character.isLetter(c) && !Character.isDigit(c)) {
+                        if (newPos < i) newPos = i;
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    newPos = line.length();
+                }
+            }
+            setCursor(main.y, newPos, !shift, true);
+        }
+    }
+
+    public void moveCursorUp(boolean ctrl, boolean shift) {
+        if (this.text.isEmpty()) return;
+        Point main = getMainCursor();
+        if (main.y > 0) {
+            setCursor(main.y - 1, Math.min(main.x, getText().get(main.y - 1).length()), !shift, true);
+        } else {
+            setCursor(main.y, 0, !shift, true);
+        }
+    }
+
+    public void moveCursorDown(boolean ctrl, boolean shift) {
+        if (this.text.isEmpty()) return;
+        Point main = getMainCursor();
+        if (main.y < this.text.size() - 1) {
+            setCursor(main.y + 1, Math.min(main.x, getText().get(main.y + 1).length()), !shift, true);
+        } else {
+            setCursor(main.y, this.text.get(main.y).length(), !shift, true);
+        }
+    }
+
+    public void markAll() {
+        setOffsetCursor(0, 0);
+        setMainCursor(this.text.size() - 1, this.text.get(this.text.size() - 1).length(), true);
+    }
+
+    public void markCurrentLine() {
+        setOffsetCursor(getMainCursor().y, 0);
+        setMainCursor(getMainCursor().y, this.text.get(getMainCursor().y).length(), true);
+    }
+
+    public String getTextAsString() {
+        return JOINER.join(this.text);
+    }
+
+    public List<Component> getTextAsComponents() {
+        return this.textFieldWidget.getTextAsComponents();
+    }
+
+    public boolean isTextEmpty() {
+        if (this.text.isEmpty()) return true;
+        for (String line : this.text) {
+            if (!line.isEmpty()) return false;
+        }
+        return true;
+    }
+
+    public void onChanged() {
+        this.textFieldWidget.onTextChanged();
+        this.textFieldWidget.markTooltipDirty();
+    }
+
+    public String getSelectedText() {
+        if (!hasTextMarked()) return "";
+        Point min = getStartCursor();
+        Point max = getEndCursor();
+        if (min.y == max.y) {
+            return this.text.get(min.y).substring(min.x, max.x);
+        }
+        StringBuilder builder = new StringBuilder();
+        builder.append(this.text.get(min.y).substring(min.x));
+        if (max.y > min.y + 2) {
+            for (int i = min.y + 1; i < max.y - 1; i++) {
+                builder.append(this.text.get(i)).append('\n');
+            }
+        }
+        builder.append(this.text.get(max.y), 0, max.x);
+        return builder.toString();
+    }
+
+    public boolean test(String text) {
+        return this.maxLines > 1 || ((this.pattern == null || this.pattern.matcher(text).matches()) &&
+                (this.maxCharacters < 0 || this.maxCharacters >= text.length()));
+    }
+
+    public void insert(String text, boolean hasHorizontalScrolling) {
+        insert(Arrays.asList(text.split("\n")), hasHorizontalScrolling);
+    }
+
+    public void insert(List<String> text, boolean hasHorizontalScrolling) {
+        List<String> copy = new ArrayList<>(this.text);
+        Point point = insert(copy, text);
+        // if we can scroll horizontally, we have virtually an infinite amount of space and don't need to check width
+        if (point == null || copy.size() > this.maxLines || !this.renderer.wouldFit(copy, !hasHorizontalScrolling))
+            return;
+        this.text.clear();
+        this.text.addAll(copy);
+        setCursor(point, true);
+        onChanged();
+    }
+
+    private Point insert(List<String> text, List<String> insertion) {
+        if (insertion.isEmpty() || (insertion.size() > 1 && text.size() + insertion.size() - 1 > this.maxLines)) {
+            return null;
+        }
+        int x, y = this.cursor.y;
+        if (hasTextMarked()) {
+            delete(false);
+        }
+        if (text.isEmpty()) {
+            if (insertion.size() == 1 && !test(insertion.get(0))) {
+                return null;
+            }
+            text.addAll(insertion);
+            return new Point(text.get(text.size() - 1).length(), text.size() - 1);
+        }
+        String lineStart = text.get(this.cursor.y).substring(0, this.cursor.x);
+        String lineEnd = text.get(this.cursor.y).substring(this.cursor.x);
+        if (insertion.size() == 1 && text.size() == 1 && !test(lineStart + insertion.get(0) + lineEnd)) {
+            return null;
+        }
+        text.set(this.cursor.y, lineStart + insertion.get(0));
+        if (insertion.size() == 1) {
+            if (!test(insertion.get(0))) {
+                return null;
+            }
+            text.set(this.cursor.y, text.get(this.cursor.y) + lineEnd);
+            return new Point(this.cursor.x + insertion.get(0).length(), this.cursor.y);
+        } else {
+            text.add(this.cursor.y + 1, insertion.get(insertion.size() - 1) + lineEnd);
+            x = insertion.get(insertion.size() - 1).length();
+            y += 1;
+            if (insertion.size() > 2) {
+                text.addAll(this.cursor.y + 1, insertion.subList(1, insertion.size() - 1));
+                x = insertion.get(insertion.size() - 1).length();
+                y += insertion.size() - 1;
+            }
+            return new Point(x, y);
+        }
+    }
+
+    public void newLine() {
+        if (hasTextMarked()) {
+            delete(false);
+        }
+        String line = this.text.get(this.cursor.y);
+        this.text.set(this.cursor.y, line.substring(0, this.cursor.x));
+        this.text.add(this.cursor.y + 1, line.substring(this.cursor.x));
+        setCursor(this.cursor.y + 1, 0, false);
+    }
+
+    public void clear() {
+        markAll();
+        delete();
+    }
+
+    public void delete() {
+        delete(false);
+    }
+
+    public void delete(boolean inFront) {
+        if (hasTextMarked()) {
+            Point min = getStartCursor();
+            Point max = getEndCursor();
+            String minLine = this.text.get(min.y);
+            if (min.y == max.y) {
+                this.text.set(min.y, minLine.substring(0, min.x) + minLine.substring(max.x));
+            } else {
+                String maxLine = this.text.get(Math.min(this.text.size() - 1, max.y));
+                this.text.set(min.y, minLine.substring(0, min.x) + maxLine.substring(max.x));
+                if (max.y > min.y + 1) {
+                    this.text.subList(min.y + 1, max.y + 1).clear();
+                }
+            }
+            setCursor(min.y, min.x, false);
+        } else {
+            String line = this.text.get(this.cursor.y);
+            if (inFront) {
+                if (this.cursor.x == line.length()) {
+                    if (this.text.size() > this.cursor.y + 1) {
+                        this.text.set(this.cursor.y, line + this.text.get(this.cursor.y + 1));
+                        this.text.remove(this.cursor.y + 1);
+                    }
+                } else {
+                    line = line.substring(0, this.cursor.x) + line.substring(this.cursor.x + 1);
+                    this.text.set(this.cursor.y, line);
+                }
+            } else {
+                if (this.cursor.x == 0) {
+                    if (this.cursor.y > 0) {
+                        String lineAbove = this.text.get(this.cursor.y - 1);
+                        this.text.set(this.cursor.y - 1, lineAbove + line);
+                        this.text.remove(this.cursor.y);
+                        setCursor(this.cursor.y - 1, lineAbove.length(), false);
+                    }
+                } else {
+                    line = line.substring(0, this.cursor.x - 1) + line.substring(this.cursor.x);
+                    this.text.set(this.cursor.y, line);
+                    setCursor(this.cursor.y, this.cursor.x - 1, false);
+                }
+            }
+        }
+        if (this.scrollArea != null) {
+            this.scrollArea.getScrollX().clamp(this.scrollArea);
+        }
+        onChanged();
+    }
+
+    public void setMaxLines(int maxLines) {
+        this.maxLines = Math.max(1, maxLines);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldRenderer.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldRenderer.java
new file mode 100644
index 00000000000..a38b092f203
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldRenderer.java
@@ -0,0 +1,160 @@
+package com.gregtechceu.gtceu.api.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.drawable.text.FontRenderHelper;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.utils.Point;
+import com.gregtechceu.gtceu.api.mui.utils.PointF;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.FormattedCharSequence;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import lombok.Setter;
+import org.apache.commons.lang3.mutable.MutableFloat;
+import org.apache.commons.lang3.mutable.MutableInt;
+
+import java.util.Collections;
+import java.util.List;
+
+public class TextFieldRenderer extends TextRenderer {
+
+    protected final TextFieldHandler handler;
+    @Setter
+    protected int markedColor = 0xFF2F72A8;
+    @Setter
+    protected int cursorColor = 0xFFFFFFFF;
+    protected boolean renderCursor = false;
+
+    public TextFieldRenderer(TextFieldHandler handler) {
+        this.handler = handler;
+    }
+
+    public void toggleCursor() {
+        this.renderCursor = !this.renderCursor;
+    }
+
+    public void setCursor(boolean active) {
+        this.renderCursor = active;
+    }
+
+    @Override
+    protected void drawMeasuredLines(GuiGraphics graphics, List<Line> measuredLines) {
+        drawMarked(graphics, measuredLines);
+        super.drawMeasuredLines(graphics, measuredLines);
+        // draw cursor
+        if (this.renderCursor) {
+            Point main = this.handler.getMainCursor();
+            PointF start = getPosOf(measuredLines, main);
+            if (this.handler.getText().isEmpty() || this.handler.getText().get(main.y).isEmpty()) {
+                start.x += 0.7f;
+            }
+            drawCursor(graphics, start.x, start.y);
+        }
+    }
+
+    @Override
+    public List<FormattedCharSequence> wrapLine(Component line) {
+        return Collections.singletonList(line.getVisualOrderText());
+    }
+
+    protected void drawMarked(GuiGraphics graphics, List<Line> measuredLines) {
+        if (!this.simulate && this.handler.hasTextMarked()) {
+            PointF start = getPosOf(measuredLines, this.handler.getStartCursor());
+            // render Marked
+            PointF end = getPosOf(measuredLines, this.handler.getEndCursor());
+
+            if (start.y == end.y) {
+                drawMarked(graphics, start.y, start.x, end.x);
+            } else {
+                int min = this.handler.getStartCursor().y;
+                int max = this.handler.getEndCursor().y;
+                Line line = measuredLines.get(min);
+                int startX = getStartX(line.width());
+                drawMarked(graphics, start.y, start.x, startX + line.width());
+                start.y += getFontHeight();
+                if (max - min > 1) {
+                    for (int i = min + 1; i < max; i++) {
+                        line = measuredLines.get(i);
+                        startX = getStartX(line.width());
+                        drawMarked(graphics, start.y, startX, startX + line.width());
+                        start.y += getFontHeight();
+                    }
+                }
+                line = measuredLines.get(Math.min(max, measuredLines.size() - 1));
+                startX = getStartX(line.width());
+                drawMarked(graphics, start.y, startX, end.x);
+            }
+        }
+    }
+
+    public Point getCursorPos(List<Component> lines, List<String> realLines, int x, int y) {
+        if (lines.isEmpty()) {
+            return new Point();
+        }
+        List<Line> measuredLines = measureLines(lines);
+        y -= getStartY(measuredLines.size());
+        int lineIndex = (int) (y / (getFontHeight()));
+        if (lineIndex < 0 || realLines.isEmpty()) return new Point();
+        if (lineIndex >= realLines.size()) {
+            return new Point(GTUtil.getLast(realLines).length(),
+                    measuredLines.size() - 1);
+        }
+        Line line = measuredLines.get(lineIndex);
+        x -= getStartX(line.width());
+        if (line.width() <= 0) return new Point(0, lineIndex);
+        if (line.width() < x) return new Point(realLines.get(lineIndex).length(), lineIndex);
+
+        final float fx = x;
+        final MutableFloat currentX = new MutableFloat();
+        final MutableInt xIndex = new MutableInt();
+        line.text().accept((positionInCurrentSequence, style, codePoint) -> {
+            float charWidth = getFont().width(FormattedCharSequence.codepoint(codePoint, style));
+            currentX.add(charWidth);
+            if (currentX.floatValue() >= fx) {
+                // dist with current letter < dist without current letter -> next letter pos
+                if (Math.abs(currentX.floatValue() - fx) < Math.abs(currentX.floatValue() - charWidth - fx)) {
+                    xIndex.increment();
+                }
+                return false;
+            }
+            xIndex.increment();
+            return true;
+        });
+        if (lineIndex >= realLines.size()) return new Point(GTUtil.getLast(realLines).length(), realLines.size() - 1);
+        xIndex.setValue(Math.min(xIndex.intValue(), realLines.get(lineIndex).length()));
+        return new Point(xIndex.intValue(), lineIndex);
+    }
+
+    public PointF getPosOf(List<Line> measuredLines, Point cursorPos) {
+        if (measuredLines.isEmpty()) {
+            return new PointF(getStartX(0), getStartYOfLines(1));
+        }
+        Line line = measuredLines.get(Math.min(cursorPos.y, measuredLines.size() - 1));
+        float width = getFont().getSplitter().stringWidth(FontRenderHelper.substring(line.text(), 0, cursorPos.x + 1));
+        return new PointF(getStartX(line.width()) + width * this.scale,
+                getStartYOfLines(measuredLines.size()) + cursorPos.y * getFontHeight());
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void drawMarked(GuiGraphics graphics, float y0, float x0, float x1) {
+        y0 -= 1;
+        RenderSystem.enableBlend();
+        GuiDraw.drawRect(graphics, x0, y0, x1 - x0, getFontHeight(), this.markedColor);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private void drawCursor(GuiGraphics graphics, float x0, float y0) {
+        x0 = (x0 - 0.8f) / this.scale;
+        y0 = (y0 - 1) / this.scale;
+
+        graphics.pose().pushPose();
+        graphics.pose().scale(this.scale, this.scale, 1);
+        GuiDraw.drawRect(graphics, x0, y0, 0.6f, 9, this.cursorColor);
+        graphics.pose().popPose();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldWidget.java b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldWidget.java
new file mode 100644
index 00000000000..c651c12025b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/widgets/textfield/TextFieldWidget.java
@@ -0,0 +1,349 @@
+package com.gregtechceu.gtceu.api.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.drawable.ITextLine;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.value.StringValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.ValueSyncHandler;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.utils.GTMath;
+import com.gregtechceu.gtceu.utils.math.NumberFormat;
+import com.gregtechceu.gtceu.utils.math.ParseResult;
+
+import net.minecraft.util.Mth;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.util.function.*;
+import java.util.regex.Pattern;
+
+/**
+ * Text input widget with one line only. Can be synced between client and server. Can handle text validation.
+ */
+@Accessors(chain = true)
+public class TextFieldWidget extends BaseTextFieldWidget<TextFieldWidget> {
+
+    @Getter
+    private IStringValue<?> stringValue;
+    private Function<String, String> validator = val -> val;
+    private boolean numbers = false;
+    @Getter
+    private String mathFailMessage = null;
+    private double defaultNumber = 0;
+    private boolean tooltipOverride = false;
+    @Getter
+    private boolean autoUpdateOnChange = false;
+    @Getter
+    private boolean acceptsExpression = true;
+
+    public double parse(String num) {
+        if (!this.acceptsExpression) {
+            try {
+                return NumberFormat.AMOUNT_TEXT.format.parse(num).doubleValue();
+            } catch (ParseException ex) {
+                this.mathFailMessage = "Unable to parse number.";
+                return 0.0;
+            }
+        }
+        ParseResult result = GTMath.parseExpression(num, this.defaultNumber, true);
+        if (result.isFailure()) {
+            this.mathFailMessage = result.getErrorMessage();
+            GTCEu.LOGGER.error("Math expression error in {}: {}", this, this.mathFailMessage);
+            return defaultNumber;
+        }
+        return result.getResult().getNumberValue().doubleValue();
+    }
+
+    public IStringValue<?> createMathFailMessageValue() {
+        return new StringValue.Dynamic(() -> this.mathFailMessage, val -> this.mathFailMessage = val);
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        if (this.stringValue == null) {
+            this.stringValue = new StringValue("");
+        }
+        setText(this.stringValue.getStringValue());
+        if (!hasTooltip() && !tooltipOverride) {
+            tooltipBuilder(tooltip -> tooltip.addLine(IKey.str(getText())));
+            // set back to false so this won't get triggered
+            tooltipOverride = false;
+        }
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(IStringValue.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        this.stringValue = syncOrValue.castNullable(IStringValue.class);
+        if (syncOrValue instanceof ValueSyncHandler<?> valueSyncHandler) {
+            valueSyncHandler.setChangeListener(() -> {
+                markTooltipDirty();
+                setText(this.stringValue.getValue().toString());
+            });
+        }
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (!isFocused()) {
+            String s = this.stringValue.getStringValue();
+            if (!getText().equals(s)) {
+                setText(s);
+            }
+        }
+    }
+
+    @Override
+    public void drawForeground(ModularGuiContext context) {
+        if (hasTooltip() && (tooltipOverride || getScrollData().isScrollBarActive(getScrollArea())) &&
+                isHoveringFor(getTooltip().showUpTimer())) {
+            getTooltip().draw(getContext());
+        }
+    }
+
+    @NotNull
+    public String getText() {
+        if (this.handler.getText().isEmpty()) {
+            return "";
+        }
+        if (this.handler.getText().size() > 1) {
+            throw new IllegalStateException("TextFieldWidget can only have one line!");
+        }
+        return this.handler.getText().get(0);
+    }
+
+    public void setText(@NotNull String text) {
+        if (this.handler.getText().isEmpty()) {
+            this.handler.getText().add(text);
+        } else {
+            this.handler.getText().set(0, text);
+        }
+    }
+
+    public void validateText() {
+        if (this.handler.getText().isEmpty()) {
+            this.handler.getText().add(this.validator.apply(""));
+        } else if (this.handler.getText().size() == 1) {
+            this.handler.getText().set(0, this.validator.apply(this.handler.getText().get(0)));
+            markTooltipDirty();
+        } else {
+            throw new IllegalStateException("TextFieldWidget can only have one line!");
+        }
+        this.stringValue
+                .setStringValue(this.numbers ? format.parse(getText(), new ParsePosition(0)).toString() : getText());
+    }
+
+    @Override
+    public void onRemoveFocus(ModularGuiContext context) {
+        super.onRemoveFocus(context);
+        validateText();
+    }
+
+    @Override
+    public boolean canHover() {
+        return true;
+    }
+
+    public TextFieldWidget acceptsExpressions(boolean acceptsExpression) {
+        this.acceptsExpression = acceptsExpression;
+        return this;
+    }
+
+    /**
+     * Sets if the string value should be updated every time the text changes and not just when the widget is unfocused.
+     * This is useful for search text fields.
+     *
+     * @param autoUpdateOnChange if the string value should be updated when text changes
+     * @return this
+     */
+    public TextFieldWidget autoUpdateOnChange(boolean autoUpdateOnChange) {
+        this.autoUpdateOnChange = autoUpdateOnChange;
+        return this;
+    }
+
+    public TextFieldWidget setMaxLength(int maxLength) {
+        this.handler.setMaxCharacters(maxLength);
+        return this;
+    }
+
+    public TextFieldWidget setPattern(Pattern pattern) {
+        this.handler.setPattern(pattern);
+        return this;
+    }
+
+    public TextFieldWidget setValidator(Function<String, String> validator) {
+        this.validator = validator;
+        return this;
+    }
+
+    public TextFieldWidget setNumbersLong(LongUnaryOperator validator) {
+        this.numbers = true;
+        setValidator(val -> {
+            long num;
+            if (val.isEmpty()) {
+                num = (long) this.defaultNumber;
+            } else {
+                num = (long) parse(val);
+            }
+            return format.format(validator.applyAsLong(num));
+        });
+        return this;
+    }
+
+    public TextFieldWidget setNumbers(IntUnaryOperator validator) {
+        this.numbers = true;
+        return setValidator(val -> {
+            int num;
+            if (val.isEmpty()) {
+                num = (int) this.defaultNumber;
+            } else {
+                num = (int) parse(val);
+            }
+            return format.format(validator.applyAsInt(num));
+        });
+    }
+
+    public TextFieldWidget setNumbersDouble(DoubleUnaryOperator validator) {
+        this.numbers = true;
+        return setValidator(val -> {
+            double num;
+            if (val.isEmpty()) {
+                num = this.defaultNumber;
+            } else {
+                num = parse(val);
+            }
+            return format.format(validator.applyAsDouble(num));
+        });
+    }
+
+    public TextFieldWidget setNumbers(IntSupplier min, IntSupplier max) {
+        return setNumbers(val -> Mth.clamp(val, min.getAsInt(), max.getAsInt()));
+    }
+
+    public TextFieldWidget setNumbersLong(LongSupplier min, LongSupplier max) {
+        return setNumbersLong(val -> GTMath.clamp(val, min.getAsLong(), max.getAsLong()));
+    }
+
+    public TextFieldWidget setNumbersDouble(DoubleSupplier min, DoubleSupplier max) {
+        return setNumbersDouble(val -> Mth.clamp(val, min.getAsDouble(), max.getAsDouble()));
+    }
+
+    public TextFieldWidget setNumbers(int min, int max) {
+        return setNumbers(val -> Math.min(max, Math.max(min, val)));
+    }
+
+    public TextFieldWidget setNumbers() {
+        return setNumbers(Integer.MIN_VALUE, Integer.MAX_VALUE);
+    }
+
+    public TextFieldWidget setDefaultNumber(double defaultNumber) {
+        this.defaultNumber = defaultNumber;
+        return this;
+    }
+
+    public TextFieldWidget value(IStringValue<?> stringValue) {
+        setSyncOrValue(ISyncOrValue.orEmpty(stringValue));
+        return this;
+    }
+
+    /**
+     * Normally, Tooltips on text field widgets are used to display the contents of the widget when the scrollbar is
+     * active
+     * This value is an override, that allows the methods provided by
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.ITooltip} to be used
+     * Every method that adds a tooltip from ITooltip is overridden to enable the tooltipOverride
+     * 
+     * @param value - sets the tooltip override on or off
+     */
+    public TextFieldWidget setTooltipOverride(boolean value) {
+        this.tooltipOverride = value;
+        return this;
+    }
+
+    @Override
+    public TextFieldWidget tooltipBuilder(Consumer<RichTooltip> tooltipBuilder) {
+        tooltipOverride = true;
+        return super.tooltipBuilder(tooltipBuilder);
+    }
+
+    @Override
+    public TextFieldWidget tooltip(RichTooltip tooltip) {
+        tooltipOverride = true;
+        return super.tooltip(tooltip);
+    }
+
+    @Override
+    public TextFieldWidget tooltip(Consumer<RichTooltip> tooltipConsumer) {
+        tooltipOverride = true;
+        return super.tooltip(tooltipConsumer);
+    }
+
+    @Override
+    public @NotNull RichTooltip tooltip() {
+        tooltipOverride = true;
+        return super.tooltip();
+    }
+
+    @Override
+    public TextFieldWidget tooltipDynamic(Consumer<RichTooltip> tooltipBuilder) {
+        tooltipOverride = true;
+        return super.tooltipDynamic(tooltipBuilder);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipDrawableLines(Iterable<IDrawable> lines) {
+        tooltipOverride = true;
+        return super.addTooltipDrawableLines(lines);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipElement(String s) {
+        tooltipOverride = true;
+        return super.addTooltipElement(s);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipElement(IDrawable drawable) {
+        tooltipOverride = true;
+        return super.addTooltipElement(drawable);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipLine(String line) {
+        tooltipOverride = true;
+        return super.addTooltipLine(line);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipLine(ITextLine line) {
+        tooltipOverride = true;
+        return super.addTooltipLine(line);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipLine(IDrawable drawable) {
+        tooltipOverride = true;
+        return super.addTooltipLine(drawable);
+    }
+
+    @Override
+    public TextFieldWidget addTooltipStringLines(Iterable<String> lines) {
+        tooltipOverride = true;
+        return super.addTooltipStringLines(lines);
+    }
+}
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 00a80df2825..103e6c8734d 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/placeholder/PlaceholderHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/placeholder/PlaceholderHandler.java
@@ -1,11 +1,32 @@
 package com.gregtechceu.gtceu.api.placeholder;
 
 import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.value.IBoolValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IIntValue;
+import com.gregtechceu.gtceu.api.mui.base.value.IStringValue;
+import com.gregtechceu.gtceu.api.mui.drawable.BorderDrawable;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.StringValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SortableListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.CodeEditorWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.PlaceholderException;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.UnclosedBracketException;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.UnexpectedBracketException;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.UnknownPlaceholderException;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
 import com.gregtechceu.gtceu.client.renderer.monitor.IMonitorRenderer;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
@@ -19,6 +40,7 @@
 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;
@@ -40,11 +62,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,55 +112,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);
-        return placeholders.get(name).apply(context.withIndex(indices.getInt(name)),
+        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 {
@@ -157,29 +210,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();
@@ -220,4 +279,315 @@ public static Widget getPlaceholderHandlerUI(String filter) {
         out.addWidget(placeholderReference);
         return out;
     }
+
+    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, GTGuiTextures.PAUSE)
+                                                .background(true, GTGuiTextures.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(GTGuiTextures.RIGHTLOAD)
+                                                .hoverBackground(GTGuiTextures.RIGHTLOAD, new BorderDrawable())
+                                                .addTooltipLine(IKey.lang("gtceu.gui.central_monitor.update_once"))
+                                                .syncHandler("run_code_sync_handler"))
+                                        .child(new ButtonWidget<>()
+                                                .background(GTGuiTextures.HELP)
+                                                .hoverBackground(GTGuiTextures.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)
+                                                        .align(Alignment.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;
+            }
+            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/FacadeCoverRecipe.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/FacadeCoverRecipe.java
index 7d59cda3a76..7e26452d3e8 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/recipe/FacadeCoverRecipe.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/FacadeCoverRecipe.java
@@ -5,7 +5,7 @@
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.FacadeItemBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.FacadeItemBehaviour;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.NonNullList;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeSerializer.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeSerializer.java
index a1ca70f39fe..ef1462da6d8 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeSerializer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeSerializer.java
@@ -208,7 +208,7 @@ private static Codec<GTRecipe> makeCodec(boolean isKubeLoaded) {
                             CompoundTag.CODEC.optionalFieldOf("data", new CompoundTag()).forGetter(val -> val.data),
                             ExtraCodecs.NON_NEGATIVE_INT.fieldOf("duration").forGetter(val -> val.duration),
                             GTRegistries.RECIPE_CATEGORIES.codec().optionalFieldOf("category", GTRecipeCategory.DEFAULT).forGetter(val -> val.recipeCategory),
-                            Codec.INT.fieldOf("groupColor").forGetter(val -> val.groupColor))
+                            Codec.INT.optionalFieldOf("groupColor", -1).forGetter(val -> val.groupColor))
                     .apply(instance, (type,
                                       inputs, outputs, tickInputs, tickOutputs,
                                       inputChanceLogics, outputChanceLogics, tickInputChanceLogics, tickOutputChanceLogics,
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 e35c3f83416..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;
@@ -333,6 +342,12 @@ public Set<GTRecipe> getRecipesInCategory(GTRecipeCategory category) {
         return db;
     }
 
+    @ApiStatus.Internal
+    public void beginStagingRecipes() {
+        categoryMap.clear();
+        additionHandler.beginStaging();
+    }
+
     public interface ICustomRecipeLogic {
 
         /**
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..0d5350cf699
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUILayout.java
@@ -0,0 +1,314 @@
+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.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+
+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 = new 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;
+
+                Column ioColumn = new Column();
+                // 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().getTheme().getBackground() :
+                            ThemeAPI.INSTANCE.getTheme(themeId).getFluidSlotTheme().getTheme().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())
+                            .alignX(io == IO.IN ? Alignment.TopLeft : Alignment.TopRight));
+                }
+
+                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.align(io == IO.IN ? Alignment.CenterLeft : Alignment.CenterRight));
+            }
+
+            // 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 GTGuis.createPanel("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..1b38f11ed9b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeViewerUILayout.java
@@ -0,0 +1,122 @@
+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.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+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 = new 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;
+
+                Column ioColumn = new Column();
+                // 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())
+                            .alignX(io == IO.IN ? Alignment.TopLeft : Alignment.TopRight));
+                }
+
+                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.align(io == IO.IN ? Alignment.CenterLeft : Alignment.CenterRight));
+            }
+
+            // 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/recipe/ingredient/EnergyStack.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/EnergyStack.java
index 1c58ff062e1..2616bb60044 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/EnergyStack.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/EnergyStack.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.api.recipe.ingredient;
 
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.codec.GTCodecUtils;
+import com.gregtechceu.gtceu.utils.codec.GTCodecUtils;
 
 import net.minecraft.network.FriendlyByteBuf;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/IntCircuitIngredient.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/IntCircuitIngredient.java
index 619ca461b7e..7d1e32d3c78 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/IntCircuitIngredient.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/IntCircuitIngredient.java
@@ -2,7 +2,7 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.core.mixins.forge.StrictNBTIngredientAccessor;
 
 import net.minecraft.network.FriendlyByteBuf;
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..59bc6f3fb28 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
@@ -14,6 +14,8 @@
 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.mui.theme.ThemeAPI;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
@@ -144,6 +146,11 @@ public class MachineBuilder<DEFINITION extends MachineDefinition, TYPE extends M
     @Getter
     private boolean regressWhenWaiting = true;
     private boolean allowCoverOnFront = false;
+    @Getter
+    @Nullable
+    private PanelFactory ui = null;
+    @Getter
+    private String themeId = ThemeAPI.DEFAULT_ID;
     private Supplier<BlockState> appearance;
     @Getter // getter for KJS
     @Nullable
@@ -296,6 +303,11 @@ public TYPE appearance(Supplier<BlockState> appearance) {
         return getThis();
     }
 
+    public TYPE ui(PanelFactory ui) {
+        this.ui = ui;
+        return getThis();
+    }
+
     public TYPE editableUI(EditableMachineUI editableUI) {
         this.editableUI = editableUI;
         return getThis();
@@ -511,6 +523,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 +696,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);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/forge/GTFluidBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/forge/GTFluidBuilder.java
index a10731f6de1..58a63e5e6ba 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/forge/GTFluidBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/forge/GTFluidBuilder.java
@@ -3,9 +3,8 @@
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.fluids.FluidState;
 import com.gregtechceu.gtceu.api.fluids.GTFluid;
-import com.gregtechceu.gtceu.api.fluids.forge.GTFluidImpl;
-import com.gregtechceu.gtceu.api.item.GTBucketItem;
 import com.gregtechceu.gtceu.api.registry.registrate.IGTFluidBuilder;
+import com.gregtechceu.gtceu.common.item.GTBucketItem;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
@@ -60,7 +59,7 @@
 @Accessors(chain = true, fluent = true)
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
-public class GTFluidBuilder<P> extends AbstractBuilder<Fluid, GTFluidImpl.Flowing, P, GTFluidBuilder<P>>
+public class GTFluidBuilder<P> extends AbstractBuilder<Fluid, GTFluid.Flowing, P, GTFluidBuilder<P>>
                            implements IGTFluidBuilder {
 
     @Setter
@@ -150,7 +149,7 @@ public GTFluidBuilder<P> renderType(Supplier<RenderType> layer) {
     }
 
     @SuppressWarnings("deprecation")
-    protected void registerRenderType(GTFluidImpl.Flowing entry) {
+    protected void registerRenderType(GTFluid.Flowing entry) {
         DistExecutor.runWhenOn(Dist.CLIENT, () -> () -> {
             OneTimeEventReceiver.addModListener(getOwner(), FMLClientSetupEvent.class, $ -> {
                 if (this.layer != null) {
@@ -188,11 +187,11 @@ public BlockBuilder<LiquidBlock, GTFluidBuilder<P>> block() {
         return block(LiquidBlock::new);
     }
 
-    public <B extends LiquidBlock> BlockBuilder<B, GTFluidBuilder<P>> block(NonNullBiFunction<NonNullSupplier<GTFluidImpl.Flowing>, BlockBehaviour.Properties, ? extends B> factory) {
+    public <B extends LiquidBlock> BlockBuilder<B, GTFluidBuilder<P>> block(NonNullBiFunction<NonNullSupplier<GTFluid.Flowing>, BlockBehaviour.Properties, ? extends B> factory) {
         if (this.defaultBlock == Boolean.FALSE) {
             throw new IllegalStateException("Only one call to block/noBlock per builder allowed");
         }
-        NonNullSupplier<GTFluidImpl.Flowing> supplier = asSupplier();
+        NonNullSupplier<GTFluid.Flowing> supplier = asSupplier();
 
         return getOwner().<B, GTFluidBuilder<P>>block(this, sourceName, p -> factory.apply(supplier, p))
                 .properties(p -> BlockBehaviour.Properties.copy(Blocks.WATER).noLootTable())
@@ -284,8 +283,8 @@ private FluidType.Properties makeTypeProperties() {
     }
 
     @Override
-    protected GTFluidImpl.Flowing createEntry() {
-        return new GTFluidImpl.Flowing(this.state, () -> this.source.get(), () -> this.get().get(),
+    protected GTFluid.Flowing createEntry() {
+        return new GTFluid.Flowing(this.state, () -> this.source.get(), () -> this.get().get(),
                 (() -> this.block != null ? this.block.get() : null),
                 (() -> this.bucket != null ? this.bucket.get() : null), this.burnTime, this.fluidType);
     }
@@ -319,7 +318,7 @@ public IGTFluidBuilder onFluidRegister(Consumer<Fluid> fluidConsumer) {
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Override
-    public RegistryEntry<GTFluidImpl.Flowing> register() {
+    public RegistryEntry<GTFluid.Flowing> register() {
         // Check the fluid has a type.
         if (this.fluidType != null) {
             // Register the type.
@@ -331,7 +330,7 @@ public RegistryEntry<GTFluidImpl.Flowing> register() {
         }
 
         if (defaultSource == Boolean.TRUE) {
-            source(() -> new GTFluidImpl.Source(this.state, () -> this.source.get(), () -> this.get().get(),
+            source(() -> new GTFluid.Source(this.state, () -> this.source.get(), () -> this.get().get(),
                     (() -> this.block != null ? this.block.get() : null),
                     (() -> this.bucket != null ? this.bucket.get() : null), this.burnTime, this.fluidType));
         }
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 c16d2630b29..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
@@ -59,7 +59,7 @@ public CompoundTag serializeNBT(boolean writeClientFields, boolean fullSync) {
         CompoundTag tag = new CompoundTag();
         for (var field : fieldsToSerialize) {
             if (shouldSerializeField(field, writeClientFields, fullSync)) {
-                Tag nbtValue = serializeField(holder, field, writeClientFields);
+                Tag nbtValue = serializeField(holder, field, writeClientFields, fullSync);
                 tag.put(field.nbtSaveKey, nbtValue);
             }
         }
@@ -101,7 +101,7 @@ public void deserializeNBT(CompoundTag tag, boolean readingClientFields) {
 
     @SuppressWarnings("unchecked")
     private static Tag serializeField(ISyncManaged holder, FieldSyncData field,
-                                      boolean writeClientFields) {
+                                      boolean writeClientFields, boolean fullSync) {
         Object currentValue = field.handle.get(holder);
 
         if (!field.isSyncManaged && currentValue == null) {
@@ -115,9 +115,9 @@ private static Tag serializeField(ISyncManaged holder, FieldSyncData field,
             if (field.transformer != null) {
                 return ((ValueTransformer<Object>) field.transformer).serializeNBT(currentValue,
                         new ValueTransformer.TransformerContext<>(holder, field.type, currentValue, field.fieldName,
-                                writeClientFields));
+                                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);
@@ -150,7 +150,7 @@ private static void deserializeField(ISyncManaged holder, FieldSyncData field,
                 try {
                     var current = field.handle.get(holder);
                     Object result = transformer.deserializeNBT(savedValue, new ValueTransformer.TransformerContext<>(
-                            holder, field.type, current, field.fieldName, readingClientFields));
+                            holder, field.type, current, field.fieldName, readingClientFields, false));
                     if (result != current) {
                         field.handle.set(holder, result);
                     }
@@ -175,4 +175,20 @@ private static void deserializeField(ISyncManaged holder, FieldSyncData field,
             GTCEu.LOGGER.error(e);
         }
     }
+
+    public static class SyncManagedTransformer implements ValueTransformer<ISyncManaged> {
+
+        @Override
+        public Tag serializeNBT(ISyncManaged value, TransformerContext<ISyncManaged> context) {
+            return value.getSyncDataHolder().serializeNBT(context.isClientSync(), context.isClientFullSyncUpdate());
+        }
+
+        @Override
+        public @Nullable ISyncManaged deserializeNBT(Tag tag, TransformerContext<ISyncManaged> context) {
+            ISyncManaged syncManaged = context.currentValue();
+            Objects.requireNonNull(syncManaged).getSyncDataHolder().deserializeNBT((CompoundTag) tag,
+                    context.isClientSync());
+            return syncManaged;
+        }
+    }
 }
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 22a83bc1f86..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;
 
 /**
@@ -25,11 +24,12 @@ public interface ValueTransformer<T> {
      * @param fieldName    The name of the field being serialized, or a string denoting the current sync context if not
      *                     being invoked directly on a field.
      * @param isClientSync Whether NBT is currently being generated as part of a sync update to the client, not as NBT
-     *                     being
-     *                     written to the server save.
+     *                     being written to the server save.
+     *
      */
-    record TransformerContext<U>(@NotNull ISyncManaged holder, @NotNull TypeDeclaration type,
-                                 @Nullable U currentValue, @Nullable String fieldName, boolean isClientSync) {}
+    record TransformerContext<U>(ISyncManaged holder, TypeDeclaration type,
+                                 @Nullable U currentValue, @Nullable String fieldName, boolean isClientSync,
+                                 boolean isClientFullSyncUpdate) {}
 
     /**
      * Casts a given NBT tag to a specific tag type, throwing an error if the tag cannot be casted.
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformers.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformers.java
index 5a123341f30..09d3114fa7e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformers.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformers.java
@@ -6,6 +6,8 @@
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.api.sync_system.ISyncManaged;
+import com.gregtechceu.gtceu.api.sync_system.SyncDataHolder;
 import com.gregtechceu.gtceu.api.sync_system.TypeDeclaration;
 import com.gregtechceu.gtceu.api.sync_system.data_transformers.collections.ListTransformer;
 import com.gregtechceu.gtceu.api.sync_system.data_transformers.collections.MapTransformer;
@@ -177,6 +179,7 @@ public static <T> void registerTransformerSupplier(Class<T> type, Supplier<Value
                 }, StringTag.class);
 
         registerTransformer(INBTSerializable.class, new NBTSerializableTransformer());
+        registerTransformer(ISyncManaged.class, new SyncDataHolder.SyncManagedTransformer());
 
         registerTransformerSupplier(List.class, ListTransformer::new);
         registerTransformerSupplier(Map.class, MapTransformer::new);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ListTransformer.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ListTransformer.java
index aa217e318dd..5b041150889 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ListTransformer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ListTransformer.java
@@ -33,7 +33,7 @@ private ValueTransformer.TransformerContext<T> getInnerElemContext(@Nullable T e
                                                                        ValueTransformer.TransformerContext<List<T>> parentContext) {
         return new TransformerContext<>(parentContext.holder(),
                 parentContext.type().getGenericTypeArgs()[0], elem, parentContext.fieldName() + "[element]",
-                parentContext.isClientSync());
+                parentContext.isClientSync(), parentContext.isClientFullSyncUpdate());
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/MapTransformer.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/MapTransformer.java
index b66985a169e..56bc98b7644 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/MapTransformer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/MapTransformer.java
@@ -48,7 +48,7 @@ private ValueTransformer.TransformerContext<K> getInnerKeyContext(@Nullable K ke
                                                                       ValueTransformer.TransformerContext<Map<K, V>> parentContext) {
         return new TransformerContext<>(parentContext.holder(),
                 parentContext.type().getGenericTypeArgs()[0], key, parentContext.fieldName() + "[key]",
-                parentContext.isClientSync());
+                parentContext.isClientSync(), parentContext.isClientFullSyncUpdate());
     }
 
     private ValueTransformer.TransformerContext<V> getInnerValueContext(@Nullable V value,
@@ -56,7 +56,7 @@ private ValueTransformer.TransformerContext<V> getInnerValueContext(@Nullable V
         return new TransformerContext<>(parentContext.holder(),
                 parentContext.type().getGenericTypeArgs()[1], value,
                 parentContext.fieldName() + "[value]",
-                parentContext.isClientSync());
+                parentContext.isClientSync(), parentContext.isClientFullSyncUpdate());
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ObjectArrayTransformer.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ObjectArrayTransformer.java
index 1f665105fe0..85eb9fe50b6 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ObjectArrayTransformer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/ObjectArrayTransformer.java
@@ -23,7 +23,7 @@ private ValueTransformer.TransformerContext<T> getInnerElemContext(@Nullable T e
                                                                        ValueTransformer.TransformerContext<T[]> parentContext) {
         return new TransformerContext<>(parentContext.holder(),
                 parentContext.type().getArrayComponentType(), elem, parentContext.fieldName() + "[element]",
-                parentContext.isClientSync());
+                parentContext.isClientSync(), parentContext.isClientFullSyncUpdate());
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/SetTransformer.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/SetTransformer.java
index 94c03417653..12f80e4b9da 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/SetTransformer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/collections/SetTransformer.java
@@ -33,7 +33,7 @@ private ValueTransformer.TransformerContext<T> getInnerElemContext(@Nullable T e
                                                                        ValueTransformer.TransformerContext<Set<T>> parentContext) {
         return new TransformerContext<>(parentContext.holder(),
                 parentContext.type().getGenericTypeArgs()[0], elem, parentContext.fieldName() + "[element]",
-                parentContext.isClientSync());
+                parentContext.isClientSync(), parentContext.isClientSync());
     }
 
     @Override
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/forge/ForgeClientEventListener.java b/src/main/java/com/gregtechceu/gtceu/client/ClientEventListener.java
similarity index 97%
rename from src/main/java/com/gregtechceu/gtceu/client/forge/ForgeClientEventListener.java
rename to src/main/java/com/gregtechceu/gtceu/client/ClientEventListener.java
index dfccab975d2..fd7ab140609 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/forge/ForgeClientEventListener.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/ClientEventListener.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.client.forge;
+package com.gregtechceu.gtceu.client;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTValues;
@@ -6,8 +6,6 @@
 import com.gregtechceu.gtceu.api.cosmetics.CapeRegistry;
 import com.gregtechceu.gtceu.api.item.tool.ToolHelper;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.client.EnvironmentalHazardClientHandler;
-import com.gregtechceu.gtceu.client.TooltipsHandler;
 import com.gregtechceu.gtceu.client.renderer.BlockHighlightRenderer;
 import com.gregtechceu.gtceu.client.renderer.MultiblockInWorldPreviewRenderer;
 import com.gregtechceu.gtceu.client.renderer.cover.FacadeCoverRenderer;
@@ -52,7 +50,7 @@
 
 @Mod.EventBusSubscriber(modid = GTCEu.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE, value = Dist.CLIENT)
 @OnlyIn(Dist.CLIENT)
-public class ForgeClientEventListener {
+public class ClientEventListener {
 
     @SubscribeEvent
     public static void onRenderLevelStageEvent(RenderLevelStageEvent event) {
diff --git a/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java b/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java
index c4bc0f934da..49f63209df7 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java
@@ -6,15 +6,15 @@
 import com.gregtechceu.gtceu.api.data.worldgen.GTOreDefinition;
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockfluid.BedrockFluidDefinition;
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockore.BedrockOreDefinition;
-import com.gregtechceu.gtceu.api.item.DrumMachineItem;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.IGTTool;
-import com.gregtechceu.gtceu.api.item.LampBlockItem;
-import com.gregtechceu.gtceu.api.item.QuantumTankMachineItem;
+import com.gregtechceu.gtceu.api.mui.animation.AnimatorManager;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableSerialization;
 import com.gregtechceu.gtceu.client.model.item.FacadeUnbakedModel;
 import com.gregtechceu.gtceu.client.model.machine.MachineModelLoader;
 import com.gregtechceu.gtceu.client.model.pipe.PipeModel;
 import com.gregtechceu.gtceu.client.model.pipe.PipeModelLoader;
+import com.gregtechceu.gtceu.client.mui.CursorHandler;
 import com.gregtechceu.gtceu.client.particle.HazardParticle;
 import com.gregtechceu.gtceu.client.particle.MufflerParticle;
 import com.gregtechceu.gtceu.client.renderer.block.MaterialBlockRenderer;
@@ -32,18 +32,18 @@
 import com.gregtechceu.gtceu.client.renderer.machine.DynamicRenderManager;
 import com.gregtechceu.gtceu.client.renderer.machine.impl.*;
 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;
+import com.gregtechceu.gtceu.common.item.LampBlockItem;
+import com.gregtechceu.gtceu.common.item.QuantumTankMachineItem;
 import com.gregtechceu.gtceu.common.machine.owner.MachineOwner;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.model.builder.PipeModelBuilder;
 import com.gregtechceu.gtceu.data.pack.event.RegisterDynamicResourcesEvent;
-import com.gregtechceu.gtceu.forge.ForgeCommonEventListener;
 import com.gregtechceu.gtceu.integration.kjs.GregTechKubeJSPlugin;
 import com.gregtechceu.gtceu.integration.map.ClientCacheManager;
 import com.gregtechceu.gtceu.integration.map.cache.client.GTClientCache;
@@ -54,6 +54,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 +68,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,14 +92,27 @@ public ClientProxy() {
 
     public static void init() {
         if (!GTCEu.isDataGen()) {
+            CursorHandler.init();
+            AnimatorManager.init();
+            DrawableSerialization.init();
+
             ClientCacheManager.registerClientCache(GTClientCache.instance, "gtceu");
             Layers.registerLayer(OreRenderLayer::new, "ore_veins");
             Layers.registerLayer(FluidRenderLayer::new, "bedrock_fluids");
-            ForgeCommonEventListener.registerCapes(new RegisterGTCapesEvent());
+            CommonEventListener.registerCapes(new RegisterGTCapesEvent());
         }
         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/ModClientEventListener.java b/src/main/java/com/gregtechceu/gtceu/client/ModClientEventListener.java
new file mode 100644
index 00000000000..299b6e35e60
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/ModClientEventListener.java
@@ -0,0 +1,30 @@
+package com.gregtechceu.gtceu.client;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.client.mui.screen.ContainerScreenWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+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;
+
+@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/mui/CursorHandler.java b/src/main/java/com/gregtechceu/gtceu/client/mui/CursorHandler.java
new file mode 100644
index 00000000000..12a621273e1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/CursorHandler.java
@@ -0,0 +1,122 @@
+package com.gregtechceu.gtceu.client.mui;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.widget.ResizeDragArea;
+
+import net.minecraft.client.Minecraft;
+
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.glfw.GLFW;
+import org.lwjgl.glfw.GLFWErrorCallback;
+import org.lwjgl.glfw.GLFWImage;
+
+import java.awt.image.BufferedImage;
+import java.nio.ByteBuffer;
+
+public class CursorHandler {
+
+    // the normal pointer cursor
+    public static long CURSOR_NORMAL;
+    // text input cursor
+    // usually I-beam shaped
+    public static long CURSOR_TEXT_INPUT;
+    // crosshair cursor
+    public static long CURSOR_CROSSHAIR;
+    // "hovering over a clickable object" cursor
+    // usually a pointing finger
+    public static long CURSOR_POINT_HOVERED;
+    // "operation not allowed" cursor
+    // usually a circle with a line through it
+    public static long CURSOR_NOT_ALLOWED;
+
+    // left to right resize cursor
+    public static long CURSOR_RESIZE_HORIZONTAL;
+    // top to down resize cursor
+    public static long CURSOR_RESIZE_VERTICAL;
+    // top right to bottom left resize cursor
+    public static long CURSOR_RESIZE_TR_BL;
+    // top-left to bottom right resize cursor
+    public static long CURSOR_RESIZE_TL_BR;
+    // omnidirectional resize cursor
+    // has arrows up-down and left-right
+    public static long CURSOR_RESIZE_ALL;
+
+    private static long windowHandle;
+
+    public static void setCursorResizeIcon(@Nullable ResizeDragArea dragArea) {
+        if (dragArea == null) {
+            resetCursorIcon();
+            return;
+        }
+        long cursor = switch (dragArea) {
+            case TOP_LEFT, BOTTOM_RIGHT -> CURSOR_RESIZE_TL_BR;
+            case TOP_RIGHT, BOTTOM_LEFT -> CURSOR_RESIZE_TR_BL;
+            case TOP, BOTTOM -> CURSOR_RESIZE_VERTICAL;
+            case RIGHT, LEFT -> CURSOR_RESIZE_HORIZONTAL;
+        };
+        GLFW.glfwSetCursor(windowHandle, cursor);
+    }
+
+    public static void resetCursorIcon() {
+        GLFW.glfwSetCursor(windowHandle, CURSOR_NORMAL);
+    }
+
+    public static long createSafeCursor(int shape) {
+        try (GLFWErrorCallback ignored = org.lwjgl.glfw.GLFW.glfwSetErrorCallback(null)) {
+            long cursor = GLFW.glfwCreateStandardCursor(shape);
+            if (cursor == 0L) { // If can't load platform-specific default cursors
+                GTCEu.LOGGER.warn("GLFW: Failed to create standard cursor shape {}. Falling back to default pointer.",
+                        shape);
+                // TODO: Load custom textures
+                return 0L;
+            }
+            return cursor;
+        }
+    }
+
+    public static void init() {
+        windowHandle = Minecraft.getInstance().getWindow().getWindow();
+
+        // load platform-specific default cursors (instead of using custom textures)
+
+        // GLFW will switch to the default cursor when 0 is passed into glfwSetCursor
+        CURSOR_NORMAL = createSafeCursor(GLFW.GLFW_ARROW_CURSOR);
+        CURSOR_TEXT_INPUT = createSafeCursor(GLFW.GLFW_IBEAM_CURSOR);
+        CURSOR_CROSSHAIR = createSafeCursor(GLFW.GLFW_CROSSHAIR_CURSOR);
+        CURSOR_POINT_HOVERED = createSafeCursor(GLFW.GLFW_POINTING_HAND_CURSOR);
+        CURSOR_NOT_ALLOWED = createSafeCursor(GLFW.GLFW_NOT_ALLOWED_CURSOR);
+
+        CURSOR_RESIZE_HORIZONTAL = createSafeCursor(GLFW.GLFW_RESIZE_EW_CURSOR);
+        CURSOR_RESIZE_VERTICAL = createSafeCursor(GLFW.GLFW_RESIZE_NS_CURSOR);
+        CURSOR_RESIZE_TR_BL = createSafeCursor(GLFW.GLFW_RESIZE_NESW_CURSOR);
+        CURSOR_RESIZE_TL_BR = createSafeCursor(GLFW.GLFW_RESIZE_NWSE_CURSOR);
+        CURSOR_RESIZE_ALL = createSafeCursor(GLFW.GLFW_RESIZE_ALL_CURSOR);
+    }
+
+    public static GLFWImage readGLImage(BufferedImage img, boolean inverse, boolean transpose) {
+        int size = img.getHeight();
+        ByteBuffer buffer = ByteBuffer.allocate(4 * size * size);
+        int y = inverse ? 0 : size - 1;
+        while (inverse ? y < size : y >= 0) {
+            for (int x = 0; x < size; x++) {
+                int x0, y0;
+                if (transpose) {
+                    x0 = y;
+                    y0 = x;
+                } else {
+                    x0 = x;
+                    y0 = y;
+                }
+                int argb = img.getRGB(x0, y0);
+                buffer.putInt(argb);
+            }
+            if (inverse) y++;
+            else y--;
+        }
+        buffer.flip();
+
+        GLFWImage image = GLFWImage.malloc();
+        image.width(size).height(size).pixels(buffer);
+        return image;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/component/DrawableTooltipComponent.java b/src/main/java/com/gregtechceu/gtceu/client/mui/component/DrawableTooltipComponent.java
new file mode 100644
index 00000000000..f1d6e34e6d6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/component/DrawableTooltipComponent.java
@@ -0,0 +1,57 @@
+package com.gregtechceu.gtceu.client.mui.component;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.world.inventory.tooltip.TooltipComponent;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+public class DrawableTooltipComponent implements ClientTooltipComponent, TooltipComponent {
+
+    @Getter
+    private final IDrawable drawable;
+
+    public DrawableTooltipComponent(IDrawable drawable) {
+        this.drawable = drawable;
+    }
+
+    @Override
+    public int getHeight() {
+        if (drawable instanceof IIcon icon) {
+            return icon.getHeight();
+        } else if (drawable instanceof IKey key) {
+            return key.asTextIcon().getHeight();
+        } else {
+            return 18;
+        }
+    }
+
+    @Override
+    public int getWidth(@NotNull Font font) {
+        if (drawable instanceof IIcon icon) {
+            return icon.getWidth();
+        } else if (drawable instanceof IKey key) {
+            return key.asTextIcon().getWidth();
+        } else {
+            return 18;
+        }
+    }
+
+    @Override
+    public void renderImage(@NotNull Font font, int x, int y, @NotNull GuiGraphics guiGraphics) {
+        GuiContext context = GuiContext.getDefault();
+        GuiGraphics lastGraphics = context.getGraphics();
+
+        context.setGraphics(guiGraphics);
+        drawable.draw(context, x, y, getWidth(font), getHeight(), WidgetTheme.getDefault().getTheme());
+        context.setGraphics(lastGraphics);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/component/FormattedTextContents.java b/src/main/java/com/gregtechceu/gtceu/client/mui/component/FormattedTextContents.java
new file mode 100644
index 00000000000..6fc576edf98
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/component/FormattedTextContents.java
@@ -0,0 +1,23 @@
+package com.gregtechceu.gtceu.client.mui.component;
+
+import net.minecraft.network.chat.ComponentContents;
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.network.chat.Style;
+
+import org.jetbrains.annotations.NotNullByDefault;
+
+import java.util.Optional;
+
+@NotNullByDefault
+public record FormattedTextContents(FormattedText text) implements ComponentContents {
+
+    @Override
+    public <R> Optional<R> visit(FormattedText.ContentConsumer<R> acceptor) {
+        return text.visit(acceptor);
+    }
+
+    @Override
+    public <R> Optional<R> visit(FormattedText.StyledContentConsumer<R> acceptor, Style style) {
+        return text.visit(acceptor, style);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/component/TooltipComponentIcon.java b/src/main/java/com/gregtechceu/gtceu/client/mui/component/TooltipComponentIcon.java
new file mode 100644
index 00000000000..c08b0c299d1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/component/TooltipComponentIcon.java
@@ -0,0 +1,74 @@
+package com.gregtechceu.gtceu.client.mui.component;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IIcon;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Box;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.world.inventory.tooltip.TooltipComponent;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+public class TooltipComponentIcon implements IIcon {
+
+    @Getter
+    private final ClientTooltipComponent clientComponent;
+
+    public TooltipComponentIcon(TooltipComponent component) {
+        this.clientComponent = ClientTooltipComponent.create(component);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public TooltipComponentIcon(ClientTooltipComponent clientComponent) {
+        this.clientComponent = clientComponent;
+    }
+
+    @Override
+    public @Nullable IDrawable getWrappedDrawable() {
+        return null;
+    }
+
+    @Override
+    public int getWidth() {
+        return clientComponent.getWidth(Minecraft.getInstance().font);
+    }
+
+    @Override
+    public int getHeight() {
+        return clientComponent.getHeight();
+    }
+
+    @Override
+    public Box getMargin() {
+        return Box.ZERO;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        Font font = context.getFont();
+        context.graphicsPose().pushPose();
+
+        // rescale the tooltip component if we happen to go out of its bounds
+        float ratio = 1.0f;
+        if (width < clientComponent.getWidth(font)) {
+            ratio = (float) width / clientComponent.getWidth(font);
+        }
+        if (height < clientComponent.getHeight()) {
+            ratio = Math.min(ratio, (float) height / clientComponent.getHeight());
+        }
+        if (ratio != 1.0f) {
+            context.graphicsPose().scale(ratio, ratio, 1.0f);
+        }
+        clientComponent.renderImage(font, x, y, context.getGraphics());
+
+        context.graphicsPose().popPose();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/BaseSchemaRenderer.java b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/BaseSchemaRenderer.java
new file mode 100644
index 00000000000..eca0c6f05ef
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/BaseSchemaRenderer.java
@@ -0,0 +1,658 @@
+package com.gregtechceu.gtceu.client.mui.schemarenderer;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.schema.ISchema;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widgets.SchemaWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.client.util.RenderUtil;
+import com.gregtechceu.gtceu.integration.embeddium.GTEmbeddiumCompat;
+import com.gregtechceu.gtceu.utils.GTMatrixUtils;
+
+import net.minecraft.CrashReport;
+import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.*;
+import net.minecraft.client.renderer.block.ModelBlockRenderer;
+import net.minecraft.client.renderer.texture.OverlayTexture;
+import net.minecraft.client.renderer.texture.TextureAtlas;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.SectionPos;
+import net.minecraft.util.Mth;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ClipContext;
+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.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.client.extensions.common.IClientFluidTypeExtensions;
+import net.minecraftforge.client.model.data.ModelData;
+
+import com.google.common.collect.Lists;
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.platform.Window;
+import com.mojang.blaze3d.shaders.FogShape;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.*;
+import it.unimi.dsi.fastutil.objects.ObjectArraySet;
+import it.unimi.dsi.fastutil.objects.Reference2ObjectArrayMap;
+import it.unimi.dsi.fastutil.objects.Reference2ObjectLinkedOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ReferenceArraySet;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+import org.lwjgl.opengl.GL11;
+
+import java.util.*;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+
+/**
+ * World rendering is based on Applied energistics 2's <a href=
+ * "https://github.com/AppliedEnergistics/Applied-Energistics-2/blob/643dfe2e7e16dac48192d85305d35e2e74a64fb0/src/main/java/appeng/client/guidebook/scene/GuidebookLevelRenderer.java">GuidebookLevelRenderer</a>
+ * (LGPLv3)
+ */
+@Accessors(fluent = true)
+public class BaseSchemaRenderer implements IDrawable {
+
+    private static final DummyLightTexture lightTexture = new DummyLightTexture();
+
+    @Getter
+    private final ISchema schema;
+    private final RenderLevel renderLevel;
+    private @Nullable RenderCompileTask lastRenderCompileTask = null;
+    @Getter
+    private final Camera camera = new Camera();
+    private final int[] viewport = { 0, 0, 0, 0 };
+    @Getter
+    private @Nullable BlockHitResult lastRayTrace = null;
+
+    private final ChunkBufferBuilderPack chunkBufferBuilders;
+
+    private final AtomicReference<RenderCompileResults> compileResults = new AtomicReference<>();
+    private final AtomicReference<CompileStatus> compileStatus = new AtomicReference<>(CompileStatus.CANCELED);
+    private @Nullable Map<RenderType, VertexBuffer> chunkBuffers = getOrCreateChunkBuffers();
+
+    public BaseSchemaRenderer(ISchema schema) {
+        this.schema = schema;
+        this.renderLevel = new RenderLevel(schema);
+        this.chunkBufferBuilders = new ChunkBufferBuilderPack();
+    }
+
+    protected @NotNull Map<RenderType, VertexBuffer> getOrCreateChunkBuffers() {
+        if (this.chunkBuffers == null || this.chunkBuffers.isEmpty()) {
+            List<RenderType> chunkRenderTypes = RenderType.chunkBufferLayers();
+            this.chunkBuffers = new Reference2ObjectLinkedOpenHashMap<>();
+            for (RenderType type : chunkRenderTypes) {
+                this.chunkBuffers.put(type, new VertexBuffer(VertexBuffer.Usage.STATIC));
+            }
+        }
+
+        return this.chunkBuffers;
+    }
+
+    public void clearChunkBuffers() {
+        if (this.lastRenderCompileTask != null) {
+            this.lastRenderCompileTask.cancel();
+            this.lastRenderCompileTask = null;
+        }
+        if (this.chunkBuffers != null && !this.chunkBuffers.isEmpty()) {
+            this.chunkBuffers.values().forEach(VertexBuffer::close);
+            this.chunkBuffers.clear();
+        }
+    }
+
+    public void recompile() {
+        clearChunkBuffers();
+        this.compileStatus.set(CompileStatus.COMPILING);
+        this.lastRenderCompileTask = new RenderCompileTask();
+
+        CompletableFuture.supplyAsync(
+                Util.wrapThreadWithTaskName("scm_chk_rebuild", this.lastRenderCompileTask::compileBlockBuffers),
+                Util.backgroundExecutor())
+                .thenCompose(Function.identity())
+                .whenComplete((result, error) -> {
+                    if (error != null) {
+                        Minecraft.getInstance().delayCrash(CrashReport.forThrowable(error, "Batching chunks"));
+                    } else {
+                        if (result != CompileStatus.CANCELED && result != CompileStatus.DISABLED) {
+                            this.chunkBufferBuilders.clearAll();
+                        } else {
+                            this.chunkBufferBuilders.discardAll();
+                        }
+                        this.compileStatus.set(result);
+                    }
+                });
+    }
+
+    public void dispose() {
+        clearChunkBuffers();
+
+        this.chunkBufferBuilders.discardAll();
+        this.compileStatus.set(CompileStatus.DISABLED);
+    }
+
+    @Override
+    public SchemaWidget asWidget() {
+        return new SchemaWidget(this);
+    }
+
+    @Override
+    public Icon asIcon() {
+        return IDrawable.super.asIcon().size(50);
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        int mouseX = context.getMouseX();
+        int mouseY = context.getMouseY();
+
+        context.getGraphics().flush();
+        context.graphicsPose().pushPose();
+        // context.getStencil().push(x, y, width, height);
+
+        Window window = Minecraft.getInstance().getWindow();
+        double guiScale = window.getGuiScale();
+        this.viewport[0] = Mth.ceil(context.transformX(x, y) * guiScale);
+        this.viewport[1] = window.getHeight() - Mth.ceil((context.transformY(x, y) + height) * guiScale);
+        this.viewport[2] = Mth.ceil(width * guiScale);
+        this.viewport[3] = Mth.ceil(height * guiScale);
+
+        RenderSystem.viewport(this.viewport[0], this.viewport[1], this.viewport[2], this.viewport[3]);
+
+        onSetupCamera();
+        setupCamera(width, height);
+        renderWorld(context.getGraphics().bufferSource(), context.getPartialTicks());
+
+        if (doRayTrace()) {
+            BlockHitResult result = null;
+            if (Area.isInside(x, y, width, height, mouseX, mouseY)) {
+                result = rayTrace(mouseX, mouseY, width, height);
+            }
+            if (result == null || result.getType() != HitResult.Type.BLOCK) {
+                if (this.lastRayTrace != null) {
+                    onRayTraceFailed();
+                }
+            } else {
+                onSuccessfulRayTrace(context.graphicsPose(), result);
+            }
+            this.lastRayTrace = result;
+        }
+
+        resetCamera();
+        context.graphicsPose().popPose();
+        // context.getStencil().pop();
+    }
+
+    @SuppressWarnings("deprecation")
+    public void renderWorld(MultiBufferSource.BufferSource bufferSource, float partialTick) {
+        CompileStatus status = this.compileStatus.get();
+        if (status == CompileStatus.DISABLED || status == CompileStatus.COMPILING) {
+            return;
+        } else if (status == CompileStatus.CANCELED) {
+            recompile();
+            return;
+        }
+
+        // Essentially disable level fog
+        RenderSystem.setShaderFogColor(1, 1, 1, 0);
+        RenderSystem.setShaderFogStart(0);
+        RenderSystem.setShaderFogEnd(1000);
+        RenderSystem.setShaderFogShape(FogShape.SPHERE);
+
+        lightTexture.update(this.renderLevel);
+        LevelLightEngine lightEngine = this.renderLevel.getLightEngine();
+        while (lightEngine.hasLightWork()) {
+            lightEngine.runLightUpdates();
+        }
+
+        Lighting.setupLevel(RenderSystem.getModelViewMatrix());
+
+        RenderSystem.disableDepthTest();
+        RenderSystem.clear(GL11.GL_DEPTH_BUFFER_BIT, Minecraft.ON_OSX);
+        RenderSystem.runAsFancy(() -> {
+            // The order comes from LevelRenderer#renderLevel
+
+            renderBlocks(RenderType.solid());
+            // FORGE: fix flickering leaves when mods mess up the blurMipmap settings
+            Minecraft.getInstance().getModelManager().getAtlas(TextureAtlas.LOCATION_BLOCKS)
+                    .setBlurMipmap(false, Minecraft.getInstance().options.mipmapLevels().get() > 0);
+            renderBlocks(RenderType.cutoutMipped());
+            Minecraft.getInstance().getModelManager().getAtlas(TextureAtlas.LOCATION_BLOCKS).restoreLastBlurMipmap();
+            renderBlocks(RenderType.cutout());
+
+            bufferSource.endBatch(RenderType.entitySolid(TextureAtlas.LOCATION_BLOCKS));
+            bufferSource.endBatch(RenderType.entityCutout(TextureAtlas.LOCATION_BLOCKS));
+            bufferSource.endBatch(RenderType.entityCutoutNoCull(TextureAtlas.LOCATION_BLOCKS));
+            bufferSource.endBatch(RenderType.entitySmoothCutout(TextureAtlas.LOCATION_BLOCKS));
+
+            if (isBEREnabled()) {
+                renderBlockEntities(bufferSource, partialTick);
+            }
+
+            bufferSource.endBatch(RenderType.solid());
+            bufferSource.endBatch(RenderType.endPortal());
+            bufferSource.endBatch(RenderType.endGateway());
+            bufferSource.endBatch(Sheets.solidBlockSheet());
+            bufferSource.endBatch(Sheets.cutoutBlockSheet());
+            bufferSource.endBatch(Sheets.bedSheet());
+            bufferSource.endBatch(Sheets.shulkerBoxSheet());
+            bufferSource.endBatch(Sheets.signSheet());
+            bufferSource.endBatch(Sheets.hangingSignSheet());
+            bufferSource.endBatch(Sheets.chestSheet());
+            bufferSource.endLastBatch();
+
+            renderBlocks(RenderType.translucent());
+            renderBlocks(RenderType.tripwire());
+        });
+        RenderSystem.enableDepthTest();
+    }
+
+    protected void renderBlocks(RenderType renderType) {
+        renderType.setupRenderState();
+        ModelBlockRenderer.enableCaching();
+
+        // set up shader uniforms
+        ShaderInstance shader = RenderSystem.getShader();
+        assert shader != null;
+
+        for (int i = 0; i < GlStateManager.TEXTURE_COUNT; ++i) {
+            int textureId = RenderSystem.getShaderTexture(i);
+            shader.setSampler("Sampler" + i, textureId);
+        }
+
+        if (shader.MODEL_VIEW_MATRIX != null) {
+            shader.MODEL_VIEW_MATRIX.set(RenderSystem.getModelViewMatrix());
+        }
+
+        if (shader.PROJECTION_MATRIX != null) {
+            shader.PROJECTION_MATRIX.set(RenderSystem.getProjectionMatrix());
+        }
+
+        if (shader.INVERSE_VIEW_ROTATION_MATRIX != null) {
+            shader.INVERSE_VIEW_ROTATION_MATRIX.set(RenderSystem.getInverseViewRotationMatrix());
+        }
+
+        if (shader.COLOR_MODULATOR != null) {
+            shader.COLOR_MODULATOR.set(RenderSystem.getShaderColor());
+        }
+
+        if (shader.GLINT_ALPHA != null) {
+            shader.GLINT_ALPHA.set(RenderSystem.getShaderGlintAlpha());
+        }
+
+        if (shader.FOG_START != null) {
+            shader.FOG_START.set(RenderSystem.getShaderFogStart());
+        }
+
+        if (shader.FOG_END != null) {
+            shader.FOG_END.set(RenderSystem.getShaderFogEnd());
+        }
+
+        if (shader.FOG_COLOR != null) {
+            shader.FOG_COLOR.set(RenderSystem.getShaderFogColor());
+        }
+
+        if (shader.FOG_SHAPE != null) {
+            shader.FOG_SHAPE.set(RenderSystem.getShaderFogShape().getIndex());
+        }
+
+        if (shader.TEXTURE_MATRIX != null) {
+            shader.TEXTURE_MATRIX.set(RenderSystem.getTextureMatrix());
+        }
+
+        if (shader.GAME_TIME != null) {
+            shader.GAME_TIME.set(RenderSystem.getShaderGameTime());
+        }
+
+        if (shader.SCREEN_SIZE != null) {
+            Window window = Minecraft.getInstance().getWindow();
+            shader.SCREEN_SIZE.set((float) window.getWidth(), (float) window.getHeight());
+        }
+
+        if (shader.CHUNK_OFFSET != null) {
+            shader.CHUNK_OFFSET.set(-camera.pos().x, -camera.pos().y, -camera.pos().z);
+        }
+
+        RenderSystem.setupShaderLights(shader);
+        shader.apply();
+
+        // actually draw the chunk
+        RenderCompileResults compileResults = this.compileResults.get();
+        if (compileResults != null && !compileResults.isEmpty(renderType)) {
+            if (GTCEu.Mods.isSodiumRubidiumEmbeddiumLoaded()) {
+                GTEmbeddiumCompat.markSpritesAsActive(compileResults.activeFluidSprites);
+            }
+
+            VertexBuffer vertexBuffer = getOrCreateChunkBuffers().get(renderType);
+            // check if the buffer is invalid in case someone breaks it
+            // noinspection ConstantValue
+            if (vertexBuffer.isInvalid() || vertexBuffer.getFormat() == null) return;
+
+            vertexBuffer.bind();
+            vertexBuffer.draw();
+        }
+
+        shader.clear();
+        VertexBuffer.unbind();
+        renderType.clearRenderState();
+    }
+
+    protected void renderBlockEntities(MultiBufferSource bufferSource, float partialTick) {
+        PoseStack poseStack = new PoseStack();
+
+        RenderCompileResults compileResults = this.compileResults.get();
+        if (compileResults == null) {
+            return;
+        }
+        for (BlockEntity blockEntity : compileResults.blockEntities) {
+            if (blockEntity != null) {
+                this.handleBlockEntity(poseStack, bufferSource, partialTick, blockEntity);
+            }
+        }
+    }
+
+    protected <E extends BlockEntity> void handleBlockEntity(PoseStack poseStack, MultiBufferSource bufferSource,
+                                                             float partialTick, E blockEntity) {
+        var dispatcher = Minecraft.getInstance().getBlockEntityRenderDispatcher();
+        var renderer = dispatcher.getRenderer(blockEntity);
+        if (renderer == null) {
+            return;
+        }
+        BlockPos pos = blockEntity.getBlockPos();
+        poseStack.pushPose();
+        poseStack.translate(pos.getX() - camera.pos().x, pos.getY() - camera.pos().y, pos.getZ() - camera.pos().z);
+
+        // noinspection DataFlowIssue
+        int packedLight = LevelRenderer.getLightColor(blockEntity.getLevel(), blockEntity.getBlockPos());
+        renderer.render(blockEntity, partialTick, poseStack, bufferSource, packedLight, OverlayTexture.NO_OVERLAY);
+        poseStack.popPose();
+    }
+
+    protected void setupCamera(int width, int height) {
+        // setup viewport and clear GL buffers
+        int clearColor = getClearColor();
+        RenderSystem.clearColor(Color.getRedF(clearColor), Color.getGreenF(clearColor), Color.getBlueF(clearColor),
+                Color.getAlphaF(clearColor));
+        RenderSystem.backupProjectionMatrix();
+
+        float near = 0.05f;
+        float far = 10000.0f;
+        float fovY = 60.0f * Mth.DEG_TO_RAD; // Field of view in the Y direction
+        float aspect = (float) width / height; // width and height are the dimensions of your window
+        float top = -near * (float) Math.tan(fovY * 0.5);
+        float bottom = -top;
+        float left = aspect * bottom;
+        float right = aspect * top;
+        Matrix4f projection = new Matrix4f();
+        if (isIsometric()) {
+            projection.setOrtho(left, right, bottom, top, near, far);
+            RenderSystem.setProjectionMatrix(projection, VertexSorting.ORTHOGRAPHIC_Z);
+        } else {
+            projection.setPerspective(fovY, aspect, near, far);
+            RenderSystem.setProjectionMatrix(projection, VertexSorting.byDistance(camera.pos()));
+        }
+
+        // set up model view matrix
+        PoseStack modelViewStack = RenderSystem.getModelViewStack();
+        modelViewStack.pushPose();
+        modelViewStack.setIdentity();
+        if (isIsometric()) {
+            // see GameRenderer:935
+            // Vanilla uses a -2000 z translation for isometric rendering
+            modelViewStack.translate(0.0f, 0.0f, -2000.0f);
+        }
+        GTMatrixUtils.lookAt(modelViewStack, this.camera.pos(), this.camera.lookAt());
+
+        RenderSystem.applyModelViewMatrix();
+    }
+
+    protected void resetCamera() {
+        // reset viewport
+        Window window = Minecraft.getInstance().getWindow();
+        RenderSystem.viewport(0, 0, window.getWidth(), window.getHeight());
+
+        // restore projection matrix
+        RenderSystem.restoreProjectionMatrix();
+
+        // restore model view matrix
+        RenderSystem.getModelViewStack().popPose();
+        RenderSystem.applyModelViewMatrix();
+    }
+
+    /**
+     * Traces a ray from the given mouse pos into the rendered scene.
+     *
+     * @param mouseX A mouse x pos from 0 to width
+     * @param mouseY A mouse y pos from 0 to height
+     * @param width  Height of the drawn framebuffer
+     * @param height Width of the drawn framebuffer
+     * @return raytrace result
+     */
+    protected BlockHitResult rayTrace(int mouseX, int mouseY, int width, int height) {
+        // transform mouse pos into relative mouse pos from 0 - 1
+        Vector3f worldPos = screenToWorldPos((float) mouseX / width, (float) mouseY / height);
+        Vector3f target = this.camera.getLookVec().mul(20).add(worldPos);
+        ClipContext context = new ClipContext(new Vec3(worldPos), new Vec3(target), ClipContext.Block.OUTLINE,
+                ClipContext.Fluid.ANY, null);
+        return this.renderLevel.clip(context);
+    }
+
+    /**
+     * Converts a relative screen space position to a world space position in the preview.
+     *
+     * @param x X pos from 0 to 1
+     * @param y Y pos from 0 to 1
+     * @return world pos
+     */
+    protected Vector3f screenToWorldPos(float x, float y) {
+        // convert relative pos to framebuffer pos
+        int wx = (int) (x * this.viewport[2]);
+        int wy = (int) (y * this.viewport[3]);
+        return GTMatrixUtils.projectScreenToWorld(wx, wy, this.viewport, true);
+    }
+
+    @ApiStatus.OverrideOnly
+    protected void onSetupCamera() {}
+
+    @ApiStatus.OverrideOnly
+    protected void onRendered() {}
+
+    @ApiStatus.OverrideOnly
+    protected void onSuccessfulRayTrace(PoseStack poseStack, @NotNull BlockHitResult result) {}
+
+    @ApiStatus.OverrideOnly
+    protected void onRayTraceFailed() {}
+
+    public boolean doRayTrace() {
+        return false;
+    }
+
+    public int getClearColor() {
+        return Color.withAlpha(Color.WHITE.main, 0.5f);
+    }
+
+    public boolean isIsometric() {
+        return false;
+    }
+
+    public boolean isBEREnabled() {
+        return true;
+    }
+
+    protected enum CompileStatus {
+        DISABLED,
+        COMPILING,
+        SUCCESS,
+        CANCELED
+    }
+
+    protected class RenderCompileTask {
+
+        private final AtomicBoolean isCanceled = new AtomicBoolean(false);
+
+        public void cancel() {
+            this.isCanceled.set(true);
+        }
+
+        protected CompletableFuture<CompileStatus> compileBlockBuffers() {
+            if (this.isCanceled.get()) {
+                return CompletableFuture.completedFuture(CompileStatus.CANCELED);
+            }
+
+            var blockRenderDispatcher = Minecraft.getInstance().getBlockRenderer();
+            ChunkBufferBuilderPack chunkBufferBuilders = BaseSchemaRenderer.this.chunkBufferBuilders;
+
+            RenderCompileResults compileResults = new RenderCompileResults();
+            RandomSource randomSource = RandomSource.create();
+            PoseStack poseStack = new PoseStack();
+            Set<RenderType> startedBuffers = new ReferenceArraySet<>(RenderType.chunkBufferLayers().size());
+
+            ModelBlockRenderer.enableCaching();
+            for (var blockEntry : BaseSchemaRenderer.this.schema) {
+                BlockPos pos = blockEntry.getKey();
+                BlockState blockState = blockEntry.getValue();
+                FluidState fluidState = blockState.getFluidState();
+
+                if (blockState.hasBlockEntity()) {
+                    BlockEntity blockEntity = BaseSchemaRenderer.this.renderLevel.getBlockEntity(pos);
+                    if (blockEntity != null) {
+                        compileResults.blockEntities.add(blockEntity);
+                    }
+                }
+
+                if (!fluidState.isEmpty()) {
+                    RenderType renderType = ItemBlockRenderTypes.getRenderLayer(fluidState);
+                    BufferBuilder builder = chunkBufferBuilders.builder(renderType);
+                    if (startedBuffers.add(renderType)) {
+                        builder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.BLOCK);
+                    }
+
+                    SectionPos sectionPos = SectionPos.of(pos);
+                    VertexConsumer vertexConsumer = new LiquidVertexConsumer(builder, sectionPos);
+                    blockRenderDispatcher.renderLiquid(pos, BaseSchemaRenderer.this.renderLevel, vertexConsumer,
+                            blockState, fluidState);
+
+                    markFluidSpritesActive(compileResults, fluidState);
+                }
+
+                if (blockState.getRenderShape() != RenderShape.INVISIBLE) {
+                    BakedModel model = blockRenderDispatcher.getBlockModel(blockState);
+
+                    BlockEntity blockEntity = BaseSchemaRenderer.this.renderLevel.getBlockEntity(pos);
+                    ModelData modelData = ModelData.EMPTY;
+                    if (blockEntity != null) {
+                        modelData = blockEntity.getModelData();
+                    }
+                    modelData = model.getModelData(BaseSchemaRenderer.this.renderLevel, pos, blockState, modelData);
+
+                    randomSource.setSeed(blockState.getSeed(pos));
+
+                    for (RenderType renderType : model.getRenderTypes(blockState, randomSource, modelData)) {
+                        BufferBuilder builder = chunkBufferBuilders.builder(renderType);
+                        if (startedBuffers.add(renderType)) {
+                            builder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.BLOCK);
+                        }
+
+                        poseStack.pushPose();
+                        poseStack.translate(pos.getX(), pos.getY(), pos.getZ());
+                        blockRenderDispatcher.renderBatched(blockState, pos, BaseSchemaRenderer.this.renderLevel,
+                                poseStack, builder, true, randomSource, modelData, renderType);
+                        poseStack.popPose();
+                    }
+                }
+            }
+
+            if (startedBuffers.contains(RenderType.translucent())) {
+                BufferBuilder bufferBuilder = chunkBufferBuilders.builder(RenderType.translucent());
+                if (!bufferBuilder.isCurrentBatchEmpty()) {
+                    bufferBuilder.setQuadSorting(VertexSorting.byDistance(camera.pos()));
+                }
+            }
+
+            for (RenderType rendertype : startedBuffers) {
+                BufferBuilder.RenderedBuffer renderedBuffer = chunkBufferBuilders.builder(rendertype)
+                        .endOrDiscardIfEmpty();
+                if (renderedBuffer != null) {
+                    compileResults.renderedLayers.put(rendertype, renderedBuffer);
+                }
+            }
+            ModelBlockRenderer.clearCache();
+
+            if (this.isCanceled.get()) {
+                compileResults.renderedLayers.values().forEach(BufferBuilder.RenderedBuffer::release);
+                return CompletableFuture.completedFuture(CompileStatus.CANCELED);
+            }
+
+            List<CompletableFuture<Void>> uploads = Lists.newArrayList();
+            compileResults.renderedLayers.forEach((renderType, buffer) -> {
+                uploads.add(uploadChunkLayer(buffer, renderType));
+                compileResults.hasBlocks.add(renderType);
+            });
+            return Util.sequenceFailFast(uploads).handle((result, error) -> {
+                if (error != null && !(error instanceof CancellationException) &&
+                        !(error instanceof InterruptedException)) {
+                    Minecraft.getInstance().delayCrash(CrashReport.forThrowable(error, "Rendering chunk"));
+                }
+
+                if (this.isCanceled.get()) {
+                    return CompileStatus.CANCELED;
+                } else {
+                    BaseSchemaRenderer.this.compileResults.set(compileResults);
+                    return CompileStatus.SUCCESS;
+                }
+            });
+        }
+
+        protected CompletableFuture<Void> uploadChunkLayer(BufferBuilder.RenderedBuffer builder,
+                                                           RenderType renderType) {
+            return CompletableFuture.runAsync(() -> {
+                VertexBuffer buffer = getOrCreateChunkBuffers().get(renderType);
+                if (!buffer.isInvalid()) {
+                    buffer.bind();
+                    buffer.upload(builder);
+                    VertexBuffer.unbind();
+                }
+            }, runnable -> RenderSystem.recordRenderCall(runnable::run));
+        }
+
+        protected static void markFluidSpritesActive(RenderCompileResults compileResults, FluidState fluidState) {
+            // For Sodium compatibility, ensure the sprites actually animate
+            // even if no block is on-screen that would cause them to, otherwise.
+            var props = IClientFluidTypeExtensions.of(fluidState);
+            compileResults.activeFluidSprites.add(RenderUtil.FluidTextureType.STILL.map(props));
+            compileResults.activeFluidSprites.add(RenderUtil.FluidTextureType.FLOWING.map(props));
+        }
+    }
+
+    protected static class RenderCompileResults {
+
+        protected final List<BlockEntity> blockEntities = new ArrayList<>();
+        protected final Map<RenderType, BufferBuilder.RenderedBuffer> renderedLayers = new Reference2ObjectArrayMap<>();
+        protected final Set<TextureAtlasSprite> activeFluidSprites = new HashSet<>();
+
+        protected final Set<RenderType> hasBlocks = new ObjectArraySet<>(RenderType.chunkBufferLayers().size());
+
+        public boolean isEmpty(RenderType renderType) {
+            return !this.hasBlocks.contains(renderType);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/BlockHighlight.java b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/BlockHighlight.java
new file mode 100644
index 00000000000..a5be170ba8a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/BlockHighlight.java
@@ -0,0 +1,186 @@
+package com.gregtechceu.gtceu.client.mui.schemarenderer;
+
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.*;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+@Accessors(fluent = true, chain = true)
+public class BlockHighlight {
+
+    // rendnering magic
+
+    protected static final float[][] vertices = new float[6][12];
+    static {
+        int[][] intVertices = {
+                { 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0 },
+                { 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0 },
+                { 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0 },
+                { 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1 },
+                { 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0 },
+                { 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0 }
+        };
+        for (int i = 0; i < 6; i++) {
+            for (int j = 0; j < 12; j++) {
+                int v = intVertices[i][j];
+                vertices[i][j] = v == 1 ? 1.005f : -0.005f;
+            }
+        }
+    }
+
+    @Getter
+    @Setter
+    private int color;
+
+    @Getter
+    @Setter
+    private boolean allSides;
+
+    @Getter
+    @Setter
+    private float thickness;
+
+    public BlockHighlight(int color) {
+        this(color, true);
+    }
+
+    public BlockHighlight(int color, float frameThickness) {
+        this(color, true, frameThickness);
+    }
+
+    public BlockHighlight(int color, boolean allSides) {
+        this(color, allSides, 0.0f);
+    }
+
+    public BlockHighlight(int color, boolean allSides, float frameThickness) {
+        this.color = color;
+        this.allSides = allSides;
+        this.thickness = frameThickness;
+    }
+
+    public final void renderHighlight(PoseStack pose, @Nullable BlockHitResult result, Vector3f camera) {
+        if (result != null && result.getType() == HitResult.Type.BLOCK) {
+            renderHighlight(pose, result.getBlockPos(), result.getDirection(), camera);
+        }
+    }
+
+    public void renderHighlight(PoseStack poseStack, BlockPos pos, Direction direction, Vector3f camera) {
+        RenderSystem.disableDepthTest();
+        RenderSystem.enableBlend();
+        RenderSystem.setShader(GameRenderer::getPositionShader);
+        RenderSystem.setShaderColor(1, 1, 1, 1);
+        Color.setGlColor(this.color);
+        poseStack.pushPose();
+        poseStack.translate(pos.getX(), pos.getY(), pos.getZ());
+
+        float distance = camera.distance(pos.getX() + 0.5f, pos.getY() + 0.5f, pos.getZ() + 0.5f);
+        doRender(poseStack, direction, distance);
+        poseStack.popPose();
+        RenderSystem.enableCull();
+        RenderSystem.enableDepthTest();
+    }
+
+    protected void doRender(PoseStack poseStack, @Nullable Direction direction, float distance) {
+        if (this.allSides) direction = null;
+        Matrix4f pose = poseStack.last().pose();
+        if (this.thickness >= 0) {
+            // scale frame thickness with distance to camera
+            float offset = (float) (this.thickness * (1 + Math.max(0, Math.sqrt(distance) - 3) / 5.0f));
+            renderFrame(pose, direction, offset);
+        } else {
+            renderSolid(pose, direction);
+        }
+    }
+
+    public static void renderSolid(Matrix4f pose, @Nullable Direction direction) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder builder = tesselator.getBuilder();
+        builder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION);
+        if (direction == null) {
+            for (Direction dir : GTUtil.DIRECTIONS) {
+                buildFace(pose, builder, dir);
+            }
+        } else {
+            buildFace(pose, builder, direction);
+        }
+    }
+
+    protected static void renderFrame(Matrix4f pose, @Nullable Direction side, float offset) {
+        if (side == null) {
+            for (Direction dir : GTUtil.DIRECTIONS) {
+                buildFrameFace(pose, dir, offset);
+            }
+        } else {
+            buildFrameFace(pose, side, offset);
+        }
+    }
+
+    protected static void buildFrameFace(Matrix4f pose, @NotNull Direction side, float offset) {
+        float[] vert = vertices[side.get3DDataValue()];
+
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder builder = tesselator.getBuilder();
+        builder.begin(VertexFormat.Mode.TRIANGLE_STRIP, DefaultVertexFormat.POSITION);
+        buildVertex(pose, builder, vert, 9);
+        buildInnerVertex(pose, builder, vert, 9, side, offset);
+        buildVertex(pose, builder, vert, 6);
+        buildInnerVertex(pose, builder, vert, 6, side, offset);
+        buildVertex(pose, builder, vert, 3);
+        buildInnerVertex(pose, builder, vert, 3, side, offset);
+        buildVertex(pose, builder, vert, 0);
+        buildInnerVertex(pose, builder, vert, 0, side, offset);
+        buildVertex(pose, builder, vert, 9);
+        buildInnerVertex(pose, builder, vert, 9, side, offset);
+
+        BufferUploader.drawWithShader(builder.end());
+    }
+
+    protected static void buildVertex(Matrix4f pose, BufferBuilder builder, float[] vertices, int vertexIndex) {
+        float x = vertices[vertexIndex];
+        float y = vertices[vertexIndex + 1];
+        float z = vertices[vertexIndex + 2];
+        builder.vertex(pose, x, y, z).endVertex();
+    }
+
+    private static void buildInnerVertex(Matrix4f pose, BufferBuilder builder, float[] vertices, int vertexIndex,
+                                         @NotNull Direction side, float offset) {
+        float x = vertices[vertexIndex];
+        float y = vertices[vertexIndex + 1];
+        float z = vertices[vertexIndex + 2];
+        if (side.getAxis() != Direction.Axis.X) {
+            if (x >= 1) x -= offset;
+            else x += offset;
+        }
+        if (side.getAxis() != Direction.Axis.Y) {
+            if (y >= 1) y -= offset;
+            else y += offset;
+        }
+        if (side.getAxis() != Direction.Axis.Z) {
+            if (z >= 1) z -= offset;
+            else z += offset;
+        }
+        builder.vertex(pose, x, y, z).endVertex();
+    }
+
+    protected static void buildFace(Matrix4f pose, BufferBuilder builder, @NotNull Direction side) {
+        float[] vert = vertices[side.ordinal()];
+        buildVertex(pose, builder, vert, 0);
+        buildVertex(pose, builder, vert, 3);
+        buildVertex(pose, builder, vert, 6);
+        buildVertex(pose, builder, vert, 9);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/Camera.java b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/Camera.java
new file mode 100644
index 00000000000..7fe5acd2d0c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/Camera.java
@@ -0,0 +1,141 @@
+package com.gregtechceu.gtceu.client.mui.schemarenderer;
+
+import net.minecraft.core.Vec3i;
+import net.minecraft.util.Mth;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
+
+import static net.minecraft.util.Mth.HALF_PI;
+
+@Accessors(fluent = true)
+public class Camera {
+
+    @Getter
+    private final Vector3f pos = new Vector3f();
+    @Getter
+    private final Vector3f lookAt = new Vector3f();
+    private final Vector3f temp = new Vector3f();
+    @Getter
+    private float yaw;
+    @Getter
+    private float pitch;
+    @Getter
+    private float dist;
+
+    public Camera() {}
+
+    public Camera setPosAndLookAt(Vector3f pos, Vector3f lookAt) {
+        return setPosAndLookAt(pos.x, pos.y, pos.z, lookAt.x, lookAt.y, lookAt.z);
+    }
+
+    public Camera setPosAndLookAt(float xPos, float yPos, float zPos, Vector3f lookAt) {
+        return setPosAndLookAt(xPos, yPos, zPos, lookAt.x, lookAt.y, lookAt.z);
+    }
+
+    public Camera setPosAndLookAt(Vector3f pos, float xLook, float yLook, float zLook) {
+        return setPosAndLookAt(pos.x, pos.y, pos.z, xLook, yLook, zLook);
+    }
+
+    public Camera setPosAndLookAt(float xPos, float yPos, float zPos, float xLook, float yLook, float zLook) {
+        this.pos.set(xPos, yPos, zPos);
+        this.lookAt.set(xLook, yLook, zLook);
+        Vector3f v = this.temp.set(lookAt).sub(pos).normalize();
+        this.yaw = (float) Math.atan2(-v.x, v.z);
+        this.pitch = (float) Math.asin(-v.y);
+        this.dist = pos.distance(lookAt);
+        return this;
+    }
+
+    public Camera setLookAtKeepPos(float x, float y, float z) {
+        setPosAndLookAt(this.pos, x, y, z);
+        return this;
+    }
+
+    public Camera setLookAtKeepAngle(float x, float y, float z) {
+        // just calculate the offset
+        this.temp.set(x, y, z);
+        this.temp.sub(this.lookAt, this.temp);
+        this.pos.add(this.temp);
+        this.lookAt.set(this.temp);
+        return this;
+    }
+
+    public Camera setPosKeepLookAt(float x, float y, float z) {
+        return setPosAndLookAt(x, y, z, this.lookAt);
+    }
+
+    public Camera setPosKeepAngle(float x, float y, float z) {
+        // just calculate the offset
+        this.temp.set(x, y, z);
+        this.temp.sub(this.pos, this.temp);
+        this.lookAt.add(this.temp);
+        this.pos.set(this.temp);
+        return this;
+    }
+
+    public Camera setAngleKeepLookAt(float radius, float yaw, float pitch) {
+        return setLookAtAndAngle(this.lookAt, radius, yaw, pitch);
+    }
+
+    public Camera setLookAtAndAngle(Vector3f lookAt, float radius, float yaw, float pitch) {
+        return setLookAtAndAngle(lookAt.x, lookAt.y, lookAt.z, radius, yaw, pitch);
+    }
+
+    public Camera setLookAtAndAngle(Vec3i lookAt, float radius, float yaw, float pitch) {
+        return setLookAtAndAngle(lookAt.getX(), lookAt.getY(), lookAt.getZ(), radius, yaw, pitch);
+    }
+
+    public Camera setLookAtAndAngle(float lookAtX, float lookAtY, float lookAtZ, float dist, float yaw, float pitch) {
+        this.lookAt.set(lookAtX, lookAtY, lookAtZ);
+        this.yaw = yaw;
+        this.pitch = pitch;
+        this.dist = dist;
+        Vector3f v = this.temp;
+        v.set(Mth.cos(yaw), 0, Mth.sin(yaw));
+        v.y = ((float) Math.tan(pitch)) * v.length();
+        v.normalize().mul(dist);
+        this.pos.set(v.add(lookAtX, lookAtY, lookAtZ));
+        return this;
+    }
+
+    public Camera setPosAndAngle(float posX, float posY, float posZ, float dist, float yaw, float pitch) {
+        this.pos.set(posX, posY, posZ);
+        this.yaw = yaw;
+        this.pitch = pitch;
+        this.dist = dist;
+        Vector3f v = this.temp;
+        v.set(Mth.cos(HALF_PI - yaw), 0, Mth.sin(HALF_PI - yaw));
+        v.y = ((float) Math.tan(HALF_PI - pitch)) * v.length();
+        v.normalize().mul(dist);
+        this.lookAt.set(v).add(this.pos);
+        return this;
+    }
+
+    public void setDistanceKeepLookAt(float dist) {
+        if (dist == this.dist) return;
+        this.dist = dist;
+        this.pos.sub(this.lookAt, this.temp);
+        this.temp.normalize().mul(dist);
+        this.lookAt.sub(this.temp, this.pos);
+    }
+
+    public void scaleDistanceKeepLookAt(float dist) {
+        if (dist == 1) return;
+        this.dist *= dist;
+        this.pos.sub(this.lookAt, this.temp);
+        this.temp.mul(dist);
+        this.lookAt.add(this.temp, this.pos);
+    }
+
+    public Vector3f getLookVec() {
+        return getLookVec(null);
+    }
+
+    public Vector3f getLookVec(@Nullable Vector3f dest) {
+        if (dest == null) dest = new Vector3f();
+        return lookAt.sub(pos, dest);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/DummyLightTexture.java b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/DummyLightTexture.java
new file mode 100644
index 00000000000..c3d2449ef84
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/DummyLightTexture.java
@@ -0,0 +1,116 @@
+package com.gregtechceu.gtceu.client.mui.schemarenderer;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.client.renderer.texture.DynamicTexture;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.LevelTimeAccess;
+import net.minecraft.world.level.lighting.LightEngine;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import com.mojang.blaze3d.systems.RenderSystem;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+import org.lwjgl.opengl.GL11;
+
+import java.util.Objects;
+
+/**
+ * A version of {@link LightTexture} that's independent of the current client level.
+ * <p>
+ * Most of the class is based on the vanilla light texture, and the remaining parts are from Applied energistics 2's
+ * <a href=
+ * "https://github.com/AppliedEnergistics/Applied-Energistics-2/blob/643dfe2e7e16dac48192d85305d35e2e74a64fb0/src/main/java/appeng/client/guidebook/scene/GuidebookLightmap.java">GuidebookLightmap</a>
+ * (LGPLv3)
+ * </p>
+ */
+public class DummyLightTexture implements AutoCloseable {
+
+    private static final Vector3fc THREE_FOURTHS = new Vector3f(0.75f, 0.75f, 0.75f);
+
+    private final DynamicTexture lightmapTexture;
+    private final NativeImage lightmapPixels;
+
+    public DummyLightTexture() {
+        lightmapTexture = new DynamicTexture(16, 16, false);
+        lightmapPixels = Objects.requireNonNull(lightmapTexture.getPixels());
+        lightmapPixels.fillRect(0, 0, 16, 16, -1);
+        lightmapTexture.upload();
+    }
+
+    public static float getSkyDarken(LevelTimeAccess level, float partialTick) {
+        var f = level.getTimeOfDay(partialTick);
+        var g = 1.0f - (Mth.cos(f * Mth.TWO_PI) * 2.0f + 0.2F);
+        g = Mth.clamp(g, 0.0f, 1.0f);
+        g = 1.0f - g;
+        return 0.2f + g * 0.8f;
+    }
+
+    public void update(LevelTimeAccess level) {
+        float skyDarkness = getSkyDarken(level, 1.0f);
+        float partDarken = Mth.lerp(0.35f, skyDarkness, 1.0f);
+        float skyBrightMul = skyDarkness * 0.95f + 0.05f;
+        float blockBrightMul = 1.5f;
+        float gamma = Minecraft.getInstance().options.gamma().get().floatValue();
+
+        Vector3f color = new Vector3f();
+
+        for (int skyLightLvl = 0; skyLightLvl <= LightEngine.MAX_LEVEL; ++skyLightLvl) {
+            for (int blockLightLvl = 0; blockLightLvl <= LightEngine.MAX_LEVEL; ++blockLightLvl) {
+                float skyLuma = LightTexture.getBrightness(level.dimensionType(), skyLightLvl) * skyBrightMul;
+                float blockLuma = LightTexture.getBrightness(level.dimensionType(), blockLightLvl) * blockBrightMul;
+
+                color.set(blockLuma,
+                        blockLuma * rescale(rescale(blockLuma)),
+                        blockLuma * blockLuma * rescale(blockLuma));
+
+                Vector3f skyColor = new Vector3f(partDarken, partDarken, 1.0f).mul(skyLuma);
+                color.add(skyColor);
+                color.lerp(THREE_FOURTHS, 0.04f);
+
+                Vector3f noGammaColor = new Vector3f(notGamma(color.x), notGamma(color.y), notGamma(color.z));
+                color.lerp(noGammaColor, Math.max(0.0f, gamma));
+                color.lerp(THREE_FOURTHS, 0.04f);
+
+                clampColor(color);
+                color.mul(255.0f);
+
+                int r = (int) color.x();
+                int g = (int) color.y();
+                int b = (int) color.z();
+                lightmapPixels.setPixelRGBA(blockLightLvl, skyLightLvl, 0xFF000000 | b << 16 | g << 8 | r);
+            }
+        }
+
+        lightmapTexture.upload();
+    }
+
+    private static void clampColor(Vector3f color) {
+        color.set(Mth.clamp(color.x, 0.0f, 1.0f),
+                Mth.clamp(color.y, 0.0f, 1.0f),
+                Mth.clamp(color.z, 0.0f, 1.0f));
+    }
+
+    private float notGamma(float value) {
+        float f = 1.0f - value;
+        return 1.0f - f * f * f * f;
+    }
+
+    // map a 0.0-1.0 range to 0.4-1.0
+    private float rescale(float value) {
+        return value * 0.6f + 0.4f;
+    }
+
+    public void bind() {
+        RenderSystem.setShaderTexture(2, lightmapTexture.getId());
+        lightmapTexture.bind();
+        RenderSystem.texParameter(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
+        RenderSystem.texParameter(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
+        RenderSystem.setShaderColor(1, 1, 1, 1);
+    }
+
+    @Override
+    public void close() {
+        lightmapTexture.close();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/LiquidVertexConsumer.java b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/LiquidVertexConsumer.java
new file mode 100644
index 00000000000..c08bb678f8a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/LiquidVertexConsumer.java
@@ -0,0 +1,128 @@
+package com.gregtechceu.gtceu.client.mui.schemarenderer;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.core.SectionPos;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import org.joml.Matrix3f;
+import org.joml.Matrix4f;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+/**
+ * The only purpose of this vertex consumer proxy is to transform vertex positions emitted by the
+ * {@link net.minecraft.client.renderer.block.LiquidBlockRenderer} into absolute coordinates. The renderer assumes it is
+ * being called in the context of tessellating a chunk section (16x16x16) and emits corresponding coordinates, while we
+ * batch all visible chunks in schemas together.
+ */
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class LiquidVertexConsumer implements VertexConsumer {
+
+    private final VertexConsumer delegate;
+    private final SectionPos sectionPos;
+
+    public LiquidVertexConsumer(VertexConsumer delegate, SectionPos sectionPos) {
+        this.delegate = delegate;
+        this.sectionPos = sectionPos;
+    }
+
+    @Override
+    public VertexConsumer vertex(double x, double y, double z) {
+        x += sectionPos.getX() * SectionPos.SECTION_SIZE;
+        y += sectionPos.getY() * SectionPos.SECTION_SIZE;
+        z += sectionPos.getZ() * SectionPos.SECTION_SIZE;
+
+        return delegate.vertex(x, y, z);
+    }
+
+    @Override
+    public VertexConsumer color(int red, int green, int blue, int alpha) {
+        return delegate.color(red, green, blue, alpha);
+    }
+
+    @Override
+    public VertexConsumer uv(float u, float v) {
+        return delegate.uv(u, v);
+    }
+
+    @Override
+    public VertexConsumer overlayCoords(int u, int v) {
+        return delegate.overlayCoords(u, v);
+    }
+
+    @Override
+    public VertexConsumer uv2(int u, int v) {
+        return delegate.uv2(u, v);
+    }
+
+    @Override
+    public VertexConsumer normal(float x, float y, float z) {
+        return delegate.normal(x, y, z);
+    }
+
+    @Override
+    public void endVertex() {
+        delegate.endVertex();
+    }
+
+    @Override
+    public void vertex(float x, float y, float z, float red, float green, float blue, float alpha, float texU,
+                       float texV, int overlayUV, int lightmapUV, float normalX, float normalY, float normalZ) {
+        delegate.vertex(x, y, z, red, green, blue, alpha, texU, texV, overlayUV, lightmapUV, normalX, normalY, normalZ);
+    }
+
+    @Override
+    public void defaultColor(int red, int green, int blue, int alpha) {
+        delegate.defaultColor(red, green, blue, alpha);
+    }
+
+    @Override
+    public void unsetDefaultColor() {
+        delegate.unsetDefaultColor();
+    }
+
+    @Override
+    public VertexConsumer color(float red, float green, float blue, float alpha) {
+        return delegate.color(red, green, blue, alpha);
+    }
+
+    @Override
+    public VertexConsumer color(int i) {
+        return delegate.color(i);
+    }
+
+    @Override
+    public VertexConsumer uv2(int lightmapUV) {
+        return delegate.uv2(lightmapUV);
+    }
+
+    @Override
+    public VertexConsumer overlayCoords(int overlayUV) {
+        return delegate.overlayCoords(overlayUV);
+    }
+
+    @Override
+    public void putBulkData(PoseStack.Pose poseEntry, BakedQuad quad, float red, float green, float blue,
+                            int combinedLight, int combinedOverlay) {
+        delegate.putBulkData(poseEntry, quad, red, green, blue, combinedLight, combinedOverlay);
+    }
+
+    @Override
+    public void putBulkData(PoseStack.Pose poseEntry, BakedQuad quad, float[] colorMuls, float red, float green,
+                            float blue, int[] combinedLights, int combinedOverlay, boolean mulColor) {
+        delegate.putBulkData(poseEntry, quad, colorMuls, red, green, blue, combinedLights, combinedOverlay, mulColor);
+    }
+
+    @Override
+    public VertexConsumer vertex(Matrix4f matrix4f, float f, float g, float h) {
+        return delegate.vertex(matrix4f, f, g, h);
+    }
+
+    @Override
+    public VertexConsumer normal(Matrix3f matrix3f, float f, float g, float h) {
+        return delegate.normal(matrix3f, f, g, h);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/RenderLevel.java b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/RenderLevel.java
new file mode 100644
index 00000000000..8bfd00bdd9e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/schemarenderer/RenderLevel.java
@@ -0,0 +1,166 @@
+package com.gregtechceu.gtceu.client.mui.schemarenderer;
+
+import com.gregtechceu.gtceu.api.mui.schema.ISchema;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.core.*;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.flag.FeatureFlagSet;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelTimeAccess;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeManager;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.border.WorldBorder;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.material.Fluids;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class RenderLevel implements LevelTimeAccess {
+
+    private final ISchema schema;
+    private final Level level;
+
+    private final Thread thread;
+
+    public RenderLevel(ISchema schema) {
+        this.schema = schema;
+        this.level = schema.getLevel();
+
+        this.thread = Thread.currentThread();
+    }
+
+    @Nullable
+    @Override
+    public BlockEntity getBlockEntity(BlockPos pos) {
+        BlockState state = this.level.getBlockState(pos);
+        if (!this.schema.getRenderFilter().test(pos, state)) {
+            return null;
+        }
+        // avoid the level
+        if (Thread.currentThread() != this.thread) {
+            int chunkX = SectionPos.blockToSectionCoord(pos.getX());
+            int chunkZ = SectionPos.blockToSectionCoord(pos.getZ());
+            var chunk = this.level.getChunkForCollisions(chunkX, chunkZ);
+            if (chunk == null) {
+                return null;
+            }
+            return chunk.getBlockEntity(pos);
+        }
+        return this.level.getBlockEntity(pos);
+    }
+
+    @Override
+    public BlockState getBlockState(BlockPos pos) {
+        BlockState state = this.level.getBlockState(pos);
+        if (!this.schema.getRenderFilter().test(pos, state)) {
+            return Blocks.AIR.defaultBlockState();
+        }
+        return state;
+    }
+
+    @Override
+    public FluidState getFluidState(BlockPos pos) {
+        BlockState state = this.level.getBlockState(pos);
+        if (!this.schema.getRenderFilter().test(pos, state)) {
+            return Fluids.EMPTY.defaultFluidState();
+        }
+        return this.level.getFluidState(pos);
+    }
+
+    @Override
+    public @Nullable ChunkAccess getChunk(int x, int z, ChunkStatus requiredStatus, boolean nonnull) {
+        return level.getChunk(x, z, requiredStatus, nonnull);
+    }
+
+    @Override
+    public boolean hasChunk(int chunkX, int chunkZ) {
+        return level.hasChunk(chunkX, chunkZ);
+    }
+
+    @Override
+    public int getHeight(Heightmap.Types heightmapType, int x, int z) {
+        return level.getHeight(heightmapType, x, z);
+    }
+
+    @Override
+    public int getSkyDarken() {
+        return level.getSkyDarken();
+    }
+
+    @Override
+    public BiomeManager getBiomeManager() {
+        return level.getBiomeManager();
+    }
+
+    @Override
+    public Holder<Biome> getUncachedNoiseBiome(int x, int y, int z) {
+        return level.getUncachedNoiseBiome(x, y, z);
+    }
+
+    @Override
+    public boolean isClientSide() {
+        return level.isClientSide();
+    }
+
+    @Override
+    public int getSeaLevel() {
+        return level.getSeaLevel();
+    }
+
+    @Override
+    public DimensionType dimensionType() {
+        return level.dimensionType();
+    }
+
+    @Override
+    public RegistryAccess registryAccess() {
+        return level.registryAccess();
+    }
+
+    @Override
+    public FeatureFlagSet enabledFeatures() {
+        return level.enabledFeatures();
+    }
+
+    @Override
+    public float getShade(Direction direction, boolean shade) {
+        return level.getShade(direction, shade);
+    }
+
+    @Override
+    public LevelLightEngine getLightEngine() {
+        return level.getLightEngine();
+    }
+
+    @Override
+    public WorldBorder getWorldBorder() {
+        return level.getWorldBorder();
+    }
+
+    @Override
+    public List<VoxelShape> getEntityCollisions(@Nullable Entity entity, AABB collisionBox) {
+        return level.getEntityCollisions(entity, collisionBox);
+    }
+
+    @Override
+    public long dayTime() {
+        return level.dayTime();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ClientScreenHandler.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ClientScreenHandler.java
new file mode 100644
index 00000000000..c625569e8eb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ClientScreenHandler.java
@@ -0,0 +1,756 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.GuiErrorHandler;
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.widget.IVanillaSlot;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.overlay.OverlayStack;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.FpsCounter;
+import com.gregtechceu.gtceu.api.mui.utils.Stencil;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widgets.RichTextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.LocatedWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.core.mixins.client.AbstractContainerScreenAccessor;
+import com.gregtechceu.gtceu.core.mixins.client.ScreenAccessor;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeViewerHandler;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.Renderable;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.util.Mth;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.ContainerScreenEvent;
+import net.minecraftforge.client.event.ScreenEvent;
+import net.minecraftforge.client.extensions.common.IClientItemExtensions;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.TickEvent;
+import net.minecraftforge.eventbus.api.EventPriority;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+import org.joml.Matrix4f;
+import org.lwjgl.opengl.GL11;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+@ApiStatus.Internal
+@Mod.EventBusSubscriber(modid = GTCEu.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE, value = Dist.CLIENT)
+public class ClientScreenHandler {
+
+    @Getter
+    private static final GuiContext defaultContext = new GuiContext();
+    private static final FpsCounter fpsCounter = new FpsCounter();
+    private static ModularScreen currentScreen = null;
+    @Getter
+    private static long ticks = 0L;
+    private static IMuiScreen lastMui;
+    private static final ObjectArrayList<IMuiScreen> muiStack = new ObjectArrayList<>(8);
+
+    private static boolean debugToggleActive = false;
+
+    // we need to know the actual gui and not some fake screen some other mod overwrites
+    @SubscribeEvent(priority = EventPriority.LOWEST)
+    public static void onOpenScreen(ScreenEvent.Opening event) {
+        onGuiChanged(event.getCurrentScreen(), event.getNewScreen());
+    }
+
+    public static void onCloseScreens(Screen closing) {
+        // called when the next screen is null, so that the player returns to the world
+        // we cant use ScreenEvent.Closing since that's also called when transitioning screens
+        onGuiChanged(closing, null);
+    }
+
+    @SubscribeEvent
+    public static void onInitScreenPost(ScreenEvent.Init.Post event) {
+        defaultContext.updateScreenArea(event.getScreen().width, event.getScreen().height);
+        if (validateGui(event.getScreen())) {
+            currentScreen.onResize(event.getScreen().width, event.getScreen().height);
+        }
+        OverlayStack.foreach(ms -> ms.onResize(event.getScreen().width, event.getScreen().height), false);
+    }
+
+    @SubscribeEvent
+    public static void onScreenKeyPressedHigh(ScreenEvent.KeyPressed.Pre event) {
+        defaultContext.updateLatestKey(event.getKeyCode(), event.getScanCode(), event.getModifiers());
+        // TODO: early needs to be before recipe viewers, but emi does mixin into KeyboardHandler so it is before
+        // everything
+        if (keyPressedEvent(event, InputPhase.EARLY)) {
+            keyPressedEvent(event, InputPhase.LATE);
+        }
+    }
+
+    private static boolean keyPressedEvent(ScreenEvent.KeyPressed.Pre event, InputPhase phase) {
+        if (validateGui(event.getScreen())) {
+            currentScreen.getContext().updateLatestKey(event.getKeyCode(), event.getScanCode(), event.getModifiers());
+        }
+        if (handleKeyboardInput(currentScreen, event.getScreen(), true, phase,
+                event.getKeyCode(), event.getScanCode(), event.getModifiers())) {
+            event.setCanceled(true);
+            return false;
+        }
+        return true;
+    }
+
+    @SubscribeEvent
+    public static void onScreenKeyReleasedHigh(ScreenEvent.KeyReleased.Pre event) {
+        defaultContext.updateLatestKey(event.getKeyCode(), event.getScanCode(), event.getModifiers());
+        // TODO also needs to be before recipe viewers
+        // dont need late for release event
+        keyReleasedEvent(event, InputPhase.EARLY);
+    }
+
+    private static boolean keyReleasedEvent(ScreenEvent.KeyReleased.Pre event, InputPhase phase) {
+        if (validateGui(event.getScreen())) {
+            currentScreen.getContext().updateLatestKey(event.getKeyCode(), event.getScanCode(), event.getModifiers());
+        }
+        if (handleKeyboardInput(currentScreen, event.getScreen(), false, phase,
+                event.getKeyCode(), event.getScanCode(), event.getModifiers())) {
+            event.setCanceled(true);
+            return false;
+        }
+        return true;
+    }
+
+    // before JEI
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public static void onScreenCharTyped(ScreenEvent.CharacterTyped.Pre event) {
+        int codePoint = event.getCodePoint();
+        int modifiers = event.getModifiers();
+        defaultContext.updateLatestTypedChar(codePoint, modifiers);
+        if (validateGui(event.getScreen())) currentScreen.getContext().updateLatestTypedChar(codePoint, modifiers);
+
+        // vanilla also casts to char here
+        if (doAction(currentScreen, ms -> ms.charTyped((char) codePoint, modifiers))) {
+            event.setCanceled(true);
+        }
+    }
+
+    // before JEI
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public static void onScreenMousePressed(ScreenEvent.MouseButtonPressed.Pre event) {
+        int button = event.getButton();
+        double mouseX = event.getMouseX();
+        double mouseY = event.getMouseY();
+        defaultContext.updateMouseButton(button);
+        if (validateGui(event.getScreen())) currentScreen.getContext().updateMouseButton(button);
+
+        if (button == -1) {
+            return;
+        }
+        if (currentScreen != null && currentScreen.handleDraggableInput(mouseX, mouseY, button, true) ||
+                doAction(currentScreen, ms -> ms.onMousePressed(mouseX, mouseY, button))) {
+            RecipeViewerHandler.getCurrent().setSearchFocused(false);
+            event.setCanceled(true);
+        }
+    }
+
+    // before JEI
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public static void onScreenMouseReleased(ScreenEvent.MouseButtonReleased.Pre event) {
+        int button = event.getButton();
+        double mouseX = event.getMouseX();
+        double mouseY = event.getMouseY();
+        defaultContext.updateMouseButton(button);
+        if (validateGui(event.getScreen())) currentScreen.getContext().updateMouseButton(button);
+
+        if (currentScreen != null && currentScreen.handleDraggableInput(mouseX, mouseY, button, false) ||
+                doAction(currentScreen, ms -> ms.mouseReleased(mouseX, mouseY, button))) {
+            RecipeViewerHandler.getCurrent().setSearchFocused(false);
+            event.setCanceled(true);
+        }
+    }
+
+    // before JEI
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public static void onScreenMouseScrolled(ScreenEvent.MouseScrolled.Pre event) {
+        double w = event.getScrollDelta();
+        if (w == 0) return;
+        defaultContext.updateMouseWheel(w);
+        if (validateGui(event.getScreen())) currentScreen.getContext().updateMouseWheel(w);
+
+        if (doAction(currentScreen, ms -> ms.mouseScrolled(event.getMouseX(), event.getMouseY(), w))) {
+            event.setCanceled(true);
+        }
+    }
+
+    // before JEI
+    @SubscribeEvent(priority = EventPriority.HIGH)
+    public static void onScreenMouseDragged(ScreenEvent.MouseDragged.Pre event) {
+        if (doAction(currentScreen, ms -> ms.mouseDragged(event.getMouseX(), event.getMouseY(),
+                event.getMouseButton(), event.getDragX(), event.getDragY()))) {
+            event.setCanceled(true);
+        }
+    }
+
+    @SubscribeEvent(priority = EventPriority.LOW)
+    public static void onScreenRenderLow(ScreenEvent.Render.Pre event) {
+        int mx = event.getMouseX(), my = event.getMouseY();
+        float pt = event.getPartialTick();
+        GuiGraphics gc = event.getGuiGraphics();
+        defaultContext.setGraphics(gc);
+        defaultContext.updateState(mx, my, pt);
+        defaultContext.reset();
+        if (validateGui(event.getScreen())) {
+            currentScreen.getContext().setGraphics(gc);
+            currentScreen.getContext().updateState(mx, my, pt);
+            drawScreen(gc, currentScreen, currentScreen.getScreenWrapper().getWrappedScreen(), mx, my, pt);
+            event.setCanceled(true);
+        }
+    }
+
+    @SubscribeEvent
+    public static void onScreenRenderNormal(ScreenEvent.Render.Post event) {
+        OverlayStack.draw(event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), event.getPartialTick());
+    }
+
+    @SubscribeEvent
+    public static void onClientTick(TickEvent.ClientTickEvent event) {
+        if (event.phase == TickEvent.Phase.END) {
+            OverlayStack.onTick();
+            defaultContext.tick();
+            if (validateGui()) {
+                currentScreen.onUpdate();
+            }
+            ticks++;
+        }
+    }
+
+    @SubscribeEvent
+    public static void onRenderTick(TickEvent.RenderTickEvent event) {
+        if (event.phase == TickEvent.Phase.START) {
+            GL11.glEnable(GL11.GL_STENCIL_TEST);
+        }
+        Stencil.reset();
+    }
+
+    public static void onFrameUpdate() {
+        OverlayStack.foreach(ModularScreen::onFrameUpdate, true);
+        if (currentScreen != null) currentScreen.onFrameUpdate();
+    }
+
+    private static void onGuiChanged(Screen oldScreen, Screen newScreen) {
+        if (oldScreen == newScreen) return;
+        defaultContext.reset();
+        fpsCounter.reset();
+        GuiErrorHandler.INSTANCE.clear();
+
+        IMuiScreen lastLastMui = lastMui;
+        if (lastMui != null) {
+            // called on open and close
+            // invalidate last mui screen, but keep it in stack
+            invalidateCurrentScreen();
+        }
+
+        if (newScreen instanceof IMuiScreen muiScreen) {
+            lastMui = muiScreen;
+            currentScreen = muiScreen.getScreen();
+            muiStack.remove(muiScreen);
+            muiStack.add(muiScreen); // move screen to the top of the stack;
+            Screen lastParent = lastLastMui != null ? lastLastMui.getScreen().getContext().getParent() : null;
+            if (lastParent != muiScreen) {
+                // new screen in the stack
+                currentScreen.getContext().setParent(oldScreen);
+            } else {
+                // last parent is equal to new screen -> effectively popping the current screen from the stack
+                // the current screen will disconnect from the stack and therefore need to dispose it
+                muiStack.remove(lastLastMui);
+                lastLastMui.getScreen().getPanelManager().dispose();
+            }
+        } else if (newScreen == null) {
+            // closing -> clear stack and dispose every screen
+            invalidateMuiStack();
+            // only when all screens are closed dispose all containers in the stack
+            ModularNetwork.CLIENT.closeAll();
+        }
+
+        OverlayStack.onOpenScreen(newScreen);
+    }
+
+    private static void invalidateCurrentScreen() {
+        // reset mouse inputs, relevant when screen gets reopened
+        if (lastMui != null) {
+            lastMui.getScreen().getPanelManager().closeScreen();
+            lastMui = null;
+        }
+        currentScreen = null;
+    }
+
+    private static void invalidateMuiStack() {
+        muiStack.forEach(muiScreen -> muiScreen.getScreen().getPanelManager().dispose());
+        muiStack.clear();
+    }
+
+    private static boolean doAction(@Nullable ModularScreen muiScreen, Predicate<ModularScreen> action) {
+        return OverlayStack.interact(action, true) || (muiScreen != null && action.test(muiScreen));
+    }
+
+    private static void foreach(@Nullable ModularScreen muiScreen, Consumer<ModularScreen> action) {
+        OverlayStack.foreach(action, true);
+        if (muiScreen != null) action.accept(muiScreen);
+    }
+
+    /**
+     * This replicates vanilla behavior while also injecting custom behavior for consistency
+     */
+    public static boolean handleKeyboardInput(@Nullable ModularScreen muiScreen, Screen mcScreen,
+                                              boolean isPress, InputPhase inputPhase,
+                                              int keyCode, int scanCode, int modifiers) {
+        if (isPress) {
+            // pressing a key
+            return inputPhase.isEarly() ? doAction(muiScreen, ms -> ms.keyPressed(keyCode, scanCode, modifiers)) :
+                    keyTyped(mcScreen, keyCode, scanCode, modifiers);
+        } else {
+            // releasing a key
+            return inputPhase.isEarly() && doAction(muiScreen, ms -> ms.keyReleased(keyCode, scanCode, modifiers));
+        }
+    }
+
+    private static boolean keyTyped(Screen screen, int keyCode, int scanCode, int modifiers) {
+        if (currentScreen == null) return false;
+        // debug mode C + CTRL + SHIFT + ALT
+        if (keyCode == 'C' && Interactable.isControl(modifiers) && Interactable.isShift(modifiers) &&
+                Interactable.isAlt(modifiers)) {
+            if (!debugToggleActive) {
+                ConfigHolder.INSTANCE.dev.debugUI = !ConfigHolder.INSTANCE.dev.debugUI;
+                debugToggleActive = true;
+            }
+            return true;
+        } else {
+            debugToggleActive = false;
+        }
+        if (keyCode == InputConstants.KEY_ESCAPE && screen.shouldCloseOnEsc()) {
+            onClose();
+            return true;
+        }
+        boolean isInventoryKey = Minecraft.getInstance().options.keyInventory
+                .isActiveAndMatches(InputConstants.getKey(keyCode, scanCode));
+        if (keyCode == 1 || isInventoryKey) {
+            onClose();
+            return true;
+        }
+        return false;
+    }
+
+    private static void onClose() {
+        if (currentScreen.getContext().hasDraggable()) {
+            currentScreen.getContext().dropDraggable(true);
+        } else {
+            currentScreen.getPanelManager().closeTopPanel();
+        }
+    }
+
+    public static void dragSlot(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        ModularGuiContext ctx = currentScreen.getContext();
+        getMCScreen().mouseDragged(ctx.getMouseX(), ctx.getMouseY(), button, dragX, dragY);
+    }
+
+    public static void clickSlot(ModularScreen ms, Slot slot) {
+        Screen screen = ms.getScreenWrapper().getWrappedScreen();
+        if (screen instanceof ScreenAccessor acc && screen instanceof IClickableContainerScreen clickableScreen &&
+                validateGui(screen)) {
+            ModularGuiContext ctx = ms.getContext();
+            var buttonList = screen.children();
+            try {
+                // remove buttons to make sure they are not clicked
+                acc.setChildren(Collections.emptyList());
+                // set clicked slot to make sure the container clicks the desired slot
+                clickableScreen.gtceu$setClickedSlot(slot);
+                screen.mouseClicked(ctx.getMouseX(), ctx.getMouseY(), ctx.getMouseButton());
+            } finally {
+                // undo modifications
+                clickableScreen.gtceu$setClickedSlot(null);
+                acc.setChildren(buttonList);
+            }
+        }
+    }
+
+    public static void releaseSlot() {
+        if (hasScreen() && getMCScreen() != null) {
+            ModularGuiContext ctx = currentScreen.getContext();
+            getMCScreen().mouseReleased(ctx.getMouseX(), ctx.getMouseY(), ctx.getMouseButton());
+        }
+    }
+
+    public static boolean shouldDrawWorldBackground() {
+        return /* ModularUI.isBlurLoaded() || */Minecraft.getInstance().level == null;
+    }
+
+    public static void drawDarkBackground(Screen screen, GuiGraphics guiGraphics) {
+        if (hasScreen()) {
+            float alpha = currentScreen.getMainPanel().getAlpha();
+            // vanilla color values as hex
+            int color = 0x101010;
+            int startAlpha = 0xc0;
+            int endAlpha = 0xd0;
+            // we need to use normal render type, not overlay here
+            guiGraphics.fillGradient(0, 0, screen.width, screen.height,
+                    Color.withAlpha(color, (int) (startAlpha * alpha)),
+                    Color.withAlpha(color, (int) (endAlpha * alpha)));
+            MinecraftForge.EVENT_BUS.post(new ScreenEvent.BackgroundRendered(screen, guiGraphics));
+        }
+    }
+
+    public static void drawScreen(GuiGraphics graphics, ModularScreen muiScreen, Screen mcScreen, int mouseX,
+                                  int mouseY, float partialTicks) {
+        if (mcScreen instanceof AbstractContainerScreen<?> container) {
+            drawContainer(graphics, muiScreen, container, mouseX, mouseY, partialTicks);
+        } else {
+            drawScreenInternal(graphics, muiScreen, mcScreen, mouseX, mouseY, partialTicks);
+        }
+    }
+
+    public static void drawScreenInternal(GuiGraphics graphics, ModularScreen muiScreen, Screen mcScreen, int mouseX,
+                                          int mouseY, float partialTicks) {
+        Stencil.reset();
+        muiScreen.getContext().getStencil().push(muiScreen.getScreenArea());
+        muiScreen.render(graphics, mouseX, mouseY, partialTicks);
+        RenderSystem.disableDepthTest();
+        drawVanillaElements(graphics, mcScreen, mouseX, mouseY, partialTicks);
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+        Lighting.setupForFlatItems();
+        muiScreen.drawForeground(graphics, partialTicks);
+        RenderSystem.enableDepthTest();
+        Lighting.setupFor3DItems();
+        muiScreen.getContext().getStencil().pop();
+    }
+
+    public static void drawContainer(GuiGraphics graphics, ModularScreen muiScreen, AbstractContainerScreen<?> mcScreen,
+                                     int mouseX, int mouseY, float partialTicks) {
+        AbstractContainerScreenAccessor acc = (AbstractContainerScreenAccessor) mcScreen;
+
+        Stencil.reset();
+        muiScreen.getContext().getStencil().push(muiScreen.getScreenArea());
+        mcScreen.renderBackground(graphics);
+        int x = mcScreen.getGuiLeft();
+        int y = mcScreen.getGuiTop();
+
+        acc.invokeRenderBg(graphics, partialTicks, mouseX, mouseY);
+        muiScreen.render(graphics, mouseX, mouseY, partialTicks);
+
+        RenderSystem.disableDepthTest();
+        // mainly for invtweaks compat
+        drawVanillaElements(graphics, mcScreen, mouseX, mouseY, partialTicks);
+        acc.setHoveredSlot(null);
+        graphics.setColor(1.0F, 1.0F, 1.0F, 1.0F);
+        Lighting.setupForFlatItems();
+        // acc.invokeRenderLabels(graphics, mouseX, mouseY);
+
+        acc.setHoveredSlot(null);
+        IWidget hovered = muiScreen.getContext().getTopHovered();
+        if (hovered instanceof IVanillaSlot vanillaSlot && vanillaSlot.handleAsVanillaSlot()) {
+            acc.setHoveredSlot(vanillaSlot.getVanillaSlot());
+        }
+
+        graphics.setColor(1.0F, 1.0F, 1.0F, 1.0F);
+        graphics.pose().pushPose();
+        graphics.pose().translate(x, y, 0);
+        MinecraftForge.EVENT_BUS.post(new ContainerScreenEvent.Render.Foreground(mcScreen, graphics, mouseX, mouseY));
+
+        AbstractContainerMenu menu = mcScreen.getMenu();
+        ItemStack draggingItem = acc.getDraggingItem().isEmpty() ? menu.getCarried() : acc.getDraggingItem();
+        if (!draggingItem.isEmpty()) {
+            int xOffset = 8;
+            int yOffset = acc.getDraggingItem().isEmpty() ? 8 : 16;
+            String text = null;
+
+            if (!acc.getDraggingItem().isEmpty() && acc.getIsSplittingStack()) {
+                draggingItem = draggingItem.copyWithCount(Mth.ceil(draggingItem.getCount() / 2.0F));
+            } else if (acc.getIsQuickCrafting() && acc.getQuickCraftSlots().size() > 1) {
+                draggingItem = draggingItem.copyWithCount(acc.getQuickCraftingRemainder());
+                if (draggingItem.isEmpty()) {
+                    text = ChatFormatting.YELLOW + "0";
+                }
+            }
+
+            drawFloatingItemStack(mcScreen, graphics, draggingItem, mouseX - x - xOffset, mouseY - y - yOffset, text);
+        }
+        graphics.pose().popPose();
+
+        if (!acc.getSnapbackItem().isEmpty()) {
+            float delta = (float) (Util.getMillis() - acc.getSnapbackTime()) / 100.0F;
+
+            if (delta >= 1.0F) {
+                delta = 1.0F;
+                acc.setSnapbackItem(ItemStack.EMPTY);
+            }
+
+            int snapBackOffsetX = acc.getSnapbackEnd().x - acc.getSnapbackStartX();
+            int snapBackOffsetY = acc.getSnapbackEnd().y - acc.getSnapbackStartY();
+            int snapBackX = acc.getSnapbackStartX() + (int) ((float) snapBackOffsetX * delta);
+            int snapBackY = acc.getSnapbackStartY() + (int) ((float) snapBackOffsetY * delta);
+            drawFloatingItemStack(mcScreen, graphics, acc.getSnapbackItem(), snapBackX, snapBackY, null);
+        }
+
+        muiScreen.drawForeground(graphics, partialTicks);
+
+        RenderSystem.enableDepthTest();
+        Lighting.setupFor3DItems();
+        muiScreen.getContext().getStencil().pop();
+    }
+
+    private static void drawFloatingItemStack(AbstractContainerScreen<?> mcScreen, GuiGraphics graphics,
+                                              ItemStack stack, int x, int y, String altText) {
+        graphics.pose().pushPose();
+        graphics.pose().translate(0.0F, 0.0F, 232.0F);
+
+        var font = IClientItemExtensions.of(stack).getFont(stack, IClientItemExtensions.FontContext.ITEM_COUNT);
+        if (font == null) font = ((ScreenAccessor) mcScreen).getFont();
+        graphics.renderItem(stack, x, y);
+        graphics.renderItemDecorations(font, stack,
+                x, y - (((AbstractContainerScreenAccessor) mcScreen).getDraggingItem().isEmpty() ? 0 : 8), altText);
+        graphics.pose().popPose();
+    }
+
+    @ApiStatus.Internal
+    public static void drawVanillaElements(GuiGraphics graphics, Screen mcScreen, int mouseX, int mouseY,
+                                           float partialTicks) {
+        for (Renderable renderable : mcScreen.renderables) {
+            renderable.render(graphics, mouseX, mouseY, partialTicks);
+        }
+    }
+
+    public static void drawDebugScreen(GuiGraphics graphics, @Nullable ModularScreen muiScreen,
+                                       @Nullable ModularScreen fallback) {
+        fpsCounter.onDraw();
+        if (!ConfigHolder.INSTANCE.dev.debugUI) return;
+        if (muiScreen == null) {
+            if (validateGui()) {
+                muiScreen = currentScreen;
+            } else {
+                if (fallback == null) return;
+                muiScreen = fallback;
+            }
+        }
+        RenderSystem.disableDepthTest();
+        RenderSystem.enableBlend();
+
+        ModularGuiContext context = muiScreen.getContext();
+        Matrix4f pose = graphics.pose().last().pose();
+
+        int mouseX = context.getAbsMouseX(), mouseY = context.getAbsMouseY();
+        int screenH = muiScreen.getScreenArea().height;
+        int outlineColor = Color.parseString(ConfigHolder.INSTANCE.dev.mui.outlineColor);// Color.argb(180, 40,
+                                                                                         // 115, 220);
+        int textColor = Color.parseString(ConfigHolder.INSTANCE.dev.mui.textColor);// Color.argb(180, 40, 115,
+                                                                                   // 220);
+        float scale = ConfigHolder.INSTANCE.dev.mui.scale;
+        int shift = (int) (11 * scale + 0.5f);
+        int lineY = screenH - shift - 2;
+        if ((GTCEu.Mods.isJEILoaded() || GTCEu.Mods.isEMILoaded() || GTCEu.Mods.isREILoaded()) &&
+                muiScreen.getContext().hasSettings() &&
+                muiScreen.getContext().getRecipeViewerSettings().isEnabled(muiScreen)) {
+            lineY -= 20;
+        }
+        GuiDraw.drawText(graphics, "Mouse Pos: " + mouseX + ", " + mouseY, 5, lineY, scale, outlineColor, true);
+        lineY -= shift;
+        GuiDraw.drawText(graphics, "FPS: " + fpsCounter.getFps(), 5, lineY, scale, outlineColor, true);
+        lineY -= shift;
+        // GuiDraw.drawText(graphics, "Theme ID: " + context.getTheme().getId(), 5, lineY, scale, outlineColor, true);
+        LocatedWidget locatedHovered = muiScreen.getPanelManager().getTopWidgetLocated(true);
+        boolean showHovered = ConfigHolder.INSTANCE.dev.mui.showHovered;
+        boolean showParent = ConfigHolder.INSTANCE.dev.mui.showParent;
+
+        ITheme theme;
+        if (locatedHovered != null && (showHovered || showParent)) {
+            theme = locatedHovered.getElement().getPanel().getTheme();
+        } else {
+            theme = context.getTheme();
+        }
+        GuiDraw.drawText(graphics, "Theme ID: " + theme.getId(), 5, lineY, scale, outlineColor, false);
+
+        if (locatedHovered != null && (showHovered || showParent)) {
+            drawSegmentLine(graphics, lineY -= 4, scale, outlineColor);
+            lineY -= 10;
+
+            IWidget hovered = locatedHovered.getElement();
+            locatedHovered.applyMatrix(context);
+            graphics.pose().pushPose();
+            context.applyTo(graphics.pose());
+
+            Area area = hovered.getArea();
+            IWidget parent = hovered.getParent();
+
+            if (showHovered && ConfigHolder.INSTANCE.dev.mui.showOutline) {
+                GuiDraw.drawBorderOutsideXYWH(graphics, 0, 0, area.width, area.height, scale, outlineColor);
+            }
+            if (hovered.hasParent() && showParent && ConfigHolder.INSTANCE.dev.mui.showParentOutline) {
+                GuiDraw.drawBorderOutsideXYWH(graphics, -area.rx, -area.ry, parent.getArea().width,
+                        parent.getArea().height, scale, Color.withAlpha(outlineColor, 0.3f));
+            }
+            graphics.pose().popPose();
+            locatedHovered.unapplyMatrix(context);
+            if (showHovered) {
+                if (ConfigHolder.INSTANCE.dev.mui.showWidgetTheme) {
+                    GuiDraw.drawText(graphics, "Widget Theme: " +
+                            hovered.getWidgetTheme(hovered.getPanel().getTheme()).getKey().getFullName(),
+                            5, lineY, scale, textColor, false);
+                    lineY -= shift;
+                }
+                if (ConfigHolder.INSTANCE.dev.mui.showSize) {
+                    GuiDraw.drawText(graphics, "Size: " + area.width + ", " + area.height, 5, lineY, scale, textColor,
+                            false);
+                    lineY -= shift;
+                }
+                if (ConfigHolder.INSTANCE.dev.mui.showPos) {
+                    GuiDraw.drawText(graphics, "Pos: " + area.x + ", " + area.y + "  Rel: " + area.rx + ", " + area.ry,
+                            5, lineY, scale, textColor, false);
+                    lineY -= shift;
+                }
+                GuiDraw.drawText(graphics, "Widget: " + hovered, 5, lineY, scale, textColor, true);
+            }
+            if (hovered.hasParent() && showParent) {
+                if (showHovered) {
+                    drawSegmentLine(graphics, lineY -= 4, scale, textColor);
+                    lineY -= 10;
+                }
+                if (ConfigHolder.INSTANCE.dev.mui.showParentWidgetTheme) {
+                    GuiDraw.drawText(graphics, "Widget Theme: " +
+                            parent.getWidgetTheme(muiScreen.getCurrentTheme()).getKey().getFullName(),
+                            5, lineY, scale, textColor, false);
+                    lineY -= shift;
+                }
+                area = parent.getArea();
+                if (ConfigHolder.INSTANCE.dev.mui.showParentSize) {
+                    GuiDraw.drawText(graphics, "Parent size: " + area.width + ", " + area.height, 5, lineY, scale,
+                            textColor, false);
+                    lineY -= shift;
+                }
+                if (ConfigHolder.INSTANCE.dev.mui.showParentPos) {
+                    GuiDraw.drawText(graphics,
+                            "Parent pos: " + area.x + ", " + area.y + "  Rel: " + area.rx + ", " + area.ry, 5, lineY,
+                            scale, textColor, false);
+                    lineY -= shift;
+                }
+                GuiDraw.drawText(graphics, "Parent: " + parent, 5, lineY, scale, textColor, false);
+            }
+            if (ConfigHolder.INSTANCE.dev.mui.showExtra) {
+                if (hovered instanceof ItemSlot slotWidget) {
+                    drawSegmentLine(graphics, lineY -= 4, scale, textColor);
+                    lineY -= 10;
+                    ModularSlot slot = slotWidget.getSlot();
+                    GuiDraw.drawText(graphics, "Slot Index: " + slot.getSlotIndex(), 5, lineY, scale, textColor, false);
+                    lineY -= shift;
+                    GuiDraw.drawText(graphics, "Slot Number: " + ((Slot) slot).index, 5, lineY, scale, textColor,
+                            false);
+                    lineY -= shift;
+                    if (slotWidget.isSynced()) {
+                        SlotGroup slotGroup = slot.getSlotGroup();
+                        boolean allowShiftTransfer = slotGroup != null && slotGroup.isAllowShiftTransfer();
+                        GuiDraw.drawText(graphics,
+                                "Shift-Click Priority: " +
+                                        (allowShiftTransfer ? slotGroup.getShiftClickPriority() : "DISABLED"),
+                                5, lineY, scale, textColor, false);
+                    }
+                } else if (hovered instanceof RichTextWidget richTextWidget) {
+                    drawSegmentLine(graphics, lineY -= 4, scale, outlineColor);
+                    lineY -= 10;
+                    locatedHovered.applyMatrix(context);
+                    Object hoveredElement = richTextWidget.getHoveredElement();
+                    locatedHovered.unapplyMatrix(context);
+                    GuiDraw.drawText(graphics, "Hovered: " + hoveredElement, 5, lineY, scale, textColor, false);
+                }
+            }
+        }
+        // dot at mouse pos
+        GuiDraw.drawRect(graphics, mouseX, mouseY, 1, 1,
+                Long.decode(ConfigHolder.INSTANCE.dev.mui.cursorColor).intValue());
+        graphics.setColor(1f, 1f, 1f, 1f);
+    }
+
+    private static void drawSegmentLine(GuiGraphics graphics, int y, float scale, int color) {
+        GuiDraw.drawRect(graphics, 5, y, 140 * scale, 1 * scale, color);
+    }
+
+    public static boolean hasScreen() {
+        return currentScreen != null;
+    }
+
+    @Nullable
+    public static Screen getMCScreen() {
+        return MCHelper.getCurrentScreen();
+    }
+
+    @Nullable
+    public static ModularScreen getMuiScreen() {
+        return currentScreen;
+    }
+
+    @UnmodifiableView
+    public static List<IMuiScreen> getMuiStack() {
+        return Collections.unmodifiableList(muiStack);
+    }
+
+    private static boolean validateGui() {
+        return validateGui(MCHelper.getCurrentScreen());
+    }
+
+    private static boolean validateGui(Screen screen) {
+        if (currentScreen == null || !(screen instanceof IMuiScreen muiScreen)) {
+            // no mui screen currently open
+            return false;
+        }
+        if (screen != MCHelper.getCurrentScreen() || muiScreen.getScreen() != currentScreen) {
+            defaultContext.reset();
+            invalidateCurrentScreen();
+            if (MCHelper.getCurrentScreen() == null) {
+                invalidateMuiStack();
+            }
+            return false;
+        }
+        return true;
+    }
+
+    public static GuiContext getBestContext() {
+        if (validateGui()) {
+            return currentScreen.getContext();
+        }
+        return defaultContext;
+    }
+
+    public enum InputPhase {
+
+        // for mui interactions
+        EARLY,
+        // for mc interactions (like E and ESC)
+        LATE;
+
+        public boolean isEarly() {
+            return this == EARLY;
+        }
+
+        public boolean isLate() {
+            return this == LATE;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ContainerScreenWrapper.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ContainerScreenWrapper.java
new file mode 100644
index 00000000000..66705180e7a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ContainerScreenWrapper.java
@@ -0,0 +1,72 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@OnlyIn(Dist.CLIENT)
+public class ContainerScreenWrapper extends AbstractContainerScreen<ModularContainerMenu> implements IMuiScreen {
+
+    @Getter
+    private final @NotNull ModularScreen screen;
+
+    public ContainerScreenWrapper(ModularContainerMenu container, @NotNull ModularScreen screen) {
+        super(container, container.getPlayer().getInventory(), Component.empty());
+        this.screen = screen;
+        this.screen.construct(this);
+    }
+
+    /**
+     * This is only used to create the menu type with Registrate. Do not use it (even though it may work).
+     *
+     * @deprecated Internal use only.
+     */
+    @SuppressWarnings({ "DataFlowIssue", "DeprecatedIsStillUsed" })
+    @Deprecated
+    @ApiStatus.Internal
+    public ContainerScreenWrapper(ModularContainerMenu container, Inventory playerInventory, Component title) {
+        super(container, playerInventory, title);
+        if (container.isScreenInitialized()) {
+            this.screen = container.getScreen();
+            this.screen.construct(this);
+        } else {
+            this.screen = null;
+        }
+    }
+
+    @Override
+    public void renderBackground(@NotNull GuiGraphics guiGraphics) {
+        handleDrawBackground(guiGraphics, super::renderBackground);
+    }
+
+    @Override
+    protected void renderBg(@NotNull GuiGraphics guiGraphics, float partialTick, int mouseX, int mouseY) {}
+
+    @Override
+    public void updateGuiArea(Rectangle area) {
+        this.leftPos = area.x;
+        this.topPos = area.y;
+        this.imageWidth = area.width;
+        this.imageHeight = area.height;
+    }
+
+    @Override
+    public boolean isPauseScreen() {
+        return this.screen.isPauseScreen();
+    }
+
+    @Override
+    public String toString() {
+        return "Wrapper(" + getScreen() + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/CustomModularScreen.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/CustomModularScreen.java
new file mode 100644
index 00000000000..5412eb82273
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/CustomModularScreen.java
@@ -0,0 +1,35 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A {@link ModularScreen} which creates its panel via an overridable function for convenience.
+ */
+@OnlyIn(Dist.CLIENT)
+public abstract class CustomModularScreen extends ModularScreen {
+
+    /**
+     * Creates a new screen with a given owner.
+     *
+     * @param owner owner of this screen (usually a mod id)
+     */
+    public CustomModularScreen(@NotNull String owner) {
+        super(owner);
+    }
+
+    /**
+     * Creates the main panel of this screen. It's called in the super constructor and must return a new panel instance.
+     *
+     * @param context context used to build the panel
+     * @return the created panel
+     */
+    @NotNull
+    @ApiStatus.OverrideOnly
+    public abstract ModularPanel buildUI(ModularGuiContext context);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/DraggablePanelWrapper.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/DraggablePanelWrapper.java
new file mode 100644
index 00000000000..632193ae1ef
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/DraggablePanelWrapper.java
@@ -0,0 +1,82 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.widget.IDraggable;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.gui.GuiGraphics;
+
+import lombok.Getter;
+
+public class DraggablePanelWrapper implements IDraggable {
+
+    private final ModularPanel panel;
+    @Getter
+    private final Area movingArea;
+    private int relativeClickX, relativeClickY;
+    @Getter
+    private boolean moving;
+
+    public DraggablePanelWrapper(ModularPanel panel) {
+        this.panel = panel;
+        this.movingArea = panel.getArea().createCopy();
+    }
+
+    @Override
+    public void drawMovingState(GuiGraphics graphics, ModularGuiContext context, float partialTicks) {
+        context.pushMatrix();
+        transform(context);
+        WidgetTree.drawTree(this.panel, context, true, true);
+        context.popMatrix();
+    }
+
+    @Override
+    public boolean onDragStart(int button) {
+        if (button == 0) {
+            ModularGuiContext context = this.panel.getContext();
+            this.movingArea.x = context.transformX(0, 0);
+            this.movingArea.y = context.transformY(0, 0);
+            this.relativeClickX = context.getAbsMouseX() - this.movingArea.x;
+            this.relativeClickY = context.getAbsMouseY() - this.movingArea.y;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onDragEnd(boolean successful) {
+        if (successful) {
+            float y = this.panel.getContext().getAbsMouseY() - this.relativeClickY;
+            float x = this.panel.getContext().getAbsMouseX() - this.relativeClickX;
+            y = y / (this.panel.getScreen().getScreenArea().height - this.panel.getArea().height);
+            x = x / (this.panel.getScreen().getScreenArea().width - this.panel.getArea().width);
+            this.panel.resizer().resetPosition();
+            this.panel.resizer().relativeToScreen();
+            this.panel.resizer().topRelAnchor(y, y).leftRelAnchor(x, x);
+            this.panel.scheduleResize();
+        }
+    }
+
+    @Override
+    public void onDrag(int mouseButton, double timeSinceLastClick) {
+        this.movingArea.x = this.panel.getContext().getAbsMouseX() - this.relativeClickX;
+        this.movingArea.y = this.panel.getContext().getAbsMouseY() - this.relativeClickY;
+    }
+
+    @Override
+    public void setMoving(boolean moving) {
+        this.moving = moving;
+        this.panel.setEnabled(!moving);
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        if (isMoving()) {
+            Area area = this.panel.getArea();
+            stack.translate(-area.x, -area.y);
+            stack.translate(this.movingArea.x, this.movingArea.y);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/IClickableContainerScreen.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/IClickableContainerScreen.java
new file mode 100644
index 00000000000..4f9efc45132
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/IClickableContainerScreen.java
@@ -0,0 +1,10 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import net.minecraft.world.inventory.Slot;
+
+public interface IClickableContainerScreen {
+
+    void gtceu$setClickedSlot(Slot slot);
+
+    Slot gtceu$getClickedSlot();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularContainerMenu.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularContainerMenu.java
new file mode 100644
index 00000000000..ba3b429c9ec
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularContainerMenu.java
@@ -0,0 +1,500 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.common.data.GTMenuTypes;
+import com.gregtechceu.gtceu.core.mixins.client.AbstractContainerMenuAccessor;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.ClickType;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.items.ItemHandlerHelper;
+
+import lombok.Getter;
+import org.jetbrains.annotations.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public class ModularContainerMenu extends AbstractContainerMenu {
+
+    public static ModularContainerMenu getCurrent(Player player) {
+        if (player.containerMenu instanceof ModularContainerMenu container) {
+            return container;
+        }
+        return null;
+    }
+
+    private static final int DROP_TO_WORLD = -999;
+    private static final int LEFT_MOUSE = 0;
+    private static final int RIGHT_MOUSE = 1;
+
+    @Getter
+    private Player player;
+    private ModularSyncManager syncManager;
+    private boolean init = true;
+    // all phantom slots (inventory doesn't contain phantom slots)
+    private final List<ModularSlot> phantomSlots = new ArrayList<>();
+    private final List<ModularSlot> shiftClickSlots = new ArrayList<>();
+    @Getter
+    private GuiData guiData;
+    private UISettings settings;
+
+    @OnlyIn(Dist.CLIENT)
+    private ModularScreen optionalScreen;
+
+    public int inWorldID = -1;
+
+    public ModularContainerMenu(int containerId) {
+        super(GTMenuTypes.MODULAR_CONTAINER.get(), containerId);
+    }
+
+    public <T extends GuiData> ModularContainerMenu(int containerId,
+                                                    Inventory playerInv, @Nullable FriendlyByteBuf data) {
+        this(containerId);
+        // TODO: Better integration with menu types for custom containers and screens.
+        throw new IllegalArgumentException("Do not open the modular container the forge way. Use an UIFactory!");
+    }
+
+    @ApiStatus.Internal
+    public void construct(Player player, ModularSyncManager msm, UISettings settings, String mainPanelName,
+                          GuiData guiData) {
+        this.player = player;
+        this.syncManager = msm;
+        this.syncManager.construct(this, mainPanelName);
+        this.settings = settings;
+        this.guiData = guiData;
+        sortShiftClickSlots();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    void initializeClient(ModularScreen screen) {
+        this.optionalScreen = screen;
+    }
+
+    @ApiStatus.Internal
+    @OnlyIn(Dist.CLIENT)
+    public void constructClientOnly() {
+        this.player = Minecraft.getInstance().player;
+        this.syncManager = null;
+    }
+
+    public boolean isInitialized() {
+        return this.player != null;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public ModularScreen getScreen() {
+        if (this.optionalScreen == null) throw new NullPointerException("ModularScreen is not yet initialised!");
+        return this.optionalScreen;
+    }
+
+    public boolean isScreenInitialized() {
+        return this.optionalScreen != null;
+    }
+
+    public AbstractContainerMenuAccessor acc() {
+        return (AbstractContainerMenuAccessor) this;
+    }
+
+    public void opened() {}
+
+    /**
+     * Called when this container closes. This is different to {@link AbstractContainerMenu#removed(Player)}, since that
+     * one is also
+     * called from {@link AbstractContainerScreen#removed()}, which means it is called even when the container may still
+     * exist.
+     * This happens when a temporary client screen takes over (like JEI,NEI,etc.). This is only called when the
+     * container actually closes.
+     */
+
+    public void closed() {}
+
+    public void disposed() {}
+
+    @MustBeInvokedByOverriders
+    @Override
+    public void broadcastChanges() {
+        super.broadcastChanges();
+        if (this.syncManager != null) {
+            this.syncManager.detectAndSendChanges(this.init);
+        }
+        this.init = false;
+    }
+
+    @MustBeInvokedByOverriders
+    public void onUpdate() {
+        // detectAndSendChanges is potentially called multiple times per tick, while this method is called exactly once
+        // per tick
+        if (this.syncManager != null) {
+            this.syncManager.onUpdate();
+        }
+    }
+
+    private void sortShiftClickSlots() {
+        this.shiftClickSlots.sort(ModularSlot.SHIFT_CLICK_PRIORITY);
+    }
+
+    @Override
+    public void initializeContents(int stateId, List<ItemStack> items, @NotNull ItemStack carried) {
+        if (this.slots.size() != items.size()) {
+            GTCEu.LOGGER.error("Here are {} slots, but expected {}", this.slots.size(), items.size());
+        }
+        super.initializeContents(stateId, items, carried);
+    }
+
+    @ApiStatus.Internal
+    public void registerSlot(String panelName, ModularSlot slot) {
+        if (slot.isPhantom()) {
+            if (this.phantomSlots.contains(slot)) {
+                throw new IllegalArgumentException("Tried to register slot which already exists!");
+            }
+            this.phantomSlots.add(slot);
+        } else {
+            if (this.slots.contains(slot)) {
+                throw new IllegalArgumentException("Tried to register slot which already exists!");
+            }
+            addSlot(slot);
+        }
+        if (slot.getSlotGroupName() != null) {
+            SlotGroup slotGroup = getSyncManager().getSlotGroup(panelName, slot.getSlotGroupName());
+            if (slotGroup == null) {
+                GTCEu.LOGGER.throwing(
+                        new IllegalArgumentException("SlotGroup '" + slot.getSlotGroupName() + "' is not registered!"));
+                return;
+            }
+            slot.slotGroup(slotGroup);
+        }
+        if (slot.getSlotGroup() != null) {
+            SlotGroup slotGroup = slot.getSlotGroup();
+            if (slotGroup.isAllowShiftTransfer()) {
+                this.shiftClickSlots.add(slot);
+                if (!this.init) {
+                    sortShiftClickSlots();
+                }
+            }
+        }
+    }
+
+    @Contract("_, null, null -> fail")
+    @NotNull
+    @ApiStatus.Internal
+    public SlotGroup validateSlotGroup(String panelName, @Nullable String slotGroupName,
+                                       @Nullable SlotGroup slotGroup) {
+        if (slotGroup != null) {
+            if (getSyncManager().getSlotGroup(panelName, slotGroup.getName()) == null) {
+                throw new IllegalArgumentException("Slot group is not registered in the GUI.");
+            }
+            return slotGroup;
+        }
+        if (slotGroupName != null) {
+            slotGroup = getSyncManager().getSlotGroup(panelName, slotGroupName);
+            if (slotGroup == null) {
+                throw new IllegalArgumentException("Can't find slot group for name " + slotGroupName);
+            }
+            return slotGroup;
+        }
+        throw new IllegalArgumentException("Either the slot group or the name must not be null!");
+    }
+
+    public ModularSyncManager getSyncManager() {
+        if (this.syncManager == null) {
+            throw new IllegalStateException("GuiSyncManager is not available for client only GUI's.");
+        }
+        return this.syncManager;
+    }
+
+    public boolean isClient() {
+        return this.syncManager == null || NetworkUtils.isClient(this.player);
+    }
+
+    public boolean isClientOnly() {
+        return this.syncManager == null;
+    }
+
+    public ModularSlot getModularSlot(int index) {
+        Slot slot = this.slots.get(index);
+        if (slot instanceof ModularSlot modularSlot) {
+            return modularSlot;
+        }
+        throw new IllegalStateException(
+                "A non-ModularSlot was found, but all slots in a ModularContainer must extend ModularSlot.");
+    }
+
+    @UnmodifiableView
+    public List<ModularSlot> getShiftClickSlots() {
+        return Collections.unmodifiableList(this.shiftClickSlots);
+    }
+
+    public void onSlotChanged(ModularSlot slot, ItemStack stack, boolean onlyAmountChanged) {}
+
+    @Override
+    public boolean canDragTo(@NotNull Slot slot) {
+        return !(slot instanceof ModularSlot modularSlot) || modularSlot.canDragIntoSlot();
+    }
+
+    @Override
+    public boolean stillValid(@NotNull Player playerIn) {
+        return this.settings.canPlayerInteractWithUI(playerIn);
+    }
+
+    @Override
+    public void clicked(int slotId, int mouseButton, @NotNull ClickType clickTypeIn, @NotNull Player player) {
+        ItemStack returnable = ItemStack.EMPTY;
+        Inventory inventory = player.getInventory();
+
+        if (clickTypeIn == ClickType.QUICK_CRAFT || acc().getQuickcraftType() != -1) {
+            superClicked(slotId, mouseButton, clickTypeIn, player);
+            return;
+        }
+
+        if ((clickTypeIn == ClickType.PICKUP || clickTypeIn == ClickType.QUICK_MOVE) &&
+                (mouseButton == LEFT_MOUSE || mouseButton == RIGHT_MOUSE)) {
+            if (slotId == DROP_TO_WORLD) {
+                superClicked(slotId, mouseButton, clickTypeIn, player);
+                return;
+            }
+
+            // early return
+            if (slotId < 0) return;
+
+            if (clickTypeIn == ClickType.QUICK_MOVE) {
+                Slot fromSlot = getSlot(slotId);
+
+                if (!fromSlot.mayPickup(player)) {
+                    return;
+                }
+                // simpler code, but effectively no difference // TODO: NEA
+                ItemStack remainder;
+                do {
+                    remainder = quickMoveStack(player, slotId);
+                    returnable = remainder.copy();
+                } while (!remainder.isEmpty() && ItemHandlerHelper.canItemStacksStack(fromSlot.getItem(), remainder));
+            } else {
+                Slot clickedSlot = getSlot(slotId);
+
+                ItemStack slotStack = clickedSlot.getItem();
+                ItemStack heldStack = this.getCarried();
+
+                if (slotStack.isEmpty()) {
+                    // no dif
+                    if (!heldStack.isEmpty() && clickedSlot.mayPlace(heldStack)) {
+                        int stackCount = mouseButton == LEFT_MOUSE ? heldStack.getCount() : 1;
+
+                        int lim = clickedSlot.getMaxStackSize(heldStack);
+                        if (stackCount > lim) {
+                            stackCount = lim;
+                        }
+
+                        clickedSlot.setByPlayer(heldStack.split(stackCount));
+                    }
+                } else if (clickedSlot.mayPickup(player)) {
+                    if (heldStack.isEmpty() && !slotStack.isEmpty()) {
+                        // checking max stack size here, probably for oversized slots
+                        int s = Math.min(slotStack.getCount(), slotStack.getMaxStackSize());
+                        int toRemove = mouseButton == LEFT_MOUSE ? s : (s + 1) / 2;
+                        this.setCarried(slotStack.split(toRemove));
+                        clickedSlot.setByPlayer(slotStack);
+                        clickedSlot.onTake(player, this.getCarried());
+                    } else if (clickedSlot.mayPlace(heldStack)) {
+                        if (ItemStack.isSameItemSameTags(slotStack, heldStack)) {
+                            int stackCount = mouseButton == LEFT_MOUSE ? heldStack.getCount() : 1;
+
+                            int lim = clickedSlot.getMaxStackSize(heldStack);
+                            if (stackCount > lim - slotStack.getCount()) {
+                                stackCount = lim - slotStack.getCount();
+                            }
+
+                            heldStack.shrink(stackCount);
+                            slotStack.grow(stackCount);
+                            clickedSlot.setByPlayer(slotStack);
+
+                        } else if (heldStack.getCount() <= clickedSlot.getMaxStackSize(heldStack)) {
+                            clickedSlot.setByPlayer(heldStack);
+                            this.setCarried(slotStack);
+                        }
+                    } else if (heldStack.getMaxStackSize() > 1 &&
+                            ItemStack.isSameItemSameTags(slotStack, heldStack) && !slotStack.isEmpty()) {
+                                int stackCount = slotStack.getCount();
+
+                                if (stackCount + heldStack.getCount() <= heldStack.getMaxStackSize()) {
+                                    heldStack.grow(stackCount);
+                                    slotStack = clickedSlot.remove(stackCount);
+
+                                    if (slotStack.isEmpty()) {
+                                        clickedSlot.setByPlayer(ItemStack.EMPTY);
+                                    }
+
+                                    clickedSlot.onTake(player, this.getCarried());
+                                }
+                            }
+                }
+                clickedSlot.setChanged();
+            }
+            broadcastChanges();
+        } else if (clickTypeIn == ClickType.PICKUP_ALL && slotId >= 0) {
+            Slot slot = slots.get(slotId);
+            ItemStack carried = this.getCarried();
+
+            if (!carried.isEmpty() && (!slot.hasItem() || !slot.mayPickup(player))) {
+                int i = mouseButton == 0 ? 0 : slots.size() - 1;
+                int j = mouseButton == 0 ? 1 : -1;
+
+                for (int k = 0; k < 2; ++k) {
+                    for (int l = i; l >= 0 && l < slots.size() &&
+                            carried.getCount() < carried.getMaxStackSize(); l += j) {
+                        Slot slot1 = slots.get(l);
+                        if (slot1 instanceof ModularSlot modularSlot && modularSlot.isPhantom()) continue;
+
+                        if (slot1.hasItem() && canItemQuickReplace(slot1, carried, true) && slot1.mayPickup(player) &&
+                                canTakeItemForPickAll(carried, slot1)) {
+                            ItemStack slotItem = slot1.getItem();
+
+                            if (k != 0 || slotItem.getCount() != slotItem.getMaxStackSize()) {
+                                int toRemove = Math.min(carried.getMaxStackSize() - carried.getCount(),
+                                        slotItem.getCount());
+                                ItemStack removed = slot1.remove(toRemove);
+                                carried.grow(toRemove);
+
+                                if (removed.isEmpty()) {
+                                    slot1.setByPlayer(ItemStack.EMPTY);
+                                }
+
+                                slot1.onTake(player, removed);
+                            }
+                        }
+                    }
+                }
+            }
+
+            broadcastChanges();
+            return;
+        } else if (clickTypeIn == ClickType.SWAP && mouseButton >= 0 && mouseButton < 9) {
+            ModularSlot phantom = getModularSlot(slotId);
+            ItemStack hotbarStack = inventory.getItem(mouseButton);
+            if (phantom.isPhantom()) {
+                // insert stack from hotbar slot into phantom slot
+                phantom.setByPlayer(hotbarStack.isEmpty() ? ItemStack.EMPTY : hotbarStack.copy());
+                broadcastChanges();
+            }
+        } else {
+            superClicked(slotId, mouseButton, clickTypeIn, player);
+        }
+    }
+
+    protected final void superClicked(int slotId, int mouseButton, @NotNull ClickType clickTypeIn,
+                                      @NotNull Player player) {
+        super.clicked(slotId, mouseButton, clickTypeIn, player);
+    }
+
+    @Override
+    public @NotNull ItemStack quickMoveStack(@NotNull Player playerIn, int index) {
+        ModularSlot slot = getModularSlot(index);
+        if (!slot.isPhantom()) {
+            ItemStack stack = slot.getItem();
+            if (!stack.isEmpty()) {
+                ItemStack copy = stack.copy();
+                stack = stack.copy();
+                int base = 0;
+                if (stack.getCount() > stack.getMaxStackSize()) {
+                    base = stack.getCount() - stack.getMaxStackSize();
+                    stack.setCount(stack.getMaxStackSize());
+                }
+                ItemStack remainder = transferItem(slot, stack.copy());
+                if (ItemStack.isSameItemSameTags(remainder, stack)) return ItemStack.EMPTY;
+                if (base == 0 && remainder.isEmpty()) stack = ItemStack.EMPTY;
+                else stack.setCount(base + remainder.getCount());
+                slot.set(stack);
+                slot.onQuickCraft(remainder, copy);
+                slot.onTake(playerIn, remainder);
+                slot.onCraftShiftClick(playerIn, remainder);
+                return ItemStack.EMPTY;
+            }
+        }
+        return ItemStack.EMPTY;
+    }
+
+    protected ItemStack transferItem(ModularSlot fromSlot, ItemStack fromStack) {
+        @Nullable
+        SlotGroup fromSlotGroup = fromSlot.getSlotGroup();
+        // in first iteration only insert into non-empty, non-phantom slots
+        for (ModularSlot toSlot : getShiftClickSlots()) {
+            SlotGroup slotGroup = Objects.requireNonNull(toSlot.getSlotGroup());
+            if (slotGroup != fromSlotGroup && toSlot.isActive() && toSlot.mayPlace(fromStack)) {
+                ItemStack toStack = toSlot.getItem().copy();
+                if (!fromSlot.isPhantom() && ItemHandlerHelper.canItemStacksStack(fromStack, toStack)) {
+                    int j = toStack.getCount() + fromStack.getCount();
+                    // Math.min(toSlot.getMaxStackSize(), fromStack.getMaxStackSize());
+                    int maxSize = toSlot.getMaxStackSize(fromStack);
+
+                    if (j <= maxSize) {
+                        fromStack.setCount(0);
+                        toStack.setCount(j);
+                        toSlot.set(toStack);
+                    } else if (toStack.getCount() < maxSize) {
+                        fromStack.shrink(maxSize - toStack.getCount());
+                        toStack.setCount(maxSize);
+                        toSlot.set(toStack);
+                    }
+
+                    if (fromStack.isEmpty()) {
+                        return fromStack;
+                    }
+                }
+            }
+        }
+        boolean hasNonEmptyPhantom = false;
+        // now insert into first empty slot (phantom or not) and check if we have any non-empty phantom slots
+        for (ModularSlot toSlot : getShiftClickSlots()) {
+            ItemStack itemstack = toSlot.getItem();
+            SlotGroup slotGroup = Objects.requireNonNull(toSlot.getSlotGroup());
+            if (slotGroup != fromSlotGroup && toSlot.isActive() && toSlot.mayPlace(fromStack)) {
+                if (toSlot.isPhantom()) {
+                    if (!itemstack.isEmpty()) {
+                        // skip non-empty phantom for now
+                        hasNonEmptyPhantom = true;
+                    } else {
+                        toSlot.set(fromStack.copy());
+                        return fromStack;
+                    }
+                } else if (itemstack.isEmpty()) {
+                    if (fromStack.getCount() > toSlot.getMaxStackSize(fromStack)) {
+                        toSlot.set(fromStack.split(toSlot.getMaxStackSize(fromStack)));
+                    } else {
+                        toSlot.set(fromStack.split(fromStack.getCount()));
+                    }
+                    if (fromStack.getCount() < 1) {
+                        break;
+                    }
+                }
+            }
+        }
+        if (!hasNonEmptyPhantom) return fromStack;
+
+        // now insert into the first phantom slot we can find (will be non-empty)
+        // unfortunately, when all phantom slots are used it will always overwrite the first one
+        for (ModularSlot toSlot : getShiftClickSlots()) {
+            SlotGroup slotGroup = Objects.requireNonNull(toSlot.getSlotGroup());
+            if (slotGroup != fromSlotGroup && toSlot.isPhantom() && toSlot.isActive() && toSlot.mayPlace(fromStack)) {
+                // don't check for stackable, just overwrite
+                toSlot.set(fromStack.copy());
+                return fromStack;
+            }
+        }
+        return fromStack;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularPanel.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularPanel.java
new file mode 100644
index 00000000000..232e71b125d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularPanel.java
@@ -0,0 +1,941 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.animation.Animator;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.base.value.ISyncOrValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.*;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.HoveredWidgetList;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolation;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolations;
+import com.gregtechceu.gtceu.api.mui.utils.ObjectList;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiViewportStack;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.LocatedWidget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.Util;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.MustBeInvokedByOverriders;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.BooleanSupplier;
+import java.util.function.Function;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
+
+/**
+ * This class is like a window in windows. It can hold any amount of widgets. It may also be draggable.
+ * To open another panel on top of the main panel you must use
+ * {@link IPanelHandler#simple(ModularPanel, SecondaryPanel.IPanelBuilder, boolean)}
+ * or {@link PanelSyncManager#syncedPanel(String, boolean, PanelSyncHandler.IPanelBuilder)} if the panel should be
+ * synced.
+ */
+public class ModularPanel extends ParentWidget<ModularPanel> implements IViewport, IDragResizeable {
+
+    public static ModularPanel defaultPanel(@NotNull String name) {
+        return defaultPanel(name, 176, 166);
+    }
+
+    public static ModularPanel defaultPanel(@NotNull String name, int width, int height) {
+        return new ModularPanel(name).size(width, height);
+    }
+
+    private static final int tapTime = 200;
+
+    @Getter
+    private final @NotNull String name;
+    private ModularScreen screen;
+    @Setter
+    private IPanelHandler panelHandler;
+    @Getter
+    private State state = State.IDLE;
+    private boolean cantDisposeNow = false;
+    @Getter
+    private final @NotNull ObjectList<LocatedWidget> hovering = ObjectList.create();
+    private final Input keyboard = new Input();
+    private final Input mouse = new Input();
+
+    // drag resizing
+    private IDragResizeable currentResizing = null;
+    private LocatedWidget currentResizingWidget = null;
+    private ResizeDragArea draggingDragArea = null;
+    private final Area startArea = new Area();
+    private int dragX, dragY;
+
+    private final List<IPanelHandler> clientSubPanels = new ArrayList<>();
+    private boolean invisible = false;
+    private Animator animator;
+
+    private boolean resizeable = false;
+    private String themeOverride;
+    private ITheme theme;
+
+    private Runnable onCloseAction;
+
+    public ModularPanel(@NotNull String name) {
+        this.name = Objects.requireNonNull(name, "A panels name must not be null and should be unique!");
+        center();
+    }
+
+    @Override
+    public @NotNull ModularPanel getPanel() {
+        return this;
+    }
+
+    @Override
+    public Area getParentArea() {
+        return getScreen().getScreenArea();
+    }
+
+    @Override
+    public void onInit() {
+        getScreen().registerFrameUpdateListener(this, this::findHoveredWidgets, false);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(IPanelHandler.class);
+    }
+
+    @Override
+    protected void setSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        super.setSyncOrValue(syncOrValue);
+        setPanelHandler(syncOrValue.castNullable(IPanelHandler.class));
+    }
+
+    @ApiStatus.Internal
+    public void setPanelSyncHandler(PanelSyncHandler syncHandler) {
+        setSyncOrValue(ISyncOrValue.orEmpty(syncHandler));
+    }
+
+    /**
+     * @return true if this panel is currently open on a screen
+     */
+    public boolean isOpen() {
+        return this.state == State.OPEN;
+    }
+
+    /**
+     * If this panel is open it will be closed.
+     * If animating is enabled and an animation is already playing this method will do nothing.
+     */
+    public void closeIfOpen() {
+        if (!isOpen()) return;
+        closeSubPanels();
+        if (isMainPanel()) {
+            // close screen and let NEA handle animation // TODO: since nea is not yet ported, it will just close the
+            // screen
+            MCHelper.popScreen(getScreen().isOpenParentOnClose(), getContext().getParent());
+            return;
+        }
+        if (!shouldAnimate()) {
+            this.screen.getPanelManager().closePanel(this);
+            return;
+        }
+        if (!isOpening() && !isClosing()) {
+            if (isMainPanel()) {
+                // if this is the main panel, start closing animation for all panels
+                for (ModularPanel panel : getScreen().getPanelManager().getOpenPanels()) {
+                    if (!panel.isMainPanel()) {
+                        panel.closeIfOpen();
+                    }
+                }
+            }
+            getAnimator().onFinish(() -> this.screen.getPanelManager().closePanel(this));
+            getAnimator().reset(true);
+            getAnimator().animate(true);
+        }
+    }
+
+    protected void closeSubPanels() {
+        if (this.panelHandler != null) {
+            this.panelHandler.closeSubPanels();
+        }
+    }
+
+    @Deprecated
+    public void animateClose() {
+        closeIfOpen();
+    }
+
+    @Override
+    public boolean hasParent() {
+        return false;
+    }
+
+    @Override
+    public WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getPanelTheme();
+    }
+
+    @Override
+    public void transform(IViewportStack stack) {
+        super.transform(stack);
+        // apply scaling for animation
+        float scale = getScale();
+        if (scale != 1f) {
+            float x = getArea().w() / 2f;
+            float y = getArea().h() / 2f;
+            stack.translate(x, y);
+            stack.scale(scale, scale);
+            stack.translate(-x, -y);
+        }
+    }
+
+    private void findHoveredWidgets() {
+        this.hovering.clear();
+        if (!isEnabled()) {
+            return;
+        }
+        HoveredWidgetList widgetList = new HoveredWidgetList(this.hovering);
+        getContext().reset();
+        GuiViewportStack stack = new GuiViewportStack();
+        stack.pushViewport(null, getScreen().getScreenArea());
+        stack.pushViewport(this, getArea());
+        transform(stack);
+        getSelfAt(stack, widgetList, getContext().getAbsMouseX(), getContext().getAbsMouseY());
+        transformChildren(stack);
+        getWidgetsAt(stack, widgetList, getContext().getAbsMouseX(), getContext().getAbsMouseY());
+        stack.popViewport(this);
+        stack.popViewport(null);
+        stack.reset();
+    }
+
+    @Override
+    public boolean canHover() {
+        return !this.invisible && super.canHover();
+    }
+
+    @MustBeInvokedByOverriders
+    public void onOpen(ModularScreen screen) {
+        this.screen = screen;
+        getArea().z(1);
+        resizer().initialize(this.screen.getResizeNode(), this.screen.getResizeNode());
+        initialise(this, false);
+        WidgetTree.onUpdate(this);
+        // TODO: NEA handles main panel
+        if (shouldAnimate()) {
+            getAnimator().onFinish(() -> {});
+            getAnimator().reset();
+            getAnimator().animate();
+        }
+        this.state = State.OPEN;
+    }
+
+    void reopen() {
+        this.state = State.OPEN;
+    }
+
+    @MustBeInvokedByOverriders
+    public void onClose() {
+        if (this.onCloseAction != null) {
+            this.onCloseAction.run();
+        }
+        this.state = State.CLOSED;
+        if (this.panelHandler != null) {
+            this.panelHandler.closePanelInternal();
+        }
+    }
+
+    @Override
+    public boolean isExcludeAreaInRecipeViewer() {
+        return super.isExcludeAreaInRecipeViewer() ||
+                (!getScreen().isOverlay() && !this.invisible && !resizer().isFullSize());
+    }
+
+    @MustBeInvokedByOverriders
+    @Override
+    public void dispose() {
+        if (this.state == State.DISPOSED) return;
+        if (this.state != State.CLOSED && this.state != State.WAIT_DISPOSING) {
+            throw new IllegalStateException("Panel must be closed before disposing!");
+        }
+        if (this.cantDisposeNow) {
+            this.state = State.WAIT_DISPOSING;
+            return;
+        }
+        super.dispose();
+        this.screen = null;
+        this.state = State.DISPOSED;
+    }
+
+    /**
+     * Wraps a function so it can be called safely. This is needed in methods where the panel can be closed and
+     * disposed, but doing
+     * so will result in unexpected errors. This wrapper stops the disposal until the function has been fully executed.
+     * The return value of the function is then returned.
+     *
+     * @param runnable function to be called safely
+     * @param <T>      return type
+     * @return return value of function
+     */
+    public final <T> T doSafe(Supplier<T> runnable) {
+        if (this.state == State.DISPOSED) return null;
+        // make sure the screen is also not disposed
+        return getScreen().getPanelManager().doSafe(() -> {
+            this.cantDisposeNow = true;
+            T t = runnable.get();
+            this.cantDisposeNow = false;
+            if (this.state == State.WAIT_DISPOSING) {
+                this.state = State.CLOSED;
+                dispose();
+            }
+            return t;
+        });
+    }
+
+    public final boolean doSafeBool(BooleanSupplier runnable) {
+        return Objects.requireNonNull(doSafe(runnable::getAsBoolean));
+    }
+
+    public final int doSafeInt(IntSupplier runnable) {
+        return Objects.requireNonNull(doSafe(runnable::getAsInt));
+    }
+
+    public boolean onMousePressed(double mouseX, double mouseY, int button) {
+        return doSafeBool(() -> {
+            LocatedWidget pressed = LocatedWidget.EMPTY;
+            boolean result = false;
+
+            if (this.hovering.isEmpty()) {
+                // no element is hovered -> try close panel
+                if (closeOnOutOfBoundsClick()) {
+                    closeIfOpen();
+                    result = true;
+                }
+            } else {
+                for (LocatedWidget widget : this.hovering) {
+                    if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                    widget.applyMatrix(getContext());
+                    IWidget w = widget.getElement();
+                    if (w instanceof IDragResizeable resizeable &&
+                            widget.getAdditionalHoverInfo() instanceof ResizeDragArea dragArea) {
+                        this.currentResizing = resizeable;
+                        this.currentResizingWidget = widget;
+                        this.dragX = getContext().getMouseX();
+                        this.dragY = getContext().getMouseY();
+                        this.startArea.set(w.getArea());
+                        this.startArea.rx = w.getArea().rx;
+                        this.startArea.ry = w.getArea().ry;
+                        this.draggingDragArea = dragArea;
+                        widget.unapplyMatrix(getContext());
+                        break;
+                    }
+                    // click widget and see how it reacts
+                    if (widget.getElement() instanceof Interactable interactable) {
+                        Interactable.Result interactResult = interactable.onMousePressed(mouseX, mouseY, button);
+                        if (interactResult.accepts) {
+                            this.mouse.addAcceptedInteractable(interactable);
+                            pressed = widget;
+                        } else if (interactResult.stops) {
+                            pressed = LocatedWidget.EMPTY;
+                        }
+                        if (interactResult.stops) {
+                            result = true;
+                            widget.unapplyMatrix(getContext());
+                            break;
+                        }
+                    }
+                    // see if widget can be dragged
+                    if (getContext().onHoveredClick(button, widget)) {
+                        pressed = LocatedWidget.EMPTY;
+                        result = true;
+                        widget.unapplyMatrix(getContext());
+                        break;
+                    }
+                    widget.unapplyMatrix(getContext());
+                    // see if widgets below this can be interacted with
+                    if (!widget.getElement().canClickThrough()) {
+                        // act as if the widget was clicked and accepted
+                        result = true;
+                        pressed = widget;
+                        break;
+                    }
+                }
+            }
+
+            if (result && pressed.getElement() instanceof IFocusedWidget) {
+                getContext().focus(pressed);
+            } else {
+                getContext().removeFocus();
+            }
+            this.mouse.pressed(pressed, button);
+            return result;
+        });
+    }
+
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        return isEnabled() && doSafeBool(() -> {
+            if (!this.mouse.doRelease) {
+                this.mouse.reset();
+                return false;
+            }
+            if (this.currentResizing != null) {
+                this.mouse.reset();
+                this.currentResizing = null;
+                this.currentResizingWidget = null;
+                return true;
+            }
+            if (interactFocused(widget -> widget.onMouseReleased(mouseX, mouseY, button), false)) {
+                return true;
+            }
+            boolean lastPressedIsHovered = false;
+            boolean tryTap = this.mouse.tryTap(button);
+            // first see if the clicked widget is still hovered and try to interact with it
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (this.mouse.isWidget(widget)) {
+                    if (widget.getElement() instanceof Interactable interactable &&
+                            onMouseReleased(mouseX, mouseY, button, tryTap, widget, interactable)) {
+                        return true;
+                    }
+                    lastPressedIsHovered = true;
+                    break;
+                }
+            }
+            // now try all other hovered
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (!this.mouse.isWidget(widget) && widget.getElement() instanceof Interactable interactable &&
+                        onMouseReleased(mouseX, mouseY, button, tryTap, widget, interactable)) {
+                    return true;
+                }
+            }
+            // nothing worked, but since the pressed widget is still hovered we assume success
+            // otherwise JEI tries to pull some weird stuff
+            if (lastPressedIsHovered) {
+                this.mouse.reset();
+                return true;
+            }
+            this.mouse.reset();
+            return false;
+        });
+    }
+
+    private boolean onMouseReleased(double mouseX, double mouseY, int button, boolean tryTap, LocatedWidget widget,
+                                    Interactable interactable) {
+        boolean stop = false;
+        widget.applyMatrix(getContext());
+        if (tryTap && this.mouse.acceptedInteractions.remove(interactable)) {
+            Interactable.Result tabResult = interactable.onMouseTapped(mouseX, mouseY, button);
+            if (tabResult.stops) {
+                stop = true;
+                // we will try to trigger onMouseReleased() even after tapping tells to stop
+            }
+        }
+        if (interactable.onMouseReleased(mouseX, mouseY, button)) {
+            stop = true;
+        }
+        widget.unapplyMatrix(getContext());
+        if (stop) {
+            this.mouse.reset();
+            return true;
+        }
+        return false;
+    }
+
+    public boolean onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        return doSafeBool(() -> {
+            switch (interactFocused(widget -> widget.onKeyPressed(keyCode, scanCode, modifiers),
+                    Interactable.Result.IGNORE)) {
+                case STOP:
+                    this.keyboard.pressed(LocatedWidget.EMPTY, keyCode);
+                    return true;
+                case SUCCESS:
+                    this.keyboard.pressed(getContext().getFocusedWidget(), keyCode);
+                    return true;
+            }
+            LocatedWidget pressed = null;
+            boolean result = false;
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (widget.getElement() instanceof Interactable interactable) {
+                    widget.applyMatrix(getContext());
+                    Interactable.Result interactResult = interactable.onKeyPressed(keyCode, scanCode, modifiers);
+                    if (interactResult.accepts) {
+                        this.keyboard.addAcceptedInteractable(interactable);
+                        pressed = widget;
+                    } else if (interactResult.stops) {
+                        pressed = null;
+                    }
+                    if (interactResult.stops) {
+                        result = true;
+                        widget.unapplyMatrix(getContext());
+                        break;
+                    }
+                    widget.unapplyMatrix(getContext());
+                }
+                if (!widget.getElement().canClickThrough()) break;
+            }
+            this.keyboard.pressed(pressed, keyCode);
+            return result;
+        });
+    }
+
+    public boolean onKeyReleased(int keyCode, int scanCode, int modifiers) {
+        return doSafeBool(() -> {
+            if (!this.keyboard.doRelease) {
+                this.keyboard.reset();
+                return false;
+            }
+            if (interactFocused(widget -> widget.onKeyReleased(keyCode, scanCode, modifiers), false)) {
+                return true;
+            }
+            boolean lastPressedIsHovered = false;
+            boolean tryTap = this.keyboard.tryTap(keyCode);
+            // first see if the clicked widget is still hovered and try to interact with it
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (this.keyboard.isWidget(widget)) {
+                    if (widget.getElement() instanceof Interactable interactable &&
+                            onKeyReleased(keyCode, scanCode, modifiers, tryTap, widget, interactable)) {
+                        return true;
+                    }
+                    lastPressedIsHovered = true;
+                    break;
+                }
+            }
+            // now try all other hovered
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (!this.keyboard.isWidget(widget) && widget.getElement() instanceof Interactable interactable &&
+                        onKeyReleased(keyCode, scanCode, modifiers, tryTap, widget, interactable)) {
+                    return true;
+                }
+            }
+            // nothing worked, but since the pressed widget is still hovered we assume success
+            // otherwise JEI tries to pull some weird stuff
+            if (lastPressedIsHovered) {
+                this.keyboard.reset();
+                return true;
+            }
+            this.keyboard.reset();
+            return false;
+        });
+    }
+
+    private boolean onKeyReleased(int keyCode, int scanCode, int modifiers, boolean tryTap, LocatedWidget widget,
+                                  Interactable interactable) {
+        boolean stop = false;
+        widget.applyMatrix(getContext());
+        if (tryTap && this.keyboard.acceptedInteractions.remove(interactable)) {
+            Interactable.Result tabResult = interactable.onKeyTapped(keyCode, scanCode, modifiers);
+            if (tabResult.stops) {
+                stop = true;
+                // we will try to trigger onMouseReleased() even after tapping tells to stop
+            }
+        }
+        if (interactable.onKeyReleased(keyCode, scanCode, modifiers)) {
+            stop = true;
+        }
+        widget.unapplyMatrix(getContext());
+        if (stop) {
+            this.keyboard.reset();
+            return true;
+        }
+        return false;
+    }
+
+    public boolean onCharTyped(char codePoint, int modifiers) {
+        return doSafeBool(() -> {
+            switch (interactFocused(widget -> widget.onCharTyped(codePoint, modifiers), Interactable.Result.IGNORE)) {
+                case STOP:
+                    this.keyboard.pressed(LocatedWidget.EMPTY, codePoint);
+                    return true;
+                case SUCCESS:
+                    this.keyboard.pressed(getContext().getFocusedWidget(), codePoint);
+                    return true;
+            }
+            LocatedWidget pressed = null;
+            boolean result = false;
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (widget.getElement() instanceof Interactable interactable) {
+                    widget.applyMatrix(getContext());
+                    Interactable.Result interactResult = interactable.onCharTyped(codePoint, modifiers);
+                    if (interactResult.accepts) {
+                        this.keyboard.addAcceptedInteractable(interactable);
+                        pressed = widget;
+                    } else if (interactResult.stops) {
+                        pressed = null;
+                    }
+                    if (interactResult.stops) {
+                        result = true;
+                        widget.unapplyMatrix(getContext());
+                        break;
+                    }
+                    widget.unapplyMatrix(getContext());
+                }
+                if (!widget.getElement().canClickThrough()) break;
+            }
+            this.keyboard.pressed(pressed, codePoint);
+            return result;
+        });
+    }
+
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        return doSafeBool(() -> {
+            if (interactFocused(widget -> widget.onMouseScrolled(mouseX, mouseY, delta), false)) {
+                return true;
+            }
+            if (this.hovering.isEmpty()) return false;
+            for (LocatedWidget widget : this.hovering) {
+                if (widget.getElement() == null || !widget.getElement().isValid()) continue;
+                if (widget.getElement() instanceof Interactable interactable) {
+                    widget.applyMatrix(getContext());
+                    boolean result = interactable.onMouseScrolled(mouseX, mouseY, delta);
+                    widget.unapplyMatrix(getContext());
+                    if (result) return true;
+                }
+            }
+            return false;
+        });
+    }
+
+    public boolean onMouseDrag(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        return doSafeBool(() -> {
+            if (this.currentResizing != null) {
+                this.currentResizingWidget.applyMatrix(getContext());
+                int mx = getContext().getMouseX();
+                int my = getContext().getMouseY();
+                this.currentResizingWidget.unapplyMatrix(getContext());
+                int dx = mx - this.dragX;
+                int dy = my - this.dragY;
+                if (dx != 0 || dy != 0) {
+                    IDragResizeable.applyDrag(this.currentResizing, (IWidget) this.currentResizing,
+                            this.draggingDragArea, this.startArea, dx, dy);
+                }
+                return true;
+            }
+            if (this.mouse.held &&
+                    button == this.mouse.lastButton &&
+                    this.mouse.lastPressed != null &&
+                    this.mouse.lastPressed.getElement() instanceof Interactable interactable &&
+                    this.mouse.lastPressed.getElement().isValid()) {
+                this.mouse.lastPressed.applyMatrix(getContext());
+                interactable.onMouseDrag(mouseX, mouseY, button, dragX, dragY);
+                this.mouse.lastPressed.unapplyMatrix(getContext());
+                return true;
+            }
+            return false;
+        });
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T, W extends IWidget & IFocusedWidget & Interactable> T interactFocused(Function<W, T> function,
+                                                                                     T defaultValue) {
+        LocatedWidget focused = this.getContext().getFocusedWidget();
+        T result = defaultValue;
+        if (focused.getElement() instanceof Interactable interactable && focused.getElement().isValid()) {
+            focused.applyMatrix(getContext());
+            result = function.apply((W) interactable);
+            focused.unapplyMatrix(getContext());
+        }
+        return result;
+    }
+
+    /**
+     * @return if this panel can be dragged. Never works on the main panel.
+     */
+    public boolean isDraggable() {
+        return getScreen().getMainPanel() != this;
+    }
+
+    /**
+     * @return if panels below this can still be interacted with.
+     */
+    public boolean disablePanelsBelow() {
+        return false;
+    }
+
+    /**
+     * @return if this panel should be closed if outside of this panel is clicked.
+     */
+    public boolean closeOnOutOfBoundsClick() {
+        return false;
+    }
+
+    @Override
+    public boolean isCurrentlyResizable() {
+        return this.resizeable;
+    }
+
+    @Override
+    public boolean keepPosOnDragResize() {
+        return !isDraggable();
+    }
+
+    @Override
+    public ModularScreen getScreen() {
+        if (!isValid()) {
+            throw new IllegalStateException();
+        }
+        return this.screen;
+    }
+
+    @Nullable
+    public IWidget getTopHovering() {
+        LocatedWidget lw = getTopHoveringLocated(false);
+        return lw == null ? null : lw.getElement();
+    }
+
+    @Nullable
+    public LocatedWidget getTopHoveringLocated(boolean debug) {
+        int i = 0;
+        while (i < this.hovering.size()) {
+            LocatedWidget widget = this.hovering.get(i);
+            if (!widget.getElement().isValid()) {
+                this.hovering.remove(i);
+                continue;
+            }
+            if (debug || widget.getElement().canHover()) {
+                return widget;
+            }
+            i++;
+        }
+        return null;
+    }
+
+    @NotNull
+    public List<LocatedWidget> getAllHoveringList(boolean debug) {
+        if (this.hovering.isEmpty()) return Collections.emptyList();
+        return new ArrayList<>(this.hovering);
+    }
+
+    public boolean isBelowMouse(IWidget widget) {
+        if (!widget.isValid() || widget.getPanel() != this) return false;
+        for (LocatedWidget lw : this.hovering) {
+            if (lw.getElement() == widget) return true;
+        }
+        return false;
+    }
+
+    public boolean isAnyHovered() {
+        if (this.hovering.isEmpty()) return false;
+        if (this.hovering.size() == 1 && this.hovering.get(0).getElement() instanceof ModularPanel panel) {
+            return panel.canHover();
+        }
+        return true;
+    }
+
+    final void setPanelGuiContext(@NotNull ModularGuiContext context) {
+        setContext(context);
+    }
+
+    public boolean isOpening() {
+        return this.animator != null && this.animator.isAnimatingForward();
+    }
+
+    public boolean isClosing() {
+        return this.animator != null && this.animator.isAnimatingReverse();
+    }
+
+    public float getScale() {
+        if (ConfigHolder.INSTANCE.client.ui.animationTime == 0) return 1f;
+        // 0.9 is default nea value
+        return Interpolations.lerp(0.9f, 1f, getAnimator().getValue());
+        // TODO NEA
+        // if (!ModularUI.Mods.NEA.isLoaded() || NEAConfig.openingAnimationTime == 0) return 1f;
+        // return Interpolations.lerp(NEAConfig.openingStartScale, 1f, getAnimator().getValue());
+    }
+
+    public float getAlpha() {
+        if (ConfigHolder.INSTANCE.client.ui.animationTime == 0) return 1f;
+        return getAnimator().getValue();
+        // if (!ModularUI.Mods.NEA.isLoaded() || NEAConfig.openingAnimationTime == 0) return 1f;
+        // return getAnimator().getValue();
+    }
+
+    public final boolean isMainPanel() {
+        return getScreen().getMainPanel() == this;
+    }
+
+    @NotNull
+    protected Animator getAnimator() {
+        if (this.animator == null) {
+            this.animator = new Animator()
+                    .bounds(0f, 1f)
+                    .duration(ConfigHolder.INSTANCE.client.ui.animationTime)
+                    .curve(Interpolation.SINE_OUT); // TODO: NEA config values
+            this.animator.reset(true);
+        }
+        return this.animator;
+    }
+
+    public boolean shouldAnimate() {
+        // TODO: fix when NEA gets ported
+        /* && getScreen().getCurrentTheme().getOpenCloseAnimationOverride() > 0 */
+        if (this.invisible) return false;
+        if (!isMainPanel() || !getScreen().isOpenParentOnClose()) return true;
+        return getContext().getParent() == null;
+    }
+
+    void registerSubPanel(IPanelHandler handler) {
+        if (!this.clientSubPanels.contains(handler)) {
+            this.clientSubPanels.add(handler);
+        }
+    }
+
+    void closeClientSubPanels() {
+        for (IPanelHandler handler : this.clientSubPanels) {
+            if (handler.isSubPanel()) {
+                handler.closePanel();
+            }
+        }
+    }
+
+    public ITheme getTheme() {
+        if (this.theme == null) {
+            this.theme = IThemeApi.get().getThemeForScreen(this, this.themeOverride);
+        }
+        return this.theme;
+    }
+
+    public ModularPanel bindPlayerInventory() {
+        return child(SlotGroupWidget.playerInventory(true));
+    }
+
+    public ModularPanel bindPlayerInventory(int bottom) {
+        return child(SlotGroupWidget.playerInventory(bottom, true));
+    }
+
+    @Override
+    public ModularPanel invisible() {
+        this.invisible = true;
+        return super.invisible();
+    }
+
+    public ModularPanel fullScreenInvisible() {
+        return invisible().full();
+    }
+
+    public ModularPanel resizeableOnDrag(boolean resizeable) {
+        this.resizeable = resizeable;
+        return this;
+    }
+
+    public ModularPanel onCloseAction(Runnable onCloseAction) {
+        this.onCloseAction = onCloseAction;
+        return this;
+    }
+
+    public ModularPanel themeOverride(String id) {
+        this.themeOverride = id;
+        this.theme = null;
+        return this;
+    }
+
+    @Deprecated
+    @Override
+    public ModularPanel name(String name) {
+        throw new IllegalStateException("Name for ModularPanels are final!");
+    }
+
+    public enum State {
+        /**
+         * Initial state of any panel.
+         */
+        IDLE,
+        /**
+         * State after the panel opened.
+         */
+        OPEN,
+        /**
+         * State after panel closed. Panel can still be reopened in this state.
+         */
+        CLOSED,
+        /**
+         * State after panel disposed.
+         * Panel can still be reopened in this state.
+         * State after panel disposed. The panel is now lost and has to be rebuilt, when reopening it.
+         */
+        DISPOSED,
+        /**
+         * Panel is closed and is waiting to be disposed.
+         */
+        WAIT_DISPOSING
+    }
+
+    /**
+     * A helper class to handle input states for mouse and keyboard separatly
+     */
+    private static class Input {
+
+        private final ObjectList<Interactable> acceptedInteractions = ObjectList.create();
+        @Nullable
+        private LocatedWidget lastPressed;
+        private boolean held;
+        private long time;
+        private int lastButton;
+        private boolean doRelease = true;
+
+        private Input() {
+            reset();
+        }
+
+        private void addAcceptedInteractable(Interactable interactable) {
+            if (!this.held) {
+                this.acceptedInteractions.add(interactable);
+            }
+        }
+
+        private void reset() {
+            this.acceptedInteractions.clear();
+            this.held = false;
+            this.time = -1;
+            this.lastButton = -1;
+            this.doRelease = true;
+        }
+
+        private boolean isValid() {
+            return this.lastPressed != null && this.time > 0;
+        }
+
+        private int getTimeSinceEvent() {
+            return (int) Math.min(Util.getMillis() - this.time, Integer.MAX_VALUE);
+        }
+
+        private boolean tryTap(int button) {
+            return this.lastButton == button && getTimeSinceEvent() <= tapTime;
+        }
+
+        private boolean isWidget(IWidget widget) {
+            return this.lastPressed != null && this.lastPressed.getElement() == widget;
+        }
+
+        private boolean isWidget(LocatedWidget widget) {
+            return isWidget(widget.getElement());
+        }
+
+        private void pressed(LocatedWidget pressed, int button) {
+            if (!this.held) {
+                this.lastPressed = pressed;
+                if (this.lastPressed != null) {
+                    this.time = Util.getMillis();
+                }
+                this.lastButton = button;
+                this.held = true;
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularScreen.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularScreen.java
new file mode 100644
index 00000000000..de4c98112b8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ModularScreen.java
@@ -0,0 +1,833 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.widget.IGuiAction;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.overlay.OverlayScreenWrapper;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.ScreenResizeNode;
+import com.gregtechceu.gtceu.api.mui.widget.wrapper.WidgetWrapper;
+import com.gregtechceu.gtceu.api.mui.widgets.menu.MenuPanel;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.Renderable;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.layouts.LayoutElement;
+import net.minecraft.client.gui.narration.NarratableEntry;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import it.unimi.dsi.fastutil.objects.*;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.MustBeInvokedByOverriders;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.opengl.GL11;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.StreamSupport;
+
+/**
+ * This is the base class for all modular UIs. It only exists on client side.
+ * It handles drawing the screen, all panels and widget interactions.
+ */
+@OnlyIn(Dist.CLIENT)
+public class ModularScreen implements GuiEventListener, Renderable, LayoutElement, NarratableEntry {
+
+    public static boolean isScreen(@Nullable Screen guiScreen, String owner, String name) {
+        if (guiScreen instanceof IMuiScreen screenWrapper) {
+            ModularScreen screen = screenWrapper.getScreen();
+            return screen.getOwner().equals(owner) && screen.getName().equals(name);
+        }
+        return false;
+    }
+
+    public static boolean isActive(String owner, String name) {
+        return isScreen(Minecraft.getInstance().screen, owner, name);
+    }
+
+    @Nullable
+    public static ModularScreen getCurrent() {
+        if (MCHelper.getCurrentScreen() instanceof IMuiScreen screenWrapper) {
+            return screenWrapper.getScreen();
+        }
+        return null;
+    }
+
+    /**
+     * The owner of this screen. Usually a modid. This is mainly used to find theme overrides.
+     */
+    @Getter
+    private final String owner;
+    /**
+     * The name of this screen, which is also the name of the panel. Every UI under one owner should have a different
+     * name.
+     * Unfortunately there is no good way to verify this, so it's the UI implementors responsibility to set a proper
+     * name for the main panel.
+     * This is mainly used to find theme overrides.
+     */
+    @Getter
+    private final String name;
+    @Getter
+    private final PanelManager panelManager;
+    @Getter
+    private final ModularGuiContext context = new ModularGuiContext(this);
+    private final Map<Class<?>, List<IGuiAction>> guiActionListeners = new Object2ObjectOpenHashMap<>();
+    private final Object2ObjectArrayMap<IWidget, Runnable> frameUpdates = new Object2ObjectArrayMap<>();
+    @Getter
+    private final ScreenResizeNode resizeNode = new ScreenResizeNode(this);
+    @Getter
+    private boolean pauseScreen = false;
+    @Getter
+    private boolean openParentOnClose = false;
+
+    @Getter
+    @Nullable
+    private String themeOverride;
+    private ITheme currentTheme;
+    @Getter
+    private IMuiScreen screenWrapper;
+    /**
+     * true if this is an overlay for another screen
+     */
+    @Getter
+    private boolean overlay = false;
+
+    /**
+     * Creates a new screen with a given owner and {@link ModularPanel}.
+     *
+     * @param owner     owner of this screen (usually a mod id)
+     * @param mainPanel main panel of this screen
+     */
+    public ModularScreen(@NotNull String owner, @NotNull ModularPanel mainPanel) {
+        this(owner, context -> mainPanel);
+    }
+
+    /**
+     * Creates a new screen with the given owner and a main panel function. The function must return a non-null value.
+     *
+     * @param owner            owner of this screen (usually a mod id)
+     * @param mainPanelCreator function which creates the main panel of this screen
+     */
+    public ModularScreen(@NotNull String owner, @NotNull Function<ModularGuiContext, ModularPanel> mainPanelCreator) {
+        this(owner, Objects.requireNonNull(mainPanelCreator, "The main panel function must not be null!"), false);
+    }
+
+    private ModularScreen(@NotNull String owner, @Nullable Function<ModularGuiContext, ModularPanel> mainPanelCreator,
+                          boolean ignored) {
+        Objects.requireNonNull(owner, "The owner must not be null!");
+        this.owner = owner;
+        ModularPanel mainPanel = mainPanelCreator != null ? mainPanelCreator.apply(this.context) :
+                buildUI(this.context);
+        Objects.requireNonNull(mainPanel, "The main panel must not be null!");
+        this.name = mainPanel.getName();
+        this.panelManager = new PanelManager(this, mainPanel);
+    }
+
+    /**
+     * Intended for use in {@link CustomModularScreen}
+     */
+    ModularScreen(@NotNull String owner) {
+        this(owner, null, false);
+    }
+
+    /**
+     * Intended for use in {@link CustomModularScreen}
+     */
+    ModularPanel buildUI(ModularGuiContext context) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Should be called in custom {@link ScreenWrapper GuiScreen} constructors which implement {@link IMuiScreen}.
+     *
+     * @param wrapper the gui screen wrapping this screen
+     */
+    @MustBeInvokedByOverriders
+    public void construct(IMuiScreen wrapper) {
+        if (this.screenWrapper != null) throw new IllegalStateException("ModularScreen is already constructed!");
+        if (wrapper == null) throw new NullPointerException("ScreenWrapper must not be null!");
+        this.screenWrapper = wrapper;
+        if (this.screenWrapper.getWrappedScreen() instanceof AbstractContainerScreen<?> containerScreen) {
+            if (containerScreen.getMenu() instanceof ModularContainerMenu modular && !modular.isScreenInitialized()) {
+                modular.initializeClient(this);
+            }
+        }
+        this.screenWrapper.updateGuiArea(this.panelManager.getMainPanel().getArea());
+        this.overlay = false;
+    }
+
+    @ApiStatus.Internal
+    @MustBeInvokedByOverriders
+    public void constructOverlay(Screen screen) {
+        if (this.screenWrapper != null) throw new IllegalStateException("ModularScreen is already constructed!");
+        if (screen == null) throw new NullPointerException("ScreenWrapper must not be null!");
+        this.screenWrapper = new OverlayScreenWrapper(screen, this);
+        this.overlay = true;
+    }
+
+    /**
+     * Called everytime the Game window changes its size. Overriding for additional logic is allowed, but super must be
+     * called.
+     * This method resizes the entire widget tree of every panel currently open and then updates the size of the
+     * {@link IMuiScreen} wrapper.
+     * <p>
+     * Do not call this method except in an override!
+     *
+     * @param width  with of the resized game window
+     * @param height height of the resized game window
+     */
+    @MustBeInvokedByOverriders
+    public void onResize(int width, int height) {
+        this.context.updateScreenArea(width, height);
+        if (this.panelManager.tryInit()) {
+            onOpen();
+        }
+
+        this.context.pushViewport(null, this.context.getScreenArea());
+        WidgetTree.verifyTree(this.resizeNode, new ReferenceOpenHashSet<>());
+        WidgetTree.resizeInternal(this.resizeNode, true);
+
+        this.context.popViewport(null);
+        if (!isOverlay()) {
+            this.screenWrapper.updateGuiArea(this.panelManager.getMainPanel().getArea());
+        }
+    }
+
+    /**
+     * Called after the screen is opened, but before the screen and all widgets are resized.
+     */
+    @ApiStatus.OverrideOnly
+    public void onOpen() {}
+
+    /**
+     * Called after the last panel (always the main panel) closes which closes the screen.
+     */
+    @ApiStatus.OverrideOnly
+    public void onClose() {}
+
+    /**
+     * Gently closes all open panels and this screen. If NeverEnoughAnimations is installed and open/close is enabled
+     * this will play the
+     * animation for all open panels and closes the screen after the animation is finished.
+     */
+    public void close() {
+        close(false);
+    }
+
+    /**
+     * Closes all open panels and this screen. If {@code force} is true, the screen will immediately close and skip all
+     * lifecycle steps to
+     * properly close panels and this screen. <b>This should be avoided in most situations</b>.
+     * If {@code force} is false, the panels are gently closed. If NeverEnoughAnimations is installed and open/close is
+     * enabled this will
+     * play the animation for all open panels and closes the screen after the animation is finished.
+     *
+     * @param force true if the screen should be closed immediately without going through remaining lifecycle steps.
+     */
+    @ApiStatus.Internal
+    public void close(boolean force) {
+        if (isActive()) {
+            if (force) {
+                Minecraft.getInstance().popGuiLayer();
+                return;
+            }
+            getMainPanel().closeIfOpen();
+        }
+    }
+
+    /**
+     * Checks if a panel with a given name is currently open in this screen.
+     *
+     * @param name name of the panel
+     * @return true if a panel with the name is open
+     */
+    public boolean isPanelOpen(String name) {
+        return this.panelManager.isPanelOpen(name);
+    }
+
+    /**
+     * Checks if a panel is currently open in this screen.
+     *
+     * @param panel panel to check
+     * @return true if the panel is open
+     */
+    public boolean isPanelOpen(ModularPanel panel) {
+        return this.panelManager.hasOpenPanel(panel);
+    }
+
+    /**
+     * Called at the start of every client tick (20 times per second).
+     */
+    @MustBeInvokedByOverriders
+    public void onUpdate() {
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            WidgetTree.onUpdate(panel);
+        }
+    }
+
+    /**
+     * Called 60 times per second in custom ticks. This logic is separate from rendering.
+     */
+    @MustBeInvokedByOverriders
+    public void onFrameUpdate() {
+        this.panelManager.checkDirty();
+        for (ObjectIterator<Object2ObjectMap.Entry<IWidget, Runnable>> iterator = this.frameUpdates
+                .object2ObjectEntrySet().fastIterator(); iterator.hasNext();) {
+            Object2ObjectMap.Entry<IWidget, Runnable> entry = iterator.next();
+            if (!entry.getKey().isValid()) {
+                iterator.remove();
+                continue;
+            }
+            entry.getValue().run();
+        }
+        this.context.onFrameUpdate();
+    }
+
+    /**
+     * Draws this screen and all open panels with their whole widget tree.
+     * <p>
+     * Do not call, only override!
+     */
+    @Override
+    public void render(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+        Lighting.setupForFlatItems();
+
+        this.context.reset();
+        this.context.pushViewport(null, this.context.getScreenArea());
+        for (ModularPanel panel : this.panelManager.getReverseOpenPanels()) {
+            this.context.updateZ(0);
+            if (panel.disablePanelsBelow()) {
+                GuiDraw.drawRect(graphics, 0, 0, this.context.getScreenArea().w(), this.context.getScreenArea().h(),
+                        Color.argb(16, 16, 16, (int) (125 * panel.getAlpha())));
+            }
+            WidgetTree.drawTree(panel, this.context);
+            // clear depth, so that anything drawn next will be guaranteed to be on top
+            RenderSystem.clearDepth(1);
+            RenderSystem.clear(GL11.GL_DEPTH_BUFFER_BIT, Minecraft.ON_OSX);
+        }
+        this.context.updateZ(0);
+        this.context.popViewport(null);
+
+        this.context.postRenderCallbacks.forEach(element -> element.accept(this.context));
+    }
+
+    /**
+     * Called after all panels with their whole widget trees and potential additional elements are drawn.
+     * <p>
+     * Do not call, only override!
+     */
+    public void drawForeground(GuiGraphics guiGraphics, float partialTicks) {
+        Lighting.setupForFlatItems();
+        RenderSystem.disableDepthTest();
+
+        this.context.reset();
+        this.context.pushViewport(null, this.context.getScreenArea());
+        for (ModularPanel panel : this.panelManager.getReverseOpenPanels()) {
+            this.context.updateZ(100);
+            if (panel.isEnabled()) {
+                WidgetTree.drawTreeForeground(panel, this.context);
+            }
+        }
+        this.context.drawDraggable(guiGraphics);
+        this.context.popViewport(null);
+    }
+
+    /**
+     * Called when a mouse button is pressed or released. Used to handle dropping of currently dragged elements.
+     */
+    public boolean handleDraggableInput(double mouseX, double mouseY, int button, boolean pressed) {
+        if (this.context.hasDraggable()) {
+            if (pressed) {
+                this.context.onMousePressed(mouseX, mouseY, button);
+            } else {
+                this.context.onMouseReleased(mouseX, mouseY, button);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Called when a mouse button is pressed. Tries to invoke
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onMousePressed(double, double, int)
+     * Interactable#onMousePressed(double, double, int)} on every widget under
+     * the mouse after gui action listeners have been called. Will try to focus widgets that have been interacted with.
+     * Focused widgets will be interacted with first in other interaction methods (mouse scroll, release and drag, key
+     * press and release).
+     *
+     * @param mouseX mouse x-coordinate
+     * @param mouseY mouse y-coordinate
+     * @param button mouse button (0 = left button, 1 = right button, 2 = scroll button, 4 and 5 = side buttons)
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    public boolean onMousePressed(double mouseX, double mouseY, int button) {
+        // call all action listeners
+        for (IGuiAction.MousePressed action : getGuiActionListeners(IGuiAction.MousePressed.class)) {
+            action.press(mouseX, mouseY, button);
+        }
+        // check if any context menu is open and close them if they or their children are not hovered
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel instanceof MenuPanel menuPanel) {
+                menuPanel.closeAllMenus(false, true);
+            }
+        }
+        // handle dragging of draggable widgets
+        if (this.context.onMousePressed(mouseX, mouseY, button)) {
+            return true;
+        }
+        // finally click hovered widgets
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onMousePressed(mouseX, mouseY, button)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called when a mouse button is released. Tries to invoke
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onMouseReleased(double, double, int)
+     * Interactable#onMouseRelease(int)} on every widget under
+     * the mouse after gui action listeners have been called.
+     *
+     * @param mouseX mouse x-coordinate
+     * @param mouseY mouse y-coordinate
+     * @param button mouse button (0 = left button, 1 = right button, 2 = scroll button, 4 and 5 = side buttons)
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    @Override
+    public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        for (IGuiAction.MouseReleased action : getGuiActionListeners(IGuiAction.MouseReleased.class)) {
+            action.release(mouseX, mouseY, button);
+        }
+        if (this.context.onMouseReleased(mouseX, mouseY, button)) {
+            return true;
+        }
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onMouseReleased(mouseX, mouseY, button)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called when a keyboard key is pressed. Tries to invoke
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onKeyPressed(int, int, int)
+     * Interactable#onKeyPressed(int, int, int)} on every
+     * widget under the mouse after gui action listeners have been called.
+     *
+     * @param keyCode   the key code of the pressed key (see constants at {@link InputConstants})
+     * @param scanCode  the character of the pressed key or {@link Character#MIN_VALUE} for keys without a character
+     * @param modifiers the key modifiers of the pressed key (see modifiers at {@link InputConstants})
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        for (IGuiAction.KeyPressed action : getGuiActionListeners(IGuiAction.KeyPressed.class)) {
+            action.press(keyCode, scanCode, modifiers);
+        }
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onKeyPressed(keyCode, scanCode, modifiers)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called when a keyboard key is released. Tries to invoke
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onKeyReleased(int, int, int)
+     * Interactable#onKeyRelease(int, int, int)} on every
+     * widget under the mouse after gui action listeners have been called.
+     *
+     * @param keyCode   the key code of the pressed key (see constants at {@link InputConstants})
+     * @param scanCode  the character of the pressed key or {@link Character#MIN_VALUE} for keys without a character
+     * @param modifiers the key modifiers of the pressed key (see modifiers at {@link InputConstants})
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    @Override
+    public boolean keyReleased(int keyCode, int scanCode, int modifiers) {
+        for (IGuiAction.KeyReleased action : getGuiActionListeners(IGuiAction.KeyReleased.class)) {
+            action.release(keyCode, scanCode, modifiers);
+        }
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onKeyReleased(keyCode, scanCode, modifiers)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called when a keyboard key is released. Tries to invoke
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onCharTyped(char, int)
+     * Interactable#onCharTyped(char, int)} on every
+     * widget under the mouse after gui action listeners have been called.
+     *
+     * @param codePoint the code point of the typed character
+     * @param modifiers the key modifiers of the typed character (see modifiers at {@link InputConstants})
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    @Override
+    public boolean charTyped(char codePoint, int modifiers) {
+        for (IGuiAction.CharTyped action : getGuiActionListeners(IGuiAction.CharTyped.class)) {
+            action.type(codePoint, modifiers);
+        }
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onCharTyped(codePoint, modifiers)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called when a mouse button is released. Tries to invoke
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onMouseScrolled(double, double, double)
+     * Interactable#onMouseScrolled(double, double, double)} on every widget under
+     * the mouse after gui action listeners have been called.
+     *
+     * @param mouseX current mouse X coordinate relative to the screen
+     * @param mouseY current mouse Y coordinate relative to the screen
+     * @param delta  the direction and speed of the scroll
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
+        for (IGuiAction.MouseScroll action : getGuiActionListeners(IGuiAction.MouseScroll.class)) {
+            action.scroll(mouseX, mouseY, delta);
+        }
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onMouseScrolled(mouseX, mouseY, delta)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called every time the mouse pos changes and a mouse button is held down. Invokes
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.Interactable#onMouseDrag(double, double, int, double, double)
+     * Interactable#onMouseDrag(double, double, int, double, double)} on every widget
+     * under the mouse after gui action listeners have been called.
+     *
+     * @param mouseX current mouse X coordinate relative to the screen
+     * @param mouseY current mouse Y coordinate relative to the screen
+     * @param button mouse button that is held down
+     *               (0 = left button, 1 = right button, 2 = scroll button, 4 and 5 = side buttons)
+     * @param dragX  the X distance of the drag
+     * @param dragY  the Y distance of the drag
+     * @return true if the action was consumed and further processing should be canceled
+     */
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        for (IGuiAction.MouseDrag action : getGuiActionListeners(IGuiAction.MouseDrag.class)) {
+            action.drag(mouseX, mouseY, button, dragX, dragY);
+        }
+        for (ModularPanel panel : this.panelManager.getOpenPanels()) {
+            if (panel.onMouseDrag(mouseX, mouseY, button, dragX, dragY)) {
+                return true;
+            }
+            if (panel.disablePanelsBelow()) {
+                break;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Called with {@code true} after a widget which implements
+     * {@link com.gregtechceu.gtceu.api.mui.base.widget.IFocusedWidget IFocusedWidget}
+     * has consumed a mouse press and called with {@code false} if a widget is currently focused and anything else has
+     * consumed a mouse
+     * press. This is required for other mods like JEI/EMI to not interfere with inputs.
+     *
+     * @param focus true if the gui screen will be focused
+     */
+    @ApiStatus.Internal
+    public void setFocused(boolean focus) {
+        this.screenWrapper.getWrappedScreen().setFocused(focus);
+    }
+
+    @Override
+    public boolean isFocused() {
+        return this.screenWrapper.getWrappedScreen().isFocused();
+    }
+
+    /**
+     * @return true if this screen is currently open and displayed on the screen
+     */
+    public boolean isActive() {
+        return getCurrent() == this;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "#" + getOwner() + ":" + getName();
+    }
+
+    /**
+     * @return the owner and name as a {@link ResourceLocation}
+     * @see #getOwner()
+     * @see #getName()
+     */
+    public ResourceLocation getResourceLocation() {
+        return new ResourceLocation(this.owner, this.name);
+    }
+
+    public ModularSyncManager getSyncManager() {
+        return getContainer().getSyncManager();
+    }
+
+    public ModularPanel getMainPanel() {
+        return this.panelManager.getMainPanel();
+    }
+
+    public Area getScreenArea() {
+        return this.context.getScreenArea();
+    }
+
+    public boolean isClientOnly() {
+        return isOverlay() || !this.screenWrapper.isGuiContainer() || getContainer().isClientOnly();
+    }
+
+    public ModularContainerMenu getContainer() {
+        if (isOverlay()) {
+            throw new IllegalStateException("Can't get ModularContainer for overlay");
+        }
+        if (this.screenWrapper.getWrappedScreen() instanceof AbstractContainerScreen<?> container) {
+            return (ModularContainerMenu) container.getMenu();
+        }
+        throw new IllegalStateException("Screen does not extend AbstractContainerScreen!");
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T extends IGuiAction> List<T> getGuiActionListeners(Class<T> clazz) {
+        return (List<T>) this.guiActionListeners.getOrDefault(clazz, Collections.emptyList());
+    }
+
+    /**
+     * Registers an interaction listener. This is useful when you want to listen to any GUI interactions and not just
+     * for a specific widget. <br>
+     * <b>Do NOT register listeners which are bound to a widget here!</b>
+     * Use {@link com.gregtechceu.gtceu.api.mui.widget.Widget#listenGuiAction(IGuiAction)
+     * Widget#listenGuiAction(IGuiAction)} for that!
+     *
+     * @param action action listener
+     */
+    public void registerGuiActionListener(IGuiAction action) {
+        // TODO these should be linked to a IWidget, which can be checked for isValid() and is panel open on use ->
+        // proper event system
+        List<IGuiAction> list = this.guiActionListeners.computeIfAbsent(getGuiActionClass(action),
+                key -> new ArrayList<>());
+        if (!list.contains(action)) list.add(action);
+    }
+
+    /**
+     * Removes an interaction listener
+     *
+     * @param action action listener to remove
+     */
+    public void removeGuiActionListener(IGuiAction action) {
+        this.guiActionListeners.getOrDefault(getGuiActionClass(action), Collections.emptyList()).remove(action);
+    }
+
+    /**
+     * Registers a frame update listener which runs approximately 60 times per second.
+     * Listeners are automatically removed if the widget becomes invalid.
+     * If a listener is already registered from the given widget, the listeners get merged.
+     *
+     * @param widget   widget the listener is bound to
+     * @param runnable listener function
+     */
+    public void registerFrameUpdateListener(IWidget widget, Runnable runnable) {
+        registerFrameUpdateListener(widget, runnable, true);
+    }
+
+    /**
+     * Registers a frame update listener which runs approximately 60 times per second.
+     * Listeners are automatically removed if the widget becomes invalid.
+     * If a listener is already registered from the given widget and <code>merge</code> is true, the listeners get
+     * merged.
+     * Otherwise, the current listener is overwritten (if any)
+     *
+     * @param widget   widget the listener is bound to
+     * @param runnable listener function
+     * @param merge    if listener should be merged with existing listener
+     */
+    public void registerFrameUpdateListener(IWidget widget, Runnable runnable, boolean merge) {
+        Objects.requireNonNull(runnable);
+        if (merge) {
+            this.frameUpdates.merge(widget, runnable, (old, now) -> () -> {
+                old.run();
+                now.run();
+            });
+        } else {
+            this.frameUpdates.put(widget, runnable);
+        }
+    }
+
+    /**
+     * Removes all frame update listeners for a widget.
+     *
+     * @param widget widget to remove listeners from
+     */
+    public void removeFrameUpdateListener(IWidget widget) {
+        this.frameUpdates.remove(widget);
+    }
+
+    private static Class<?> getGuiActionClass(IGuiAction action) {
+        Class<?>[] classes = action.getClass().getInterfaces();
+        for (Class<?> clazz : classes) {
+            if (IGuiAction.class.isAssignableFrom(clazz)) {
+                return clazz;
+            }
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public ITheme getCurrentTheme() {
+        if (this.currentTheme == null) {
+            useTheme(this.themeOverride);
+        }
+        return this.currentTheme;
+    }
+
+    /**
+     * Tries to use a specific theme for this screen. If the theme for this screen has been overriden via resource
+     * packs, this method does
+     * nothing.
+     *
+     * @param theme id of theme to use
+     * @return this for builder like usage
+     */
+    public ModularScreen useTheme(String theme) {
+        this.themeOverride = theme;
+        this.currentTheme = IThemeApi.get().getThemeForScreen(this, this.themeOverride);
+        return this;
+    }
+
+    /**
+     * Sets if the gui should pause the game in the background. Pausing means every ticking will halt. If the client is
+     * connected to a
+     * dedicated server the UI will NEVER pause the game.
+     *
+     * @param pausesGame true if the ui should pause the game in the background.
+     * @return this for builder like usage
+     */
+    public ModularScreen pausesGame(boolean pausesGame) {
+        this.pauseScreen = pausesGame;
+        return this;
+    }
+
+    public ModularScreen openParentOnClose(boolean openParentOnClose) {
+        this.openParentOnClose = openParentOnClose;
+        return this;
+    }
+
+    @Override
+    public void setX(int x) {
+        this.panelManager.getMainPanel().getArea().setX(x);
+    }
+
+    @Override
+    public void setY(int y) {
+        this.panelManager.getMainPanel().getArea().setY(y);
+    }
+
+    @Override
+    public int getX() {
+        return this.panelManager.getMainPanel().getArea().getX();
+    }
+
+    @Override
+    public int getY() {
+        return this.panelManager.getMainPanel().getArea().getY();
+    }
+
+    @Override
+    public int getWidth() {
+        return this.panelManager.getMainPanel().getArea().getWidth();
+    }
+
+    @Override
+    public int getHeight() {
+        return this.panelManager.getMainPanel().getArea().getHeight();
+    }
+
+    @Override
+    public @NotNull ScreenRectangle getRectangle() {
+        Area area = this.panelManager.getMainPanel().getArea();
+        return new ScreenRectangle(area.x(), area.y(), area.w(), area.h());
+    }
+
+    @Override
+    public void visitWidgets(@NotNull Consumer<AbstractWidget> consumer) {
+        /*
+         * for (WidgetWrapper wrapper : panelManager.getReverseOpenPanelsWrappers()) {
+         * consumer.accept(wrapper);
+         * }
+         */
+    }
+
+    private static final Component USAGE_NARRATION = Component.translatable("narrator.screen.usage");
+
+    private NarratableEntry lastNarratable = null;
+
+    @Override
+    public void updateNarration(@NotNull NarrationElementOutput output) {
+        output.add(NarratedElementType.USAGE, USAGE_NARRATION);
+        var entries = StreamSupport.stream(panelManager.getReverseOpenPanelsWrappers().spliterator(), false);
+        WidgetWrapper.updateNarrations(entries, output, lastNarratable, entry -> lastNarratable = entry);
+    }
+
+    @Override
+    public @NotNull NarrationPriority narrationPriority() {
+        if (this.isFocused()) return NarrationPriority.FOCUSED;
+        else if (this.context.isHovered()) return NarrationPriority.HOVERED;
+        else return NarrationPriority.NONE;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/OpenScreenEvent.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/OpenScreenEvent.java
new file mode 100644
index 00000000000..e16584a243b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/OpenScreenEvent.java
@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraftforge.eventbus.api.Event;
+
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OpenScreenEvent extends Event {
+
+    @Getter
+    private final Screen screen;
+    private final List<ModularScreen> overlays = new ArrayList<>();
+
+    public OpenScreenEvent(Screen screen) {
+        this.screen = screen;
+    }
+
+    public boolean isModularScreen() {
+        return screen instanceof IMuiScreen;
+    }
+
+    public @Nullable ModularScreen getModularScreen() {
+        return screen instanceof IMuiScreen muiScreen ? muiScreen.getScreen() : null;
+    }
+
+    public List<ModularScreen> getOverlays() {
+        return overlays;
+    }
+
+    public void addOverlay(ModularScreen screen) {
+        this.overlays.add(screen);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/PanelManager.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/PanelManager.java
new file mode 100644
index 00000000000..2435acf50ed
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/PanelManager.java
@@ -0,0 +1,504 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.ObjectList;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.wrapper.WidgetWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.LocatedWidget;
+import com.gregtechceu.gtceu.utils.ReverseIterable;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.*;
+import java.util.function.Supplier;
+
+public class PanelManager {
+
+    private static final int DISPOSAL_CAPACITY = 1 << 4;
+
+    @Getter
+    private final @NotNull ModularScreen screen;
+    /**
+     * At least one panel must exist always exist.
+     * If this panel is closed, all panels will close.
+     */
+    private final ModularPanel mainPanel;
+    /**
+     * List of all open panels from top to bottom.
+     */
+    private final ObjectList<ModularPanel> panels = ObjectList.create();
+    // a clone of the list to avoid CMEs
+    private final List<ModularPanel> panelsClone = new ArrayList<>();
+    private final List<ModularPanel> panelsView = Collections.unmodifiableList(this.panelsClone);
+    private final ReverseIterable<ModularPanel> reversePanels = new ReverseIterable<>(this.panelsView);
+    private final List<WidgetWrapper> panelWrappers = new ArrayList<>();
+    private final List<WidgetWrapper> panelWrappersView = Collections.unmodifiableList(this.panelWrappers);
+    private final ReverseIterable<WidgetWrapper> reversePanelWrappers = new ReverseIterable<>(this.panelWrappersView);
+    private final ObjectList<ModularPanel> disposal = ObjectList.create(DISPOSAL_CAPACITY);
+    private final Map<String, IPanelHandler> panelHandlerMap = new Object2ObjectOpenHashMap<>();
+    private boolean cantDisposeNow = false;
+    private boolean dirty = false;
+    private State state = State.INIT;
+
+    public PanelManager(@NotNull ModularScreen screen, ModularPanel panel) {
+        this.screen = screen;
+        this.mainPanel = Objects.requireNonNull(panel, "Main panel must not be null!");
+    }
+
+    boolean tryInit() {
+        return switch (this.state) {
+            case WAIT_DISPOSAL -> throw new IllegalStateException(
+                    "Tried to open panel while its waiting to be disposed. This shouldn't happen.");
+            case OPEN, REOPENED -> false;
+            case CLOSED -> {
+                if (this.panels.isEmpty()) {
+                    throw new IllegalStateException("Can't init in closed state!");
+                }
+                this.panels.forEach(ModularPanel::reopen);
+                this.disposal.removeIf(this.panels::contains);
+                setState(State.REOPENED);
+                yield true;
+            }
+            case INIT, DISPOSED -> {
+                setState(State.OPEN);
+                openPanel(this.mainPanel, false);
+                checkDirty();
+                yield true;
+            }
+        };
+    }
+
+    public boolean isMainPanel(ModularPanel panel) {
+        return this.mainPanel == panel;
+    }
+
+    void checkDirty() {
+        if (this.dirty) {
+            this.panelsClone.clear();
+            this.panelsClone.addAll(this.panels);
+
+            /*
+             * this.panelWrappers.clear();
+             * this.panelsClone.stream()
+             * .map(WidgetWrapper::new)
+             * .forEach(this.panelWrappers::add);
+             */
+
+            this.dirty = false;
+        }
+    }
+
+    @NotNull
+    public List<LocatedWidget> getAllHoveredWidgetsList(boolean debug) {
+        for (ModularPanel panel : this.panels) {
+            if (panel.isAnyHovered()) {
+                return panel.getAllHoveringList(debug);
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    @Nullable
+    public ModularPanel getTopHoveredPanel() {
+        for (ModularPanel panel : this.panels) {
+            if (panel.isAnyHovered()) return panel;
+        }
+        return null;
+    }
+
+    public boolean isBelowMouseInTopPanel(IWidget widget) {
+        for (ModularPanel panel : this.panels) {
+            if (panel.isAnyHovered()) {
+                return panel.isBelowMouse(widget);
+            }
+        }
+        return false;
+    }
+
+    private void openPanel(ModularPanel panel, boolean resize) {
+        if (this.panels.size() == 127) {
+            throw new IllegalStateException("Too many panels are open!");
+        }
+        if (this.panels.contains(panel) || isPanelOpen(panel.getName())) {
+            throw new IllegalStateException("Panel " + panel.getName() + " is already open.");
+        }
+        this.disposal.remove(panel);
+        panel.setPanelGuiContext(this.screen.getContext());
+        this.panels.add(0, panel);
+        this.dirty = true;
+        panel.onOpen(this.screen);
+        if (resize) {
+            WidgetTree.resizeInternal(panel.resizer(), true);
+        }
+    }
+
+    public boolean isPanelOpen(String name) {
+        for (ModularPanel panel : this.panels) {
+            if (panel.getName().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @NotNull
+    public ModularPanel getMainPanel() {
+        if (isDisposed()) {
+            throw new IllegalStateException("Screen has been disposed");
+        }
+        return this.mainPanel;
+    }
+
+    /**
+     * Returns the panel that was opened last.
+     *
+     * @return last opened panel
+     * @throws IndexOutOfBoundsException if the current state is {@link State#DISPOSED}
+     */
+    @NotNull
+    public ModularPanel getTopMostPanel() {
+        return this.panels.get(0);
+    }
+
+    @Nullable
+    public IWidget getTopWidget() {
+        for (ModularPanel panel : this.panels) {
+            IWidget widget = panel.getTopHovering();
+            if (widget != null) {
+                return widget;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public LocatedWidget getTopWidgetLocated(boolean debug) {
+        for (ModularPanel panel : this.panels) {
+            LocatedWidget widget = panel.getTopHoveringLocated(debug);
+            if (widget != null) {
+                return widget;
+            }
+        }
+        return null;
+    }
+
+    @ApiStatus.Internal
+    public void openPanel(@NotNull ModularPanel panel, @NotNull IPanelHandler panelHandler) {
+        IPanelHandler existing = this.panelHandlerMap.get(panel.getName());
+        if (existing == null) {
+            this.panelHandlerMap.put(panel.getName(), panelHandler);
+        } else if (existing != panelHandler) {
+            GTCEu.LOGGER.error(
+                    "Tried to open a panel, but a panel handler that opens the same panel already exists. Using existing panel handler!");
+            existing.openPanel();
+            return;
+        }
+        openPanel(panel, true);
+    }
+
+    public void closePanel(@NotNull ModularPanel panel) {
+        if (!hasOpenPanel(panel)) {
+            throw new IllegalArgumentException("Panel '" + panel.getName() + "' is open in this screen!");
+        }
+        if (panel == getMainPanel()) {
+            closeAll();
+            this.screen.close(true);
+            return;
+        }
+        if (this.panels.remove(panel)) {
+            finalizePanel(panel);
+            this.dirty = true;
+        }
+    }
+
+    public void closeTopPanel() {
+        getTopMostPanel().closeIfOpen();
+    }
+
+    public boolean closeAll() {
+        if (this.state.isOpen) {
+            // any open panel will be set to closed, but will not actually be removed, so it can be reopened
+            this.panels.forEach(this::finalizePanel);
+            setState(State.CLOSED);
+            this.screen.onClose();
+            return true;
+        }
+        return false;
+    }
+
+    void closeScreen() {
+        // only close the screen without closing the panels
+        // this is useful when we expect the screen to reopen at some point and the sync managers are still available
+        if (this.state.isOpen) {
+            setState(State.CLOSED);
+            this.screen.onClose();
+        }
+    }
+
+    private void finalizePanel(ModularPanel panel) {
+        if (panel.isOpen()) panel.onClose();
+        if (!this.disposal.contains(panel)) {
+            if (this.disposal.size() == DISPOSAL_CAPACITY) {
+                this.disposal.remove(0).dispose();
+            }
+            this.disposal.add(panel);
+        }
+    }
+
+    public <T> T doSafe(Supplier<T> runnable) {
+        if (isDisposed()) return null;
+        this.cantDisposeNow = true;
+        T t = runnable.get();
+        this.cantDisposeNow = false;
+        if (this.state == State.WAIT_DISPOSAL) {
+            setState(State.CLOSED);
+            dispose();
+        }
+        return t;
+    }
+
+    @ApiStatus.Internal
+    public void dispose() {
+        if (isDisposed()) return;
+        if (this.state != State.CLOSED && this.state != State.WAIT_DISPOSAL) {
+            throw new IllegalStateException("Must close screen first before disposing!");
+        }
+        if (this.cantDisposeNow) {
+            setState(State.WAIT_DISPOSAL);
+            return;
+        }
+        // make sure every panel gets closed before disposing
+        this.panels.forEach(this::finalizePanel);
+        setState(State.CLOSED);
+        this.disposal.forEach(ModularPanel::dispose);
+        this.disposal.clear();
+        this.panels.clear();
+        this.panelsClone.clear();
+        this.panelWrappers.clear();
+        this.dirty = false;
+        setState(State.DISPOSED);
+    }
+
+    public boolean hasOpenPanel(ModularPanel panel) {
+        return this.panels.contains(panel);
+    }
+
+    public boolean hasPanelOpen(String name) {
+        return getOpenPanel(name) != null;
+    }
+
+    public @Nullable ModularPanel getOpenPanel(String name) {
+        for (ModularPanel panel : this.panels) {
+            if (panel.getName().equals(name)) {
+                return panel;
+            }
+        }
+        return null;
+    }
+
+    public int getOpenPanelCount() {
+        return this.panels.size();
+    }
+
+    public int getPanelIndex(ModularPanel panel) {
+        return this.panels.indexOf(panel);
+    }
+
+    public int getPanelIndexOrFail(ModularPanel panel, String action) {
+        int index = getPanelIndex(panel);
+        if (index < 0) {
+            throw new IllegalArgumentException("Failed to perform action '" + action + "' on panel '" + panel +
+                    "', because it is not open in this screen");
+        }
+        return index;
+    }
+
+    public void pushUp(@NotNull ModularPanel panel) {
+        int index = getPanelIndexOrFail(panel, "push up");
+        if (index == 0) return;
+        movePanel(index, index - 1);
+    }
+
+    public void pushDown(@NotNull ModularPanel panel) {
+        int index = getPanelIndexOrFail(panel, "push down");
+        if (index == this.panels.size() - 1) return;
+        movePanel(index, index + 1);
+    }
+
+    public void pushToTop(@NotNull ModularPanel window) {
+        int index = getPanelIndexOrFail(window, "push to top");
+        if (index == 0) return;
+        movePanel(index, 0);
+    }
+
+    public void pushToBottom(@NotNull ModularPanel window) {
+        int index = getPanelIndexOrFail(window, "push to bottom");
+        if (index == this.panels.size() - 1) return;
+        movePanel(index, -1);
+    }
+
+    public void movePanelAbove(ModularPanel panelToMove, ModularPanel target) {
+        int index = getPanelIndexOrFail(panelToMove, "move panel after");
+        if (index == 0) return;
+        int targetIndex = getTopSubPanelIndexOf(target);
+        if (targetIndex < 0) {
+            throw new IllegalArgumentException("Could not find target or a sub panel of '" + target + "'.");
+        }
+        movePanel(index, targetIndex);
+    }
+
+    public void movePanelBelow(ModularPanel panelToMove, ModularPanel target) {
+        int index = getPanelIndexOrFail(panelToMove, "move panel after");
+        if (index == this.panels.size() - 1) return;
+        int targetIndex = getBottomSubPanelIndexOf(target);
+        if (targetIndex < 0) {
+            throw new IllegalArgumentException("Could not find target or a sub panel of '" + target + "'.");
+        }
+        movePanel(index, targetIndex + 1);
+    }
+
+    private void movePanel(int panelIndex, int target) {
+        if (target < 0) target += this.panels.size();
+        else if (panelIndex < target) target--;
+        ModularPanel panel = this.panels.remove(panelIndex);
+        this.panels.add(target, panel);
+        this.dirty = true;
+    }
+
+    private int getTopSubPanelIndexOf(ModularPanel target) {
+        int targetIndex = -1;
+        for (int i = this.panels.size() - 1; i >= 0; i--) {
+            ModularPanel panel = this.panels.get(i);
+            if (isSubPanelOf(panel, target)) {
+                targetIndex = i;
+                continue;
+            }
+            break;
+        }
+        return targetIndex;
+    }
+
+    private int getBottomSubPanelIndexOf(ModularPanel target) {
+        int targetIndex = -1;
+        for (int i = 0; i < this.panels.size(); i++) {
+            ModularPanel panel = this.panels.get(i);
+            if (isSubPanelOf(panel, target)) {
+                targetIndex = i;
+                continue;
+            }
+            break;
+        }
+        return targetIndex;
+    }
+
+    public boolean isSubPanelOf(ModularPanel panel, ModularPanel target) {
+        if (panel == target) return true;
+        IPanelHandler panelHandler = this.panelHandlerMap.get(panel.getName());
+        while (panelHandler != null) {
+            if (panelHandler instanceof SecondaryPanel secPanel) {
+                if (secPanel.getParent() == target) {
+                    return true;
+                }
+                panelHandler = this.panelHandlerMap.get(secPanel.getParent().getName());
+            } else {
+                break;
+            }
+        }
+        return false;
+    }
+
+    @NotNull
+    @UnmodifiableView
+    public List<ModularPanel> getOpenPanels() {
+        checkDirty();
+        return this.panelsView;
+    }
+
+    @NotNull
+    @UnmodifiableView
+    public Iterable<ModularPanel> getReverseOpenPanels() {
+        checkDirty();
+        return this.reversePanels;
+    }
+
+    @NotNull
+    @UnmodifiableView
+    public List<WidgetWrapper> getOpenPanelsWrappers() {
+        checkDirty();
+        return this.panelWrappersView;
+    }
+
+    @NotNull
+    @UnmodifiableView
+    public Iterable<WidgetWrapper> getReverseOpenPanelsWrappers() {
+        checkDirty();
+        return this.reversePanelWrappers;
+    }
+
+    private void setState(State state) {
+        this.state = Objects.requireNonNull(state);
+    }
+
+    public boolean isClosed() {
+        return this.state == State.CLOSED || this.state == State.DISPOSED;
+    }
+
+    public boolean isDisposed() {
+        return this.state == State.DISPOSED;
+    }
+
+    public boolean isOpen() {
+        return this.state.isOpen;
+    }
+
+    public boolean isReopened() {
+        return this.state == State.REOPENED;
+    }
+
+    private void checkDisposed() {
+        if (isDisposed()) {
+            throw new IllegalStateException("Screen is disposed!");
+        }
+    }
+
+    public enum State {
+
+        /**
+         * Screen is created, but not yet opened.
+         */
+        INIT(false),
+        /**
+         * Screen is open after init, or after it was disposed and opened again.
+         */
+        OPEN(true),
+        /**
+         * Screen was closed, but is now open again.
+         */
+        REOPENED(true),
+        /**
+         * Screen is closed after it was open. Panels may still be considered open in some cases.
+         */
+        CLOSED(false),
+        /**
+         * Screen is closed and waiting to be disposed.
+         */
+        WAIT_DISPOSAL(false),
+        /**
+         * Screen is disposed. Screen can be reopened in this state, but every panel has to be rebuilt.
+         */
+        DISPOSED(false);
+
+        public final boolean isOpen;
+
+        State(boolean isOpen) {
+            this.isOpen = isOpen;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/RecipeViewerSettingsImpl.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/RecipeViewerSettingsImpl.java
new file mode 100644
index 00000000000..08da46495a8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/RecipeViewerSettingsImpl.java
@@ -0,0 +1,170 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.RecipeViewerSettings;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.integration.recipeviewer.RecipeViewerState;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Keeps track of everything related to JEI in a Modular GUI.
+ * By default, JEI is disabled in client only GUIs.
+ * This class can be safely interacted with even when JEI/HEI is not installed.
+ */
+@OnlyIn(Dist.CLIENT)
+public class RecipeViewerSettingsImpl implements RecipeViewerSettings {
+
+    private RecipeViewerState recipeViewerState = RecipeViewerState.DEFAULT;
+    private final List<IWidget> exclusionWidgets = new ArrayList<>();
+    private final List<Rectangle> exclusionAreas = new ArrayList<>();
+    private final List<GhostIngredientSlot<?>> ghostIngredientSlots = new ArrayList<>();
+
+    /**
+     * Force JEI to be enabled
+     */
+    @Override
+    public void enable() {
+        this.recipeViewerState = RecipeViewerState.ENABLED;
+    }
+
+    /**
+     * Force JEI to be disabled
+     */
+    @Override
+    public void disable() {
+        this.recipeViewerState = RecipeViewerState.DISABLED;
+    }
+
+    /**
+     * Only enabled JEI in synced GUIs
+     */
+    @Override
+    public void defaultState() {
+        this.recipeViewerState = RecipeViewerState.DEFAULT;
+    }
+
+    /**
+     * Checks if JEI is enabled for a given screen
+     *
+     * @param screen modular screen
+     * @return true if jei is enabled
+     */
+    @Override
+    public boolean isEnabled(ModularScreen screen) {
+        return this.recipeViewerState.test(screen);
+    }
+
+    /**
+     * Adds an exclusion zone. JEI will always try to avoid exclusion zones. <br>
+     * <b>If a widgets wishes to have an exclusion zone it should use {@link #addExclusionArea(IWidget)}!</b>
+     *
+     * @param area exclusion area
+     */
+    @Override
+    public void addExclusionArea(Rectangle area) {
+        if (!this.exclusionAreas.contains(area)) {
+            this.exclusionAreas.add(area);
+        }
+    }
+
+    /**
+     * Removes an exclusion zone.
+     *
+     * @param area exclusion area to remove (must be the same instance)
+     */
+    @Override
+    public void removeExclusionArea(Rectangle area) {
+        this.exclusionAreas.remove(area);
+    }
+
+    /**
+     * Adds an exclusion zone of a widget. JEI will always try to avoid exclusion zones. <br>
+     * Useful when a widget is outside its panel.
+     *
+     * @param area widget
+     */
+    @Override
+    public void addExclusionArea(IWidget area) {
+        if (!this.exclusionWidgets.contains(area)) {
+            this.exclusionWidgets.add(area);
+        }
+    }
+
+    /**
+     * Removes a widget exclusion area.
+     *
+     * @param area widget
+     */
+    @Override
+    public void removeExclusionArea(IWidget area) {
+        this.exclusionWidgets.remove(area);
+    }
+
+    /**
+     * Adds a JEI ghost slots. Ghost slots can display an ingredient, but the ingredient does not really exist.
+     * By calling this method users will be able to drag ingredients from JEI into the slot.
+     *
+     * @param slot slot widget
+     * @param <W>  slot widget type
+     */
+    @Override
+    public <W extends IWidget & GhostIngredientSlot<?>> void addGhostIngredientSlot(W slot) {
+        if (!this.ghostIngredientSlots.contains(slot)) {
+            this.ghostIngredientSlots.add(slot);
+        }
+    }
+
+    /**
+     * Removes a JEI ghost slot.
+     *
+     * @param slot slot widget
+     * @param <W>  slot widget type
+     */
+    @Override
+    public <W extends IWidget & GhostIngredientSlot<?>> void removeGhostIngredientSlot(W slot) {
+        this.ghostIngredientSlots.remove(slot);
+    }
+
+    @UnmodifiableView
+    public List<Rectangle> getExclusionAreas() {
+        return Collections.unmodifiableList(this.exclusionAreas);
+    }
+
+    @UnmodifiableView
+    public List<IWidget> getExclusionWidgets() {
+        return Collections.unmodifiableList(this.exclusionWidgets);
+    }
+
+    @UnmodifiableView
+    public List<GhostIngredientSlot<?>> getGhostIngredientSlots() {
+        return Collections.unmodifiableList(this.ghostIngredientSlots);
+    }
+
+    @ApiStatus.Internal
+    public List<Rectangle> getAllExclusionAreas() {
+        this.exclusionWidgets.removeIf(widget -> !widget.isValid());
+        List<Rectangle> areas = new ArrayList<>(this.exclusionAreas);
+        for (Iterator<IWidget> iterator = this.exclusionWidgets.iterator(); iterator.hasNext();) {
+            IWidget widget = iterator.next();
+            if (!widget.isValid()) {
+                iterator.remove();
+                continue;
+            }
+            if (widget.isEnabled()) {
+                areas.add(widget.getArea());
+            }
+        }
+        return areas;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/RichTooltip.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/RichTooltip.java
new file mode 100644
index 00000000000..195e658e844
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/RichTooltip.java
@@ -0,0 +1,451 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IRichTextBuilder;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.drawable.text.RichText;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.event.RichTooltipEvent;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.client.gui.screens.inventory.tooltip.DefaultTooltipPositioner;
+import net.minecraft.locale.Language;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.util.Mth;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.inventory.tooltip.TooltipComponent;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.client.event.RenderTooltipEvent;
+import net.minecraftforge.common.MinecraftForge;
+
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.datafixers.util.Either;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import lombok.experimental.Tolerate;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+@Accessors(fluent = true, chain = true)
+public class RichTooltip implements IRichTextBuilder<RichTooltip> {
+
+    private static final Area HOLDER = new Area();
+
+    private final RichText text = new RichText();
+    @Setter
+    private Consumer<Area> parent;
+    @Setter
+    private Pos pos = null;
+    private Consumer<RichTooltip> tooltipBuilder;
+    @Getter
+    @Setter
+    private int showUpTimer = 0;
+    @Getter
+    @Setter
+    private boolean autoUpdate = false;
+    private int titleMargin = 0;
+    private boolean appliedMargin = true;
+
+    private int x = 0, y = 0;
+    private int maxWidth = Integer.MAX_VALUE;
+
+    private boolean dirty;
+
+    public RichTooltip() {
+        parent(Area.ZERO);
+    }
+
+    @Override
+    public RichTooltip reset() {
+        clearText();
+        this.pos = null;
+        this.tooltipBuilder = null;
+        this.showUpTimer = 0;
+        this.autoUpdate = false;
+        this.titleMargin = 0;
+        this.appliedMargin = true;
+        this.x = 0;
+        this.y = 0;
+        this.maxWidth = Integer.MAX_VALUE;
+        return this;
+    }
+
+    @Tolerate
+    public RichTooltip parent(Area parent) {
+        return parent(area -> area.set(parent));
+    }
+
+    @Tolerate
+    public RichTooltip parent(Supplier<Area> parent) {
+        return parent(area -> area.set(parent.get()));
+    }
+
+    @Tolerate
+    public RichTooltip parent(IWidget parent) {
+        return parent(area -> {
+            area.setPos(0, 0);
+            area.setSize(parent.getArea());
+        });
+    }
+
+    public void buildTooltip() {
+        this.dirty = false;
+        if (this.tooltipBuilder != null) {
+            this.text.clearText();
+            this.tooltipBuilder.accept(this);
+            this.appliedMargin = false;
+        }
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void draw(GuiContext context) {
+        draw(context, ItemStack.EMPTY);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void draw(GuiContext context, @Nullable ItemStack stack) {
+        if (this.autoUpdate) markDirty();
+        if (isEmpty()) return;
+
+        if (this.maxWidth <= 0) {
+            this.maxWidth = Integer.MAX_VALUE;
+        }
+        if (stack == null) stack = ItemStack.EMPTY;
+        if (!this.appliedMargin) {
+            if (this.titleMargin > 0) {
+                this.text.insertTitleMargin(this.titleMargin);
+            }
+            this.appliedMargin = true;
+        }
+        Area screen = context.getScreenArea();
+        this.maxWidth = Math.min(this.maxWidth, screen.width);
+        int mouseX = context.getAbsMouseX(), mouseY = context.getAbsMouseY();
+        TextRenderer renderer = TextRenderer.SHARED;
+        // this only turns the text and not any drawables into strings
+        List<Either<FormattedText, TooltipComponent>> textLines = this.text.getAsText().stream()
+                .<Either<FormattedText, TooltipComponent>>map(Either::left)
+                .collect(Collectors.toList());
+
+        var gatherEvent = new RenderTooltipEvent.GatherComponents(stack, screen.width, screen.height,
+                textLines, this.maxWidth);
+        if (MinecraftForge.EVENT_BUS.post(gatherEvent)) {
+            // canceled
+            return;
+        }
+
+        this.maxWidth = gatherEvent.getMaxWidth();
+        textLines = gatherEvent.getTooltipElements();
+        List<ClientTooltipComponent> components = textLines.stream()
+                .map(either -> either.map(
+                        text -> ClientTooltipComponent.create(text instanceof Component component ?
+                                component.getVisualOrderText() : Language.getInstance().getVisualOrder(text)),
+                        ClientTooltipComponent::create))
+                .toList();
+
+        RichText copy = this.text.copy();
+
+        RichTooltipEvent.Pre event = new RichTooltipEvent.Pre(stack, context.getGraphics(),
+                mouseX, mouseY, screen.width, screen.height,
+                context.getFont(), components, DefaultTooltipPositioner.INSTANCE, copy);
+        if (MinecraftForge.EVENT_BUS.post(event)) {
+            // canceled
+            return;
+        }
+        // we are supposed to now use the strings of the event, but we can't properly determine where to put them
+        mouseX = event.getX();
+        mouseY = event.getY();
+        int screenWidth = event.getScreenWidth(), screenHeight = event.getScreenHeight();
+
+        context.setOverrideFont(event.getFont());
+
+        // simulate to figure how big this tooltip is without any restrictions
+        copy.setupRenderer(renderer, 0, 0, this.maxWidth, -1, Color.WHITE.main, false);
+        copy.compileAndDraw(renderer, context, true);
+
+        Rectangle area = determineTooltipArea(copy, context, renderer, screenWidth, screenHeight, mouseX, mouseY);
+
+        Lighting.setupForFlatItems();
+        RenderSystem.disableDepthTest();
+        RenderSystem.disableBlend();
+
+        context.getGraphics().pose().pushPose();
+        context.getGraphics().pose().translate(0, 0, 400);
+        GuiDraw.drawTooltipBackground(context, stack, components, area.x, area.y, area.width, area.height, this);
+
+        // MinecraftForge.EVENT_BUS.post(new RenderTooltipEvent.PostBackground(stack, textLines, area.x, area.y,
+        // TextRenderer.getFont(), area.width, area.height));
+
+        RenderSystem.setShaderColor(1f, 1f, 1f, 1f);
+
+        renderer.setPos(area.x, area.y);
+        this.text.compileAndDraw(renderer, context, false);
+        context.getGraphics().pose().popPose();
+
+        context.setOverrideFont(null);
+    }
+
+    public Rectangle determineTooltipArea(RichText text, GuiContext context, TextRenderer renderer,
+                                          int screenWidth, int screenHeight, int mouseX, int mouseY) {
+        int width = (int) renderer.getLastWidth();
+        int height = (int) renderer.getLastHeight();
+        if (width > screenWidth - 14) {
+            width = screenWidth - 14;
+        }
+
+        Pos pos = this.pos;
+        if (pos == null) {
+            pos = ConfigHolder.INSTANCE.client.ui.tooltipPos;
+        }
+        if (pos == Pos.FIXED) {
+            return new Rectangle(this.x, this.y, width, height);
+        }
+
+        Area area = HOLDER;
+        this.parent.accept(area);
+        if (area.x == 0 && area.y == 0 && area.width == 0 && area.height == 0) {
+            pos = Pos.NEXT_TO_MOUSE;
+        }
+
+        if (pos == Pos.NEXT_TO_MOUSE) {
+            // vanilla style, tooltip floats next to mouse
+            // note that this behaves slightly different from vanilla (better imo)
+            final int padding = 8;
+            // magic number to place tooltip nicer. Look at Screen#L237
+            final int mouseOffset = 12;
+            int x = mouseX + mouseOffset, y = mouseY - mouseOffset;
+            if (x < padding) {
+                x = padding; // this can't happen mathematically since mouse is always positive
+            } else if (x + width + padding > screenWidth) {
+                // doesn't fit on the right side of the screen
+                if (screenWidth - mouseX < mouseX) { // check if left side has more space
+                    x -= mouseOffset * 2 + width; // flip side of cursor if other side has more space
+                    if (x < padding) {
+                        x = padding; // went off-screen
+                    }
+                    width = mouseX - mouseOffset - padding; // max space on left side
+                } else {
+                    width = screenWidth - padding - x; // max space on right side
+                }
+                // recalculate width and height
+                renderer.setPos(x, y);
+                renderer.setAlignment(text.getAlignment(), width, -1);
+                text.compileAndDraw(renderer, context, true);
+                width = (int) renderer.getLastWidth();
+                height = (int) renderer.getLastHeight();
+            }
+            y = Mth.clamp(y, padding, screenHeight - padding - height);
+            return new Rectangle(x, y, width, height);
+        }
+
+        // the rest of the cases will put the tooltip next a given area
+        if (this.parent == null) {
+            throw new IllegalStateException("Tooltip pos is " + pos.name() + ", but no widget parent is set!");
+        }
+
+        int minWidth = text.getMinWidth();
+
+        int shiftAmount = 10;
+        int padding = 7;
+
+        area.transformAndRectanglerize(context);
+        int x = 0, y = 0;
+        if (pos.axis.isVertical()) { // above or below
+            x = area.x + (width < area.width ? shiftAmount : -shiftAmount);
+            x = Mth.clamp(x, padding, screenWidth - padding - width);
+
+            if (pos == Pos.VERTICAL) {
+                int bottomSpace = screenHeight - area.ey();
+                pos = bottomSpace < height + padding && bottomSpace < area.y ? Pos.ABOVE : Pos.BELOW;
+            }
+
+            if (pos == Pos.BELOW) {
+                y = area.ey() + padding;
+            } else if (pos == Pos.ABOVE) {
+                y = area.y - height - padding;
+            }
+        } else if (pos.axis.isHorizontal()) {
+            boolean usedMoreSpaceSide = false;
+            Pos oPos = pos;
+            if (oPos == Pos.HORIZONTAL) {
+                if (area.x > screenWidth - area.ex()) {
+                    pos = Pos.LEFT;
+                    // x = 0;
+                } else {
+                    pos = Pos.RIGHT;
+                    x = screenWidth - area.ex() + padding;
+                }
+            }
+
+            if (height < area.height) {
+                y = area.y + shiftAmount;
+
+            } else {
+                y = area.y - shiftAmount;
+                if (y < padding) {
+                    y = padding;
+                }
+            }
+
+            if (x + width > screenWidth - padding) {
+                int maxWidth;
+                if (pos == Pos.LEFT) {
+                    maxWidth = Math.max(minWidth, area.x - padding * 2);
+                } else {
+                    maxWidth = Math.max(minWidth, screenWidth - area.ex() - padding * 2);
+                }
+                usedMoreSpaceSide = true;
+                renderer.setAlignment(this.text.getAlignment(), maxWidth);
+                this.text.compileAndDraw(renderer, context, true);
+                width = (int) renderer.getLastWidth();
+                height = (int) renderer.getLastHeight();
+            }
+
+            if (oPos == Pos.HORIZONTAL && !usedMoreSpaceSide) {
+                int rightSpace = screenWidth - area.ex();
+                pos = rightSpace < width + padding && rightSpace < area.x ? Pos.LEFT : Pos.RIGHT;
+            }
+
+            if (pos == Pos.RIGHT) {
+                x = area.ex() + padding;
+            } else if (pos == Pos.LEFT) {
+                x = area.x - width - padding;
+                if (x < padding) {
+                    x = padding;
+                    width = area.x - x - padding;
+                }
+            }
+        }
+        return new Rectangle(x, y, width, height);
+    }
+
+    public boolean isEmpty() {
+        if (this.dirty) buildTooltip();
+        return this.text.isEmpty();
+    }
+
+    public void markDirty() {
+        this.dirty = true;
+    }
+
+    public RichTooltip pos(int x, int y) {
+        this.pos = Pos.FIXED;
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    @Override
+    public RichTooltip getThis() {
+        return this;
+    }
+
+    @Override
+    public IRichTextBuilder<?> getRichText() {
+        return text;
+    }
+
+    public RichTooltip tooltipBuilder(Consumer<RichTooltip> tooltipBuilder) {
+        Consumer<RichTooltip> existingBuilder = this.tooltipBuilder;
+        if (existingBuilder != null && tooltipBuilder != null) {
+            this.tooltipBuilder = tooltip -> {
+                existingBuilder.accept(this);
+                tooltipBuilder.accept(this);
+            };
+        } else {
+            this.tooltipBuilder = tooltipBuilder;
+        }
+        markDirty();
+        return this;
+    }
+
+    public RichTooltip addFromItem(ItemStack item) {
+        List<Component> lines = MCHelper.getItemToolTip(item);
+        add(lines.get(0));
+        if (lines.size() > 1) {
+            spaceLine();
+            for (int i = 1, n = lines.size(); i < n; i++) {
+                add(lines.get(i)).newLine();
+            }
+        }
+        return this;
+    }
+
+    public RichTooltip titleMargin() {
+        return titleMargin(0);
+    }
+
+    public RichTooltip titleMargin(int margin) {
+        this.titleMargin = margin;
+        this.appliedMargin = false;
+        return this;
+    }
+
+    public static void findIngredientArea(Area area, int x, int y) {
+        Screen screen = MCHelper.getCurrentScreen();
+        if (screen instanceof AbstractContainerScreen<?> containerScreen) {
+            Slot slot = containerScreen.getSlotUnderMouse();
+            if (slot != null) {
+                int sx = slot.x + containerScreen.getGuiLeft();
+                int sy = slot.y + containerScreen.getGuiTop();
+                if (sx >= 0 && sy >= 0) {
+                    area.set(sx - 1, sy - 1, 18, 18);
+                    return;
+                }
+            }
+        }
+        /*
+         * TODO fix this JEI compat thing
+         * if (GTCEu.Mods.isJEILoaded()) {
+         * IShowsRecipeFocuses overlay = (IShowsRecipeFocuses)
+         * ModularUIJeiPlugin.getRuntime().getIngredientListOverlay();
+         * IClickedIngredient<?> ingredient = overlay.getIngredientUnderMouse(x, y);
+         * if (ingredient == null || ingredient.getArea() == null) {
+         * overlay = (IShowsRecipeFocuses) ModularUIJeiPlugin.getRuntime().getBookmarkOverlay();
+         * ingredient = overlay.getIngredientUnderMouse(x, y);
+         * }
+         * if (ingredient != null && ingredient.getArea() != null) {
+         * Rectangle slot = ingredient.getArea();
+         * area.set(slot.x - 1, slot.y - 1, 18, 18);
+         * return;
+         * }
+         * }
+         */
+        area.set(Area.ZERO);
+    }
+
+    public enum Pos {
+
+        ABOVE(GuiAxis.Y),
+        BELOW(GuiAxis.Y),
+        LEFT(GuiAxis.X),
+        RIGHT(GuiAxis.X),
+        VERTICAL(GuiAxis.Y),
+        HORIZONTAL(GuiAxis.X),
+        NEXT_TO_MOUSE(null),
+        FIXED(null);
+
+        public final GuiAxis axis;
+
+        Pos(GuiAxis axis) {
+            this.axis = axis;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ScreenWrapper.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ScreenWrapper.java
new file mode 100644
index 00000000000..771e5cd9dbd
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/ScreenWrapper.java
@@ -0,0 +1,40 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+@OnlyIn(Dist.CLIENT)
+public class ScreenWrapper extends Screen implements IMuiScreen {
+
+    @Getter
+    private final @NotNull ModularScreen screen;
+
+    public ScreenWrapper(@NotNull ModularScreen screen) {
+        super(Component.empty());
+        this.screen = screen;
+        this.screen.construct(this);
+    }
+
+    @Override
+    public void renderBackground(@NotNull GuiGraphics guiGraphics) {
+        handleDrawBackground(guiGraphics, super::renderBackground);
+    }
+
+    @Override
+    public boolean isPauseScreen() {
+        return this.screen.isPauseScreen();
+    }
+
+    @Override
+    public String toString() {
+        return "Wrapper(" + getScreen() + ")";
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/SecondaryPanel.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/SecondaryPanel.java
new file mode 100644
index 00000000000..992da7a237e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/SecondaryPanel.java
@@ -0,0 +1,106 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+
+import net.minecraft.world.entity.player.Player;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.Objects;
+
+public class SecondaryPanel implements IPanelHandler {
+
+    @Getter
+    private final ModularPanel parent;
+    private final IPanelBuilder provider;
+    private final boolean subPanel;
+    private ModularScreen screen;
+    private ModularPanel panel;
+    private boolean open = false;
+    private boolean queueDelete = false;
+
+    public SecondaryPanel(ModularPanel parent, IPanelBuilder provider, boolean subPanel) {
+        this.parent = parent;
+        this.provider = provider;
+        this.subPanel = subPanel;
+        parent.registerSubPanel(this);
+    }
+
+    @Override
+    public void closePanel() {
+        if (!this.open) return;
+        this.panel.closeIfOpen();
+    }
+
+    @Override
+    public void closeSubPanels() {
+        if (this.panel != null) {
+            this.panel.closeClientSubPanels();
+        }
+    }
+
+    @ApiStatus.Internal
+    @Override
+    public void closePanelInternal() {
+        this.open = false;
+        if (this.queueDelete) {
+            this.panel = null;
+            this.queueDelete = false;
+        }
+    }
+
+    @Override
+    public void deleteCachedPanel() {
+        if (this.open) {
+            this.queueDelete = true;
+        } else {
+            this.panel = null;
+        }
+    }
+
+    @Override
+    public boolean isSubPanel() {
+        return subPanel;
+    }
+
+    @Override
+    public boolean isPanelOpen() {
+        return this.open;
+    }
+
+    @Override
+    public void openPanel() {
+        if (this.open) return;
+        if (this.screen != this.parent.getScreen()) {
+            this.screen = this.parent.getScreen();
+        }
+        if (this.panel == null) {
+            this.panel = buildPanel();
+            if (this.panel == this.screen.getMainPanel()) {
+                throw new IllegalArgumentException("Must not return main panel!");
+            }
+            if (WidgetTree.hasSyncedValues(this.panel)) {
+                throw new IllegalArgumentException(
+                        "Panel has widgets with synced values, but the panel is not synced!");
+            }
+            this.panel.setPanelHandler(this);
+        }
+        this.screen.getPanelManager().openPanel(this.panel, this);
+        this.open = true;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private ModularPanel buildPanel() {
+        return Objects.requireNonNull(this.provider.build(this.screen.getMainPanel(), MCHelper.getPlayer()));
+    }
+
+    public interface IPanelBuilder {
+
+        ModularPanel build(ModularPanel parentPanel, Player player);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/UISettings.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/UISettings.java
new file mode 100644
index 00000000000..e6992ad3026
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/UISettings.java
@@ -0,0 +1,144 @@
+package com.gregtechceu.gtceu.client.mui.screen;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.RecipeViewerSettings;
+import com.gregtechceu.gtceu.api.mui.base.UIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.IntFunction;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public class UISettings {
+
+    public static final double DEFAULT_INTERACT_RANGE = 8.0;
+
+    private IntFunction<ModularContainerMenu> containerCreator;
+    @OnlyIn(Dist.CLIENT)
+    private GuiCreator guiSupplier;
+    private Predicate<Player> canInteractWith;
+    @Getter
+    private String theme;
+    @Getter
+    private final RecipeViewerSettings recipeViewerSettings;
+
+    public UISettings() {
+        this(new RecipeViewerSettingsImpl());
+    }
+
+    public UISettings(RecipeViewerSettings recipeViewerSettings) {
+        this.recipeViewerSettings = recipeViewerSettings;
+    }
+
+    /**
+     * A function for a custom {@link ModularContainerMenu} implementation. This overrides
+     * {@link UIFactory#createContainer(int)}.
+     *
+     * @param containerCreator container creator function. Must return a new instance.
+     */
+    public void customContainer(IntFunction<ModularContainerMenu> containerCreator) {
+        this.containerCreator = containerCreator;
+    }
+
+    /**
+     * A function for a custom {@link IMuiScreen} implementation. This overrides
+     * {@link UIFactory#createScreenWrapper(ModularContainerMenu, ModularScreen)} (ModularContainer, ModularScreen)}.
+     * Note that {@link IMuiScreen#getScreen()} has to be an
+     * instance of {@link AbstractContainerScreen } otherwise an exception is thrown, when the UI opens.
+     *
+     * @param guiSupplier a supplier for a gui creator function. It has to be a double function because it crashes on
+     *                    server otherwise.
+     */
+    public void customGui(Supplier<GuiCreator> guiSupplier) {
+        if (GTCEu.isClientThread()) {
+            this.guiSupplier = guiSupplier.get();
+        }
+    }
+
+    /**
+     * Overrides the default can interact check of {@link UIFactory#canInteractWith(Player, GuiData)}.
+     *
+     * @param canInteractWith function to test if a player can interact with the ui. This is called every tick while UI
+     *                        is open. Once this
+     *                        function returns false, the UI is immediately closed.
+     */
+    public void canInteractWith(Predicate<Player> canInteractWith) {
+        this.canInteractWith = canInteractWith;
+    }
+
+    @ApiStatus.Internal
+    public <D extends GuiData> void defaultCanInteractWith(UIFactory<D> factory, D guiData) {
+        canInteractWith(player -> factory.canInteractWith(player, guiData));
+    }
+
+    public void canInteractWithinRange(Vec3 pos, double range) {
+        canInteractWith(player -> player.distanceToSqr(pos) <= range * range);
+    }
+
+    public void canInteractWithinRange(BlockPos pos, double range) {
+        canInteractWithinRange(pos.getCenter(), range);
+    }
+
+    public void canInteractWithinRange(PosGuiData guiData, double range) {
+        canInteractWithinRange(guiData.getBlockPos(), range);
+    }
+
+    public void canInteractWithinDefaultRange(Vec3 pos) {
+        canInteractWithinRange(pos, DEFAULT_INTERACT_RANGE);
+    }
+
+    public void canInteractWithinDefaultRange(BlockPos pos) {
+        canInteractWithinRange(pos, DEFAULT_INTERACT_RANGE);
+    }
+
+    public void canInteractWithinDefaultRange(PosGuiData guiData) {
+        canInteractWithinRange(guiData, DEFAULT_INTERACT_RANGE);
+    }
+
+    public void useTheme(String theme) {
+        this.theme = theme;
+    }
+
+    @ApiStatus.Internal
+    public ModularContainerMenu createContainer(int containerId) {
+        return containerCreator.apply(containerId);
+    }
+
+    @ApiStatus.Internal
+    @SideOnly(Side.CLIENT)
+    public IMuiScreen createGui(ModularContainerMenu container, ModularScreen screen) {
+        return guiSupplier.create(container, screen);
+    }
+
+    public boolean hasCustomContainer() {
+        return containerCreator != null;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public boolean hasCustomGui() {
+        return guiSupplier != null;
+    }
+
+    public boolean canPlayerInteractWithUI(Player player) {
+        return canInteractWith == null || canInteractWith.test(player);
+    }
+
+    public interface GuiCreator {
+
+        IMuiScreen create(ModularContainerMenu container, ModularScreen screen);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/event/RichTooltipEvent.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/event/RichTooltipEvent.java
new file mode 100644
index 00000000000..13e4b7355c9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/event/RichTooltipEvent.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.client.mui.screen.event;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IRichTextBuilder;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipPositioner;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.client.event.RenderTooltipEvent;
+import net.minecraftforge.eventbus.api.Cancelable;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+@SuppressWarnings("UnstableApiUsage")
+public class RichTooltipEvent {
+
+    private RichTooltipEvent() {}
+
+    @Cancelable
+    public static class Pre extends RenderTooltipEvent.Pre {
+
+        @Getter
+        private final IRichTextBuilder<?> tooltip;
+
+        public Pre(@NotNull ItemStack stack, @NotNull GuiGraphics graphics,
+                   int x, int y, int screenWidth, int screenHeight, @NotNull Font font,
+                   @NotNull List<ClientTooltipComponent> components, @NotNull ClientTooltipPositioner positioner,
+                   IRichTextBuilder<?> tooltip) {
+            super(stack, graphics, x, y, screenWidth, screenHeight, font, components, positioner);
+            this.tooltip = tooltip;
+        }
+    }
+
+    public static class Color extends RenderTooltipEvent.Color {
+
+        @Getter
+        private final IRichTextBuilder<?> tooltip;
+
+        public Color(@NotNull ItemStack stack, @NotNull GuiGraphics graphics,
+                     int x, int y, @NotNull Font font, int background, int borderStart, int borderEnd,
+                     @NotNull List<ClientTooltipComponent> components, IRichTextBuilder<?> tooltip) {
+            super(stack, graphics, x, y, font, background, borderStart, borderEnd, components);
+            this.tooltip = tooltip;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/GuiContext.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/GuiContext.java
new file mode 100644
index 00000000000..683f17f7af2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/GuiContext.java
@@ -0,0 +1,206 @@
+package com.gregtechceu.gtceu.client.mui.screen.viewport;
+
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Stencil;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+
+/**
+ * A gui context contains various properties like screen size, mouse position, last clicked button etc.
+ * It also is a matrix/pose stack.
+ * A default instance can be obtained using {@link #getDefault()}, which can be used in {@link IDrawable IDrawables} for
+ * example.
+ * That instance is automatically updated at all times (except when no UI is currently open).
+ */
+public class GuiContext extends GuiViewportStack {
+
+    public static GuiContext getDefault() {
+        return ClientScreenHandler.getBestContext();
+    }
+
+    @Getter
+    private final Area screenArea = new Area();
+    @Getter
+    @Setter(onMethod_ = @ApiStatus.Internal)
+    private GuiGraphics graphics = null;
+    private @Nullable Font overrideFont = null;
+    @Getter
+    private final Stencil stencil = new Stencil(this);
+
+    /* Mouse states */
+    private int mouseX;
+    private int mouseY;
+    @Getter
+    private int mouseButton;
+    @Getter
+    private double mouseScrollDelta;
+
+    /* Keyboard states */
+    @Getter
+    private int keyCode;
+    @Getter
+    private int scanCode;
+    @Getter
+    private int modifiers;
+    @Getter
+    private int codePoint;
+
+    /* Render states */
+    @Getter
+    private float partialTicks;
+    @Getter
+    private long tick = 0;
+    @Getter
+    private int currentDrawingZ = 0;
+
+    public boolean isAbove(IWidget widget) {
+        return isMouseAbove(widget.getArea());
+    }
+
+    /**
+     * @return true the mouse is anywhere above the widget
+     */
+    public boolean isMouseAbove(IWidget widget) {
+        return isMouseAbove(widget.getArea());
+    }
+
+    /**
+     * @return true the mouse is anywhere above the area
+     */
+    public boolean isMouseAbove(Area area) {
+        return area.isInside(this.mouseX, this.mouseY);
+    }
+
+    @ApiStatus.Internal
+    public void updateState(int mouseX, int mouseY, float partialTicks) {
+        this.mouseX = mouseX;
+        this.mouseY = mouseY;
+        this.partialTicks = partialTicks;
+    }
+
+    @ApiStatus.Internal
+    public void updateMouseButton(int button) {
+        this.mouseButton = button;
+    }
+
+    @ApiStatus.Internal
+    public void updateMouseWheel(double scrollDelta) {
+        this.mouseScrollDelta = scrollDelta;
+    }
+
+    @ApiStatus.Internal
+    public void updateLatestKey(int keyCode, int scanCode, int modifiers) {
+        this.keyCode = keyCode;
+        this.scanCode = scanCode;
+        this.modifiers = modifiers;
+    }
+
+    @ApiStatus.Internal
+    public void updateLatestTypedChar(int codePoint, int modifiers) {
+        this.codePoint = codePoint;
+        this.modifiers = modifiers;
+    }
+
+    @ApiStatus.Internal
+    public void updateScreenArea(int w, int h) {
+        this.screenArea.set(0, 0, w, h);
+        this.screenArea.rx = 0;
+        this.screenArea.ry = 0;
+    }
+
+    public void updateZ(int z) {
+        this.currentDrawingZ = z;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public Minecraft getMC() {
+        return Minecraft.getInstance();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public Font getFont() {
+        if (overrideFont != null) {
+            return overrideFont;
+        } else {
+            return MCHelper.getFont();
+        }
+    }
+
+    @ApiStatus.Internal
+    @OnlyIn(Dist.CLIENT)
+    public void setOverrideFont(@Nullable Font overrideFont) {
+        this.overrideFont = overrideFont;
+    }
+
+    public void tick() {
+        this.tick += 1;
+    }
+
+    /* Viewport */
+
+    public Matrix4f getLastGraphicsPose() {
+        if (graphics == null) return new Matrix4f();
+        return graphics.pose().last().pose();
+    }
+
+    public PoseStack graphicsPose() {
+        if (graphics == null) return new PoseStack();
+        return graphics.pose();
+    }
+
+    public int getMouseX() {
+        return unTransformX(this.mouseX, this.mouseY);
+    }
+
+    public int getMouseY() {
+        return unTransformY(this.mouseX, this.mouseY);
+    }
+
+    /**
+     * Get absolute X coordinate of the mouse without the
+     * scrolling areas applied
+     */
+    public int getAbsMouseX() {
+        return this.mouseX;
+    }
+
+    /**
+     * Get absolute Y coordinate of the mouse without the
+     * scrolling areas applied
+     */
+    public int getAbsMouseY() {
+        return this.mouseY;
+    }
+
+    public int getMouse(GuiAxis axis) {
+        return axis.isHorizontal() ? getMouseX() : getMouseY();
+    }
+
+    public int getAbsMouse(GuiAxis axis) {
+        return axis.isHorizontal() ? getAbsMouseX() : getAbsMouseY();
+    }
+
+    public boolean isMuiContext() {
+        return false;
+    }
+
+    public ModularGuiContext getMuiContext() {
+        throw new UnsupportedOperationException("This is not a MuiContext");
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/GuiViewportStack.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/GuiViewportStack.java
new file mode 100644
index 00000000000..379212238a2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/GuiViewportStack.java
@@ -0,0 +1,274 @@
+package com.gregtechceu.gtceu.client.mui.screen.viewport;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewportStack;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class is a matrix stack aka pose stack. It keeps track of widget transformations (including position)
+ * and can apply these transformations to OpenGL for rendering.
+ * This is mainly used, but not limited to, properly displacing widgets in a scroll area.
+ */
+public class GuiViewportStack implements IViewportStack {
+
+    private static final Vector3f sharedVec = new Vector3f();
+
+    private final ObjectArrayList<TransformationMatrix> matrixPool = new ObjectArrayList<>();
+    private final ObjectArrayList<TransformationMatrix> viewportStack = new ObjectArrayList<>();
+    private final List<Area> viewportAreas = new ArrayList<>();
+    private TransformationMatrix top;
+    private TransformationMatrix topViewport;
+
+    @Override
+    public void reset() {
+        this.viewportStack.clear();
+        this.top = null;
+        this.topViewport = null;
+    }
+
+    @Override
+    public Area getViewport() {
+        return this.topViewport.getArea();
+    }
+
+    @Override
+    public void pushViewport(IViewport viewport, Area area) {
+        Matrix4f parent = this.top == null ? null : this.top.getMatrix();
+        Area child = getCurrentViewportArea();
+        child.set(area);
+        if (this.topViewport != null) {
+            if (!this.topViewport.isViewportMatrix()) {
+                throw new IllegalStateException(this.topViewport.toString());
+            }
+            if (this.topViewport.getArea() == null) {
+                throw new NullPointerException(this.topViewport.toString());
+            }
+            this.topViewport.getArea().clamp(child);
+        }
+        this.viewportStack.push(newMatrix().construct(viewport, child, parent));
+        updateViewport(false);
+        this.topViewport = this.viewportStack.top();
+    }
+
+    @Override
+    public void pushMatrix() {
+        this.viewportStack.push(newMatrix().construct(this.top == null ? null : this.top.getMatrix()));
+        updateViewport(false);
+    }
+
+    private TransformationMatrix newMatrix() {
+        return !this.matrixPool.isEmpty() ? this.matrixPool.pop() : new TransformationMatrix();
+    }
+
+    private void pop() {
+        TransformationMatrix matrix = this.viewportStack.pop();
+        matrix.dispose();
+        if (this.matrixPool.size() < 256) {
+            this.matrixPool.add(matrix);
+        }
+    }
+
+    private Area getCurrentViewportArea() {
+        while (this.viewportAreas.size() < this.viewportStack.size() + 1) {
+            this.viewportAreas.add(new Area());
+        }
+        return this.viewportAreas.get(this.viewportStack.size());
+    }
+
+    @Override
+    public void popViewport(IViewport viewport) {
+        if (this.top == null || !this.top.isViewportMatrix() || this.top.getViewport() != viewport) {
+            String name;
+            if (this.top == null) {
+                name = "none";
+            } else {
+                name = this.top.isViewportMatrix() ? asString(this.top.getViewport()) : "not a viewport";
+            }
+            throw new IllegalStateException(
+                    "Viewports must be popped in reverse order they were pushed. Tried to pop '" + viewport +
+                            "', but last pushed is '" + name + "'.");
+        }
+        this.viewportStack.pop();
+        updateViewport(true);
+    }
+
+    private static String asString(IViewport viewport) {
+        return viewport == null ? "screen viewport" : viewport.toString();
+    }
+
+    @Override
+    public void popMatrix() {
+        if (this.top.isViewportMatrix()) {
+            throw new IllegalStateException("Tried to pop viewport matrix, but at the top is a normal matrix.");
+        }
+        pop();
+        updateViewport(false);
+    }
+
+    public void push(TransformationMatrix transformationMatrix) {
+        this.viewportStack.push(newMatrix().construct(transformationMatrix,
+                this.top == null ? null : this.top.getMatrix()));
+        updateViewport(false);
+        if (this.top.isViewportMatrix()) {
+            this.topViewport = this.top;
+        }
+    }
+
+    public void pop(TransformationMatrix transformationMatrix) {
+        if (this.top.getWrapped() != transformationMatrix) {
+            throw new IllegalArgumentException();
+        }
+        boolean isViewport = this.top.isViewportMatrix();
+        pop();
+        updateViewport(isViewport);
+    }
+
+    @Override
+    public int getStackSize() {
+        return this.viewportStack.size();
+    }
+
+    @Override
+    public void popUntilIndex(int index) {
+        for (int i = this.viewportStack.size() - 1; i > index; i--) {
+            pop();
+        }
+        updateViewport(true);
+    }
+
+    @Override
+    public void popUntilViewport(IViewport viewport) {
+        int i = this.viewportStack.size();
+        while (--i >= 0 && this.viewportStack.top().getViewport() != viewport) {
+            pop();
+        }
+        updateViewport(true);
+    }
+
+    @Override
+    public void translate(float x, float y) {
+        checkViewport();
+        this.top.getMatrix().translate(vec(x, y, 0));
+        this.top.markDirty();
+    }
+
+    @Override
+    public void translate(float x, float y, float z) {
+        checkViewport();
+        this.top.getMatrix().translate(x, y, z);
+        this.top.markDirty();
+    }
+
+    @Override
+    public void rotate(float angle, float x, float y, float z) {
+        checkViewport();
+        this.top.getMatrix().rotate(angle, vec(x, y, z));
+        this.top.markDirty();
+    }
+
+    @Override
+    public void rotateZ(float angle) {
+        rotate(angle, 0f, 0f, 1f);
+    }
+
+    @Override
+    public void scale(float x, float y) {
+        checkViewport();
+        this.top.getMatrix().scale(vec(x, y, 1f));
+        this.top.markDirty();
+    }
+
+    @Override
+    public void multiply(Matrix4f matrix) {
+        checkViewport();
+        this.top.getMatrix().mul(matrix);
+        this.top.markDirty();
+    }
+
+    @Override
+    public void resetCurrent() {
+        checkViewport();
+        if (this.viewportStack.size() > 1) {
+            this.top.getMatrix().set(this.viewportStack.get(this.viewportStack.size() - 2).getMatrix());
+        } else {
+            this.top.getMatrix().identity();
+        }
+        this.top.markDirty();
+    }
+
+    private void checkViewport() {
+        if (this.top == null) {
+            throw new IllegalStateException("Tried to transform viewport, but there is no viewport!");
+        }
+    }
+
+    private void updateViewport(boolean findTopViewport) {
+        this.top = this.viewportStack.isEmpty() ? null : this.viewportStack.top();
+        if (!findTopViewport) return;
+        // find new top viewport
+        this.topViewport = null;
+        if (this.viewportStack.isEmpty()) return;
+        for (int i = this.viewportStack.size() - 1; i >= 0; i--) {
+            TransformationMatrix matrix = this.viewportStack.get(i);
+            if (matrix.isViewportMatrix()) {
+                this.topViewport = matrix;
+            }
+        }
+    }
+
+    @Override
+    public int transformX(float x, float y) {
+        return this.top == null ? (int) x : this.top.transformX(x, y);
+    }
+
+    @Override
+    public int transformY(float x, float y) {
+        return this.top == null ? (int) y : this.top.transformY(x, y);
+    }
+
+    @Override
+    public int unTransformX(float x, float y) {
+        return this.top == null ? (int) x : this.top.unTransformX(x, y);
+    }
+
+    @Override
+    public int unTransformY(float x, float y) {
+        return this.top == null ? (int) y : this.top.unTransformY(x, y);
+    }
+
+    @Override
+    public Vector3f transform(Vector3f vec, Vector3f dest) {
+        return this.top == null ? dest.set(vec) : this.top.transform(vec, dest);
+    }
+
+    @Override
+    public Vector3f unTransform(Vector3f vec, Vector3f dest) {
+        return this.top == null ? dest.set(vec) : this.top.unTransform(vec, dest);
+    }
+
+    @Override
+    public void applyTo(PoseStack poseStack) {
+        if (this.top == null) return;
+        poseStack.mulPoseMatrix(this.top.getMatrix());
+    }
+
+    @Nullable
+    @Override
+    public TransformationMatrix peek() {
+        return this.top;
+    }
+
+    private static Vector3f vec(float x, float y, float z) {
+        sharedVec.set(x, y, z);
+        return sharedVec;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/LocatedElement.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/LocatedElement.java
new file mode 100644
index 00000000000..5f3f669f920
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/LocatedElement.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.client.mui.screen.viewport;
+
+import it.unimi.dsi.fastutil.Hash;
+import lombok.Getter;
+
+import java.util.Objects;
+
+public class LocatedElement<T> {
+
+    @Getter
+    private final T element;
+    @Getter
+    private final TransformationMatrix transformationMatrix;
+
+    public LocatedElement(T element, TransformationMatrix transformationMatrix) {
+        this.element = element;
+        this.transformationMatrix = new TransformationMatrix(transformationMatrix, null);
+    }
+
+    public void applyMatrix(GuiContext context) {
+        context.push(this.transformationMatrix);
+    }
+
+    public void unapplyMatrix(GuiContext context) {
+        context.pop(this.transformationMatrix);
+    }
+
+    @Override
+    public String toString() {
+        return "LocatedElement[" + getElement() + "]";
+    }
+
+    public LocatedElementHashStrategy<T> createHashStrategy() {
+        return new LocatedElementHashStrategy<>();
+    }
+
+    public static class LocatedElementHashStrategy<T> implements Hash.Strategy<LocatedElement<T>> {
+
+        @Override
+        public int hashCode(LocatedElement<T> o) {
+            return Objects.hashCode(o == null ? null : o.element);
+        }
+
+        @Override
+        public boolean equals(LocatedElement<T> a, LocatedElement<T> b) {
+            if (a == b) return true;
+            if (a == null || b == null) return false;
+            return Objects.equals(a.element, b.element);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/LocatedWidget.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/LocatedWidget.java
new file mode 100644
index 00000000000..cc3d8633db6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/LocatedWidget.java
@@ -0,0 +1,77 @@
+package com.gregtechceu.gtceu.client.mui.screen.viewport;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+
+import it.unimi.dsi.fastutil.Hash;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class LocatedWidget extends LocatedElement<IWidget> {
+
+    public static final Hash.Strategy<LocatedWidget> HASH_STRATEGY = new HashStrategy();
+
+    private static final GuiViewportStack STACK = new GuiViewportStack();
+
+    public static LocatedWidget of(IWidget widget) {
+        if (widget == null) {
+            return EMPTY;
+        }
+        // first make a list of all parents
+        IWidget parent = widget;
+        List<IWidget> ancestors = new ArrayList<>();
+        while (true) {
+            ancestors.add(0, parent);
+            if (parent instanceof ModularPanel) {
+                break;
+            }
+            parent = parent.getParent();
+        }
+        // iterate through each parent starting at the root and apply each transformation
+        STACK.reset();
+        for (IWidget widget1 : ancestors) {
+            if (widget1 instanceof IViewport viewport) {
+                STACK.pushViewport(viewport, widget1.getArea());
+                widget1.transform(STACK);
+                viewport.transformChildren(STACK);
+            } else {
+                STACK.pushMatrix();
+                widget1.transform(STACK);
+            }
+        }
+        return new LocatedWidget(widget, STACK.peek(), null);
+    }
+
+    public static final LocatedWidget EMPTY = new LocatedWidget(null, TransformationMatrix.EMPTY, null);
+    @Getter
+    private final Object additionalHoverInfo;
+
+    public LocatedWidget(IWidget element, TransformationMatrix transformationMatrix, Object additionalHoverInfo) {
+        super(element, transformationMatrix);
+        this.additionalHoverInfo = additionalHoverInfo;
+    }
+
+    @Override
+    public String toString() {
+        return "LocatedWidget[" + getElement() + " | " + additionalHoverInfo + "]";
+    }
+
+    public static class HashStrategy implements Hash.Strategy<LocatedWidget> {
+
+        @Override
+        public int hashCode(LocatedWidget o) {
+            return Objects.hashCode(o == null ? null : o.getElement());
+        }
+
+        @Override
+        public boolean equals(LocatedWidget a, LocatedWidget b) {
+            if (a == b) return true;
+            if (a == null || b == null) return false;
+            return Objects.equals(a.getElement(), b.getElement());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/ModularGuiContext.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/ModularGuiContext.java
new file mode 100644
index 00000000000..ae66652ffe6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/ModularGuiContext.java
@@ -0,0 +1,472 @@
+package com.gregtechceu.gtceu.client.mui.screen.viewport;
+
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.widget.*;
+import com.gregtechceu.gtceu.client.mui.CursorHandler;
+import com.gregtechceu.gtceu.client.mui.screen.*;
+
+import net.minecraft.Util;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.Slot;
+
+import com.google.common.collect.AbstractIterator;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+/**
+ * This class contains all the info from {@link GuiContext} and additional MUI specific info like the current
+ * {@link ModularScreen},
+ * current hovered widget, current dragged widget, current focused widget and recipe viewer settings.
+ * An instance can only be obtained from {@link ModularScreen#getContext()}. One instance is created every time a
+ * {@link ModularScreen}
+ * is created.
+ */
+public class ModularGuiContext extends GuiContext {
+
+    /* GUI elements */
+    @Getter
+    private final ModularScreen screen;
+    @Getter
+    @Setter
+    private @Nullable Screen parent;
+    @Getter
+    private LocatedWidget focusedWidget = LocatedWidget.EMPTY;
+    private List<LocatedWidget> belowMouse = Collections.emptyList();
+    /**
+     * the hovered widget (widget directly below the mouse)
+     */
+    private List<LocatedWidget> hovered = Collections.emptyList();
+    private LocatedWidget resizeable = null;
+    private final HoveredIterable hoveredWidgets;
+
+    private LocatedElement<IDraggable> draggable;
+    private int dragStartX = 0, dragStartY = 0;
+    private int lastButton = -1;
+    private long lastClickTime = 0;
+    private int lastDragX, lastDragY;
+
+    public List<Consumer<ModularGuiContext>> postRenderCallbacks = new ArrayList<>();
+
+    private UISettings settings;
+
+    private final Iterable<IWidget> hoveredIterable = () -> new AbstractIterator<>() {
+
+        private final List<LocatedWidget> currentHovered = ModularGuiContext.this.hovered;
+        private final Iterator<LocatedWidget> it = currentHovered.iterator();
+
+        @Override
+        protected @Nullable IWidget computeNext() {
+            if (ModularGuiContext.this.hovered != this.currentHovered) {
+                throw new ConcurrentModificationException("Tried to use hovered iterable over multiple ticks," +
+                        "where hovered list changed. This is not allowed.");
+            }
+            return this.it.hasNext() ? this.it.next().getElement() : computeNext();
+        }
+    };
+
+    public ModularGuiContext(ModularScreen screen) {
+        this.screen = screen;
+        this.hoveredWidgets = new HoveredIterable();
+    }
+
+    /**
+     * @return true if any widget is being hovered
+     */
+    public boolean isHovered() {
+        return !this.hovered.isEmpty();
+    }
+
+    public @Nullable IWidget getTopHovered() {
+        return this.hovered.isEmpty() ? null : this.hovered.get(0).getElement();
+    }
+
+    @UnmodifiableView
+    public Iterable<IWidget> getAllHovered() {
+        return this.hoveredIterable;
+    }
+
+    /**
+     * @return all widgets which are below the mouse ({@link GuiContext#isAbove(IWidget)} is true)
+     */
+    public Iterable<IWidget> getAllBelowMouse() {
+        return this.hoveredWidgets;
+    }
+
+    /**
+     * @return true if there is any focused widget
+     */
+    public boolean isFocused() {
+        return this.focusedWidget.getElement() != null;
+    }
+
+    /* Element focusing */
+
+    /**
+     * @return true if there is any focused widget
+     */
+    public boolean isFocused(IFocusedWidget widget) {
+        return this.focusedWidget.getElement() == widget;
+    }
+
+    /**
+     * Tries to focus the given widget
+     *
+     * @param widget widget to focus
+     */
+    public void focus(IFocusedWidget widget) {
+        focus(LocatedWidget.of((IWidget) widget));
+    }
+
+    /**
+     * Tries to focus the given widget
+     *
+     * @param widget widget to focus
+     */
+    public void focus(@NotNull LocatedWidget widget) {
+        if (this.focusedWidget.getElement() == widget.getElement()) {
+            return;
+        }
+
+        if (widget.getElement() != null && !(widget.getElement() instanceof IFocusedWidget)) {
+            throw new IllegalArgumentException();
+        }
+
+        if (this.focusedWidget.getElement() != null) {
+            IFocusedWidget focusedWidget = (IFocusedWidget) this.focusedWidget.getElement();
+            focusedWidget.onRemoveFocus(this);
+            this.screen.setFocused(false);
+        }
+
+        this.focusedWidget = widget;
+
+        if (this.focusedWidget.getElement() != null) {
+            IFocusedWidget focusedWidget = (IFocusedWidget) this.focusedWidget.getElement();
+            focusedWidget.onFocus(this);
+            this.screen.setFocused(true);
+        }
+    }
+
+    /**
+     * Removes focus from any widget
+     */
+    public void removeFocus() {
+        focus(LocatedWidget.EMPTY);
+    }
+
+    /**
+     * Tries to find the next focusable widget.
+     *
+     * @param parent focusable context
+     * @return true if successful
+     */
+    public boolean focusNext(IWidget parent) {
+        return focus(parent, -1, 1);
+    }
+
+    /**
+     * Tries to find the previous focusable widget.
+     *
+     * @param parent focusable context
+     * @return true if successful
+     */
+    public boolean focusPrevious(IWidget parent) {
+        return focus(parent, -1, -1);
+    }
+
+    public boolean focus(IWidget parent, int index, int factor) {
+        return focus(parent, index, factor, false);
+    }
+
+    /**
+     * Focus next focusable GUI element
+     */
+    public boolean focus(IWidget widget, int index, int factor, boolean stop) {
+        List<IWidget> children = widget.getChildren();
+
+        factor = factor >= 0 ? 1 : -1;
+        index += factor;
+
+        for (; index >= 0 && index < children.size(); index += factor) {
+            IWidget child = children.get(index);
+
+            if (!child.isEnabled()) {
+                continue;
+            }
+
+            if (child instanceof IFocusedWidget focusedWidget1) {
+                focus(focusedWidget1);
+
+                return true;
+            } else {
+                int start = factor > 0 ? -1 : child.getChildren().size();
+
+                if (focus(child, start, factor, true)) {
+                    return true;
+                }
+            }
+        }
+
+        IWidget grandparent = widget.getParent();
+        boolean isRoot = grandparent instanceof ModularPanel;
+
+        if (!stop && (isRoot || grandparent.canBeSeen(this))) {
+            List<IWidget> siblings = grandparent.getChildren();
+            if (focus(grandparent, siblings.indexOf(widget), factor)) {
+                return true;
+            }
+            if (isRoot) {
+                return focus(grandparent, factor > 0 ? -1 : siblings.size() - 1, factor);
+            }
+        }
+
+        return false;
+    }
+
+    /* draggable */
+
+    public boolean hasDraggable() {
+        return this.draggable != null;
+    }
+
+    public boolean isMouseItemEmpty() {
+        Player player = MCHelper.getPlayer();
+        return player == null || player.containerMenu.getCarried().isEmpty();
+    }
+
+    @ApiStatus.Internal
+    public boolean onMousePressed(double mouseX, double mouseY, int button) {
+        if ((button == 0 || button == 1) && isMouseItemEmpty() && hasDraggable()) {
+            dropDraggable(true);
+            return true;
+        }
+        return false;
+    }
+
+    @ApiStatus.Internal
+    public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+        if (button == this.lastButton && isMouseItemEmpty() && hasDraggable()) {
+            long time = Util.getMillis();
+            dropDraggable((this.dragStartX == getAbsMouseX() && this.dragStartY == getAbsMouseY()) ||
+                    (time - this.lastClickTime) < 100);
+            return true;
+        }
+        return false;
+    }
+
+    @ApiStatus.Internal
+    public void dropDraggable(boolean shouldCancel) {
+        this.draggable.applyMatrix(this);
+        this.draggable.getElement()
+                .onDragEnd(!shouldCancel &&
+                        this.draggable.getElement().canDropHere(getAbsMouseX(), getAbsMouseY(), getTopHovered()));
+        // TODO: getTopHovered correct here?
+        this.draggable.getElement().setMoving(false);
+        this.draggable.unapplyMatrix(this);
+        this.draggable = null;
+        this.lastButton = -1;
+        this.lastClickTime = 0;
+    }
+
+    @ApiStatus.Internal
+    public boolean onHoveredClick(int button, LocatedWidget hovered) {
+        if ((button == 0 || button == 1) && isMouseItemEmpty() && !hasDraggable()) {
+            IWidget widget = hovered.getElement();
+            LocatedElement<IDraggable> draggable;
+            if (widget instanceof IDraggable iDraggable) {
+                draggable = new LocatedElement<>(iDraggable, hovered.getTransformationMatrix());
+            } else if (widget instanceof ModularPanel panel) {
+                if (panel.isDraggable()) {
+                    if (!panel.resizer().hasFixedSize()) {
+                        throw new IllegalStateException(
+                                "Panel must have a fixed size. It can't specify left AND right or top AND bottom!");
+                    }
+                    draggable = new LocatedElement<>(new DraggablePanelWrapper(panel), TransformationMatrix.EMPTY);
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+            if (draggable.getElement().onDragStart(button)) {
+                draggable.getElement().setMoving(true);
+                this.draggable = draggable;
+                this.dragStartX = getAbsMouseX();
+                this.dragStartY = getAbsMouseY();
+                this.lastButton = button;
+                this.lastClickTime = Util.getMillis();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @ApiStatus.Internal
+    public void drawDraggable(GuiGraphics graphics) {
+        if (hasDraggable()) {
+            this.draggable.applyMatrix(this);
+            this.draggable.getElement().drawMovingState(graphics, this, getPartialTicks());
+            this.draggable.unapplyMatrix(this);
+        }
+    }
+
+    private static boolean isStillHovered(List<LocatedWidget> newHovered, LocatedWidget lw) {
+        if (newHovered == null) return false;
+        for (LocatedWidget hovered : newHovered) {
+            if (hovered.getElement() == lw.getElement()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @ApiStatus.Internal
+    public void onFrameUpdate() {
+        if (hasDraggable() && (this.lastDragX != getAbsMouseX() || this.lastDragY != getAbsMouseY())) {
+            this.lastDragX = getAbsMouseX();
+            this.lastDragY = getAbsMouseY();
+            this.draggable.applyMatrix(this);
+            this.draggable.getElement().onDrag(this.lastButton, this.lastClickTime);
+            this.draggable.unapplyMatrix(this);
+        }
+        List<LocatedWidget> newBelowMouse = this.screen.getPanelManager().getAllHoveredWidgetsList(false);
+        if (!newBelowMouse.isEmpty()) {
+            List<LocatedWidget> oldBelowMouse = this.belowMouse;
+            this.belowMouse = newBelowMouse;
+            for (LocatedWidget lw : this.belowMouse) {
+                if (lw.getElement().isValid() && !lw.getElement().isBelowMouse()) {
+                    lw.getElement().onMouseEnterArea();
+                }
+            }
+
+            List<LocatedWidget> newHovered = getHoveredWidgets(newBelowMouse);
+            List<LocatedWidget> oldHovered = this.hovered;
+            this.hovered = newHovered;
+
+            checkHoverEnd(newHovered, oldHovered, IWidget::onMouseEndHover);
+            checkHoverEnd(newBelowMouse, oldBelowMouse, IWidget::onMouseLeaveArea);
+        } else {
+            checkHoverEnd(null, this.hovered, IWidget::onMouseEndHover);
+            checkHoverEnd(null, this.belowMouse, IWidget::onMouseLeaveArea);
+            this.hovered = Collections.emptyList();
+            this.belowMouse = Collections.emptyList();
+            this.resizeable = null;
+            CursorHandler.resetCursorIcon();
+        }
+    }
+
+    private List<LocatedWidget> getHoveredWidgets(List<LocatedWidget> belowMouse) {
+        Slot slot = null;
+        LocatedWidget resizeable = null;
+        ResizeDragArea newResizeDragArea = null;
+        List<LocatedWidget> newHovered = new ArrayList<>();
+        for (LocatedWidget lw : belowMouse) {
+            if (!lw.getElement().isValid()) continue;
+            if (lw.getElement().canHover()) {
+                newHovered.add(lw);
+                if (!lw.getElement().isHovering()) {
+                    lw.getElement().onMouseStartHover();
+                }
+                if (slot == null && lw.getElement() instanceof IVanillaSlot vanillaSlot &&
+                        vanillaSlot.handleAsVanillaSlot()) {
+                    slot = vanillaSlot.getVanillaSlot();
+                }
+                if (lw.getAdditionalHoverInfo() instanceof ResizeDragArea resizeDragArea) {
+                    resizeable = lw;
+                    newResizeDragArea = resizeDragArea;
+                }
+                if (!lw.getElement().canHoverThrough()) break;
+            }
+        }
+        ResizeDragArea oldResizeDragArea = this.resizeable != null ?
+                (ResizeDragArea) this.resizeable.getAdditionalHoverInfo() : null;
+        if (newResizeDragArea != oldResizeDragArea) {
+            CursorHandler.setCursorResizeIcon(newResizeDragArea);
+            this.resizeable = resizeable;
+        }
+        this.screen.getScreenWrapper().setHoveredSlot(slot);
+        return newHovered.isEmpty() ? Collections.emptyList() : newHovered;
+    }
+
+    private void checkHoverEnd(List<LocatedWidget> newList, List<LocatedWidget> oldList, Consumer<IWidget> onHoverEnd) {
+        if (!oldList.isEmpty()) {
+            for (LocatedWidget lw : oldList) {
+                if (!isStillHovered(newList, lw)) {
+                    onHoverEnd.accept(lw.getElement());
+                }
+            }
+        }
+    }
+
+    public ITheme getTheme() {
+        return this.screen.getCurrentTheme();
+    }
+
+    @Override
+    public boolean isMuiContext() {
+        return true;
+    }
+
+    @Override
+    public ModularGuiContext getMuiContext() {
+        return this;
+    }
+
+    public UISettings getUISettings() {
+        if (this.settings == null) {
+            throw new IllegalStateException("The screen is not yet initialised!");
+        }
+        return this.settings;
+    }
+
+    public RecipeViewerSettingsImpl getRecipeViewerSettings() {
+        if (this.screen.isOverlay()) {
+            throw new IllegalStateException("Overlays don't have JEI settings!");
+        }
+        return (RecipeViewerSettingsImpl) getUISettings().getRecipeViewerSettings();
+    }
+
+    @ApiStatus.Internal
+    public void setSettings(UISettings settings) {
+        if (this.settings != null) {
+            throw new IllegalStateException("Tried to set settings twice");
+        }
+        this.settings = settings;
+        if (this.settings.getTheme() != null) {
+            this.screen.useTheme(this.settings.getTheme());
+        }
+    }
+
+    public boolean hasSettings() {
+        return this.settings != null;
+    }
+
+    private class HoveredIterable implements Iterable<IWidget> {
+
+        @NotNull
+        @Override
+        public Iterator<IWidget> iterator() {
+            return new AbstractIterator<>() {
+
+                private final Iterator<ModularPanel> panelIt = ModularGuiContext.this.getScreen()
+                        .getPanelManager().getOpenPanels().iterator();
+                private Iterator<LocatedWidget> widgetIt;
+
+                @Override
+                protected IWidget computeNext() {
+                    while (widgetIt == null || !widgetIt.hasNext()) {
+                        if (!panelIt.hasNext()) return endOfData();
+                        widgetIt = panelIt.next().getHovering().iterator();
+                    }
+                    return widgetIt.next().getElement();
+                }
+            };
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/TransformationMatrix.java b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/TransformationMatrix.java
new file mode 100644
index 00000000000..625dbcd6540
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/mui/screen/viewport/TransformationMatrix.java
@@ -0,0 +1,146 @@
+package com.gregtechceu.gtceu.client.mui.screen.viewport;
+
+import com.gregtechceu.gtceu.api.mui.base.layout.IViewport;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+/**
+ * A single matrix in a matrix stack. Also has some other information.
+ */
+@ApiStatus.Internal
+public class TransformationMatrix {
+
+    public static final TransformationMatrix EMPTY = new TransformationMatrix(null);
+
+    @Getter
+    private TransformationMatrix wrapped;
+    @Getter
+    private IViewport viewport;
+    @Getter
+    private Area area;
+    @Getter
+    private final Matrix4f matrix = new Matrix4f();
+    private final Matrix4f invertedMatrix = new Matrix4f();
+    private boolean inUse = false;
+
+    @Getter
+    private boolean viewportMatrix;
+    @Getter
+    private boolean dirty = true;
+
+    public TransformationMatrix() {}
+
+    public TransformationMatrix(@Nullable Matrix4f parent) {
+        construct(parent);
+    }
+
+    public TransformationMatrix(TransformationMatrix parent, @Nullable Matrix4f parentMatrix) {
+        construct(parent, parentMatrix);
+    }
+
+    TransformationMatrix construct(TransformationMatrix parent, @Nullable Matrix4f parentMatrix) {
+        checkInUse();
+        this.wrapped = parent;
+        this.viewport = parent.viewport;
+        this.area = parent.area;
+        if (parentMatrix == null) {
+            this.matrix.set(parent.getMatrix());
+        } else {
+            parentMatrix.mul(parent.getMatrix(), this.matrix);
+        }
+        this.viewportMatrix = parent.viewportMatrix;
+        return this;
+    }
+
+    TransformationMatrix construct(@Nullable Matrix4f parent) {
+        return construct(null, null, parent, false);
+    }
+
+    TransformationMatrix construct(IViewport viewport, Area area, @Nullable Matrix4f parent) {
+        return construct(viewport, area, parent, true);
+    }
+
+    private TransformationMatrix construct(IViewport viewport, Area area, @Nullable Matrix4f parent,
+                                           boolean isViewport) {
+        checkInUse();
+        this.wrapped = null;
+        this.viewport = viewport;
+        this.area = area;
+        this.viewportMatrix = isViewport;
+        if (parent != null) {
+            this.matrix.set(parent);
+        } else {
+            this.matrix.identity();
+        }
+        return this;
+    }
+
+    void dispose() {
+        this.wrapped = null;
+        this.viewport = null;
+        this.area = null;
+        this.inUse = false;
+        this.viewportMatrix = false;
+    }
+
+    private void checkInUse() {
+        if (this.inUse) {
+            throw new IllegalStateException("Transformation matrix is already in use!");
+        }
+        this.inUse = true;
+        this.dirty = true;
+    }
+
+    public Matrix4f getInvertedMatrix() {
+        if (this.dirty) {
+            this.matrix.invert(this.invertedMatrix);
+            this.dirty = false;
+        }
+        return this.invertedMatrix;
+    }
+
+    public void markDirty() {
+        this.dirty = true;
+    }
+
+    public int transformX(float x, float y) {
+        Matrix4f m = getMatrix();
+        return (int) (x * m.m00() + y * m.m10() + m.m30());
+    }
+
+    public int transformY(float x, float y) {
+        Matrix4f m = getMatrix();
+        return (int) (x * m.m01() + y * m.m11() + m.m31());
+    }
+
+    public int unTransformX(float x, float y) {
+        Matrix4f m = getInvertedMatrix();
+        return (int) (x * m.m00() + y * m.m10() + m.m30());
+    }
+
+    public int unTransformY(float x, float y) {
+        Matrix4f m = getInvertedMatrix();
+        return (int) (x * m.m01() + y * m.m11() + m.m31());
+    }
+
+    public Vector3f transform(Vector3f vec, Vector3f dest) {
+        return transform(getMatrix(), vec, dest);
+    }
+
+    public Vector3f unTransform(Vector3f vec, Vector3f dest) {
+        return transform(getInvertedMatrix(), vec, dest);
+    }
+
+    public static Vector3f transform(Matrix4f m, Vector3f vec, Vector3f dest) {
+        float x = m.m00() * vec.x + m.m10() * vec.y + m.m20() * vec.z + m.m30();
+        float y = m.m01() * vec.x + m.m11() * vec.y + m.m21() * vec.z + m.m31();
+        float z = m.m02() * vec.x + m.m12() * vec.y + m.m22() * vec.z + m.m32();
+        dest.set(x, y, z);
+        return dest;
+    }
+}
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 f8c933d7d65..f80e60a5f34 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/BlockHighlightRenderer.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/BlockHighlightRenderer.java
@@ -3,19 +3,18 @@
 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;
 import com.gregtechceu.gtceu.api.item.tool.ToolHelper;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.pipenet.IPipeType;
 import com.gregtechceu.gtceu.client.util.PoseStackExtensions;
 import com.gregtechceu.gtceu.client.util.RenderUtil;
-import com.gregtechceu.gtceu.common.item.CoverPlaceBehavior;
+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;
@@ -37,6 +36,7 @@
 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/block/LampItemRenderer.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/block/LampItemRenderer.java
index 853f9a3e361..268af12e43c 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/block/LampItemRenderer.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/block/LampItemRenderer.java
@@ -1,6 +1,6 @@
 package com.gregtechceu.gtceu.client.renderer.block;
 
-import com.gregtechceu.gtceu.api.item.LampBlockItem;
+import com.gregtechceu.gtceu.common.item.LampBlockItem;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer;
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 84eca1dd9c7..ce935bc334a 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
@@ -9,7 +9,7 @@
 import com.gregtechceu.gtceu.client.util.GTQuadTransformers;
 import com.gregtechceu.gtceu.client.util.StaticFaceBakery;
 import com.gregtechceu.gtceu.common.cover.FacadeCover;
-import com.gregtechceu.gtceu.common.item.FacadeItemBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.FacadeItemBehaviour;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
 import net.minecraft.Util;
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..9b142007064
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/monitor/MonitorGuiRenderer.java
@@ -0,0 +1,239 @@
+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.InWorldMUIOpenEvent;
+import com.gregtechceu.gtceu.api.mui.InWorldMUIRenderEvent;
+import com.gregtechceu.gtceu.api.mui.animation.AnimatorManager;
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.client.CharTypedEvent;
+import com.gregtechceu.gtceu.client.EarlyKeyPressEvent;
+import com.gregtechceu.gtceu.client.mui.screen.*;
+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.common.mui.factory.MachineUIFactory;
+import com.gregtechceu.gtceu.core.IGameRenderer;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.ShaderInstance;
+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.client.ForgeHooksClient;
+import net.minecraftforge.common.ForgeMod;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+import com.mojang.blaze3d.pipeline.RenderTarget;
+import com.mojang.blaze3d.pipeline.TextureTarget;
+import com.mojang.blaze3d.platform.InputConstants;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.*;
+import com.mojang.datafixers.util.Pair;
+import org.joml.Matrix4f;
+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()), true);
+        } 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.isPlayerInventory()) {
+                        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();
+        AnimatorManager.INSTANCE.onDraw(null);
+        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/forge/ForgeCommonEventListener.java b/src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java
similarity index 91%
rename from src/main/java/com/gregtechceu/gtceu/forge/ForgeCommonEventListener.java
rename to src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java
index b855f3dc6dc..f5bfa619e5e 100644
--- a/src/main/java/com/gregtechceu/gtceu/forge/ForgeCommonEventListener.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java
@@ -1,25 +1,33 @@
-package com.gregtechceu.gtceu.forge;
+package com.gregtechceu.gtceu.common;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTCEuAPI;
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.block.BlockAttributes;
+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.capability.IMedicalConditionTracker;
 import com.gregtechceu.gtceu.api.capability.compat.EUToFEProvider;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.cosmetics.CapeRegistry;
 import com.gregtechceu.gtceu.api.cosmetics.event.RegisterGTCapesEvent;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
+import com.gregtechceu.gtceu.api.data.chemical.material.event.PostMaterialEvent;
+import com.gregtechceu.gtceu.api.data.chemical.material.info.MaterialFlags;
+import com.gregtechceu.gtceu.api.data.chemical.material.properties.AlloyBlastProperty;
+import com.gregtechceu.gtceu.api.data.chemical.material.properties.BlastProperty;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.HazardProperty;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
+import com.gregtechceu.gtceu.api.data.chemical.material.stack.MaterialStack;
 import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
+import com.gregtechceu.gtceu.api.fluids.FluidBuilder;
+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.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEnderRegistry;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeManager;
 import com.gregtechceu.gtceu.api.pattern.MultiblockWorldSavedData;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
 import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
@@ -34,9 +42,9 @@
 import com.gregtechceu.gtceu.common.data.machines.GTAEMachines;
 import com.gregtechceu.gtceu.common.fluid.potion.BottleItemFluidHandler;
 import com.gregtechceu.gtceu.common.fluid.potion.PotionItemFluidHandler;
-import com.gregtechceu.gtceu.common.item.ToggleEnergyConsumerBehavior;
 import com.gregtechceu.gtceu.common.item.armor.IJetpack;
 import com.gregtechceu.gtceu.common.item.armor.QuarkTechSuite;
+import com.gregtechceu.gtceu.common.item.behavior.ToggleEnergyConsumerBehavior;
 import com.gregtechceu.gtceu.common.machine.owner.MachineOwner;
 import com.gregtechceu.gtceu.common.network.GTNetwork;
 import com.gregtechceu.gtceu.common.network.packets.SPacketSendWorldID;
@@ -51,6 +59,7 @@
 import com.gregtechceu.gtceu.data.loader.BedrockOreLoader;
 import com.gregtechceu.gtceu.data.loader.GTOreLoader;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
+import com.gregtechceu.gtceu.data.recipe.misc.alloyblast.CustomAlloyBlastRecipeProducer;
 import com.gregtechceu.gtceu.integration.map.ClientCacheManager;
 import com.gregtechceu.gtceu.integration.map.WaypointManager;
 import com.gregtechceu.gtceu.integration.map.cache.server.ServerCache;
@@ -105,13 +114,14 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static com.gregtechceu.gtceu.utils.FormattingUtil.toLowerCaseUnderscore;
 
 @Mod.EventBusSubscriber(modid = GTCEu.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE)
-public class ForgeCommonEventListener {
+public class CommonEventListener {
 
     @SubscribeEvent
     public static void registerItemStackCapabilities(AttachCapabilitiesEvent<ItemStack> event) {
@@ -251,6 +261,8 @@ public static void registerReloadListeners(AddReloadListenerEvent event) {
         event.addListener(new GTOreLoader());
         event.addListener(new BedrockFluidLoader());
         event.addListener(new BedrockOreLoader());
+        if (GTCEu.isClientThread())
+            event.addListener(new ThemeManager());
     }
 
     @SubscribeEvent
@@ -294,7 +306,6 @@ public static void serverStarting(ServerStartingEvent event) {
     @SubscribeEvent
     public static void serverStopped(ServerStoppedEvent event) {
         ServerCache.instance.clear();
-        VirtualEnderRegistry.release();
     }
 
     @SubscribeEvent
@@ -665,4 +676,43 @@ public static void breakSpeed(PlayerEvent.BreakSpeed event) {
             }
         }
     }
+
+    @SubscribeEvent
+    public static void addAlloyBlastProperties(PostMaterialEvent event) {
+        for (Material material : GTCEuAPI.materialManager.getRegisteredMaterials()) {
+            if (!material.hasFlag(MaterialFlags.DISABLE_ALLOY_PROPERTY)) {
+                addAlloyBlastProperty(material);
+            }
+        }
+        // Alloy Blast Overriding
+        GTMaterials.NiobiumNitride.getProperty(PropertyKey.ALLOY_BLAST)
+                .setRecipeProducer(new CustomAlloyBlastRecipeProducer(1, 11, -1));
+
+        GTMaterials.IndiumTinBariumTitaniumCuprate.getProperty(PropertyKey.ALLOY_BLAST)
+                .setRecipeProducer(new CustomAlloyBlastRecipeProducer(-1, -1, 16));
+    }
+
+    public static void addAlloyBlastProperty(@NotNull Material material) {
+        final List<MaterialStack> components = material.getMaterialComponents();
+        // ignore materials which are not alloys
+        if (components.size() < 2) return;
+
+        BlastProperty blastProperty = material.getProperty(PropertyKey.BLAST);
+        if (blastProperty == null) return;
+
+        if (!material.hasProperty(PropertyKey.FLUID)) return;
+
+        // if there are more than 2 fluid-only components in the material, do not generate a hot fluid
+        if (components.stream().filter(CommonEventListener::isMaterialStackFluidOnly).limit(3).count() > 2) {
+            return;
+        }
+
+        material.setProperty(PropertyKey.ALLOY_BLAST, new AlloyBlastProperty(material.getBlastTemperature()));
+        material.getProperty(PropertyKey.FLUID).getStorage().enqueueRegistration(FluidStorageKeys.MOLTEN,
+                new FluidBuilder().state(FluidState.LIQUID));
+    }
+
+    private static boolean isMaterialStackFluidOnly(@NotNull MaterialStack ms) {
+        return !ms.material().hasProperty(PropertyKey.DUST) && ms.material().hasProperty(PropertyKey.FLUID);
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java b/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java
index 53f27507e4d..f6447623ee1 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java
@@ -5,7 +5,7 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.addon.AddonFinder;
 import com.gregtechceu.gtceu.api.addon.IGTAddon;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
 import com.gregtechceu.gtceu.api.data.chemical.material.event.MaterialEvent;
 import com.gregtechceu.gtceu.api.data.chemical.material.event.MaterialRegistryEvent;
@@ -16,15 +16,17 @@
 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.UIFactories;
+import com.gregtechceu.gtceu.api.mui.factory.inventory.InventoryTypes;
 import com.gregtechceu.gtceu.api.recipe.chance.logic.ChanceLogic;
 import com.gregtechceu.gtceu.api.recipe.ingredient.*;
 import com.gregtechceu.gtceu.api.recipe.lookup.ingredient.*;
 import com.gregtechceu.gtceu.api.recipe.lookup.ingredient.fluid.*;
 import com.gregtechceu.gtceu.api.recipe.lookup.ingredient.item.*;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
 import com.gregtechceu.gtceu.common.data.*;
 import com.gregtechceu.gtceu.common.data.GTPlaceholders;
 import com.gregtechceu.gtceu.common.data.machines.GTMachineUtils;
@@ -32,6 +34,8 @@
 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.mui.GTGuiTheme;
 import com.gregtechceu.gtceu.common.network.GTNetwork;
 import com.gregtechceu.gtceu.common.registry.GTRegistration;
 import com.gregtechceu.gtceu.common.unification.material.MaterialRegistryManager;
@@ -45,7 +49,6 @@
 import com.gregtechceu.gtceu.data.pack.GTDynamicResourcePack;
 import com.gregtechceu.gtceu.data.pack.GTPackSource;
 import com.gregtechceu.gtceu.data.recipe.GTCraftingComponents;
-import com.gregtechceu.gtceu.forge.AlloyBlastPropertyAddition;
 import com.gregtechceu.gtceu.integration.ae2.GTAEPlaceholders;
 import com.gregtechceu.gtceu.integration.cctweaked.CCTweakedPlugin;
 import com.gregtechceu.gtceu.integration.create.GTCreateIntegration;
@@ -69,6 +72,7 @@
 import net.minecraftforge.common.crafting.PartialNBTIngredient;
 import net.minecraftforge.common.crafting.StrictNBTIngredient;
 import net.minecraftforge.event.AddPackFindersEvent;
+import net.minecraftforge.event.TickEvent;
 import net.minecraftforge.eventbus.api.IEventBus;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fluids.FluidStack;
@@ -94,12 +98,19 @@ public CommonProxy() {
         // used for forge events (ClientProxy + CommonProxy)
         IEventBus eventBus = FMLJavaModLoadingContext.get().getModEventBus();
         eventBus.register(this);
-        eventBus.addListener(AlloyBlastPropertyAddition::addAlloyBlastProperties);
         // must be set here because of KubeJS compat
         // trying to read this before the pre-init stage
         GTCEuAPI.materialManager = MaterialRegistryManager.getInstance();
         ConfigHolder.init();
         GTCEuAPI.initializeHighTier();
+
+        /* MUI Initialization */
+        UIFactories.init();
+        InventoryTypes.init();
+
+        GTGuiTextures.init();
+        GTGuiTheme.registerThemes();
+
         if (GTCEu.isDev()) {
             ConfigHolder.INSTANCE.recipes.generateLowQualityGems = true;
             ConfigHolder.INSTANCE.compat.energy.enableFEConverters = true;
@@ -117,7 +128,6 @@ 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
@@ -143,6 +153,10 @@ public static void init() {
 
         GTCovers.init();
         GTCreativeModeTabs.init();
+
+        IEventBus modBus = FMLJavaModLoadingContext.get().getModEventBus();
+        GTMenuTypes.init(modBus);
+
         GTBlocks.init();
         GTFluids.init();
         GTEntityTypes.init();
@@ -203,6 +217,8 @@ public static void init() {
         FusionReactorMachine.registerFusionTier(GTValues.UV, " (MKIII)");
     }
 
+    public void preInit(FMLConstructModEvent event) {}
+
     private static void initMaterials() {
         // First, register other mods' Registries
         MaterialRegistryManager managerInternal = (MaterialRegistryManager) GTCEuAPI.materialManager;
@@ -296,6 +312,13 @@ public void commonSetup(FMLCommonSetupEvent event) {
         });
     }
 
+    @SubscribeEvent
+    public static void onTick(TickEvent.PlayerTickEvent event) {
+        if (event.player.containerMenu instanceof ModularContainerMenu containerMenu) {
+            containerMenu.onUpdate();
+        }
+    }
+
     @SubscribeEvent
     public void registerCapabilities(RegisterCapabilitiesEvent event) {
         GTCapability.register(event);
diff --git a/src/main/java/com/gregtechceu/gtceu/common/block/CableBlock.java b/src/main/java/com/gregtechceu/gtceu/common/block/CableBlock.java
index 1abacd672cb..dacfeefdb21 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/block/CableBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/block/CableBlock.java
@@ -4,7 +4,7 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.block.MaterialPipeBlock;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.WireProperties;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/block/DuctPipeBlock.java b/src/main/java/com/gregtechceu/gtceu/common/block/DuctPipeBlock.java
index 95cffc6ee83..bc5fa0cc8ff 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/block/DuctPipeBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/block/DuctPipeBlock.java
@@ -3,10 +3,10 @@
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.block.PipeBlock;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardCleaner;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardEmitter;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardCleanerTrait;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
 import com.gregtechceu.gtceu.api.pipenet.IPipeNode;
 import com.gregtechceu.gtceu.api.registry.registrate.provider.GTBlockstateProvider;
 import com.gregtechceu.gtceu.client.model.pipe.PipeModel;
@@ -88,8 +88,10 @@ public boolean canPipeConnectToBlock(IPipeNode<DuctPipeType, DuctPipeProperties>
                                          @Nullable BlockEntity tile) {
         return tile != null &&
                 (tile.getCapability(GTCapability.CAPABILITY_HAZARD_CONTAINER, side.getOpposite()).isPresent() ||
-                        tile instanceof MetaMachine metaMachine && (tile instanceof IEnvironmentalHazardCleaner ||
-                                tile instanceof IEnvironmentalHazardEmitter));
+                        tile instanceof MetaMachine metaMachine &&
+                                (metaMachine.getTraitHolder().getTrait(EnvironmentalHazardCleanerTrait.TYPE) != null ||
+                                        metaMachine.getTraitHolder().getTrait(EnvironmentalHazardEmitterTrait.TYPE) !=
+                                                null));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/block/LaserPipeBlock.java b/src/main/java/com/gregtechceu/gtceu/common/block/LaserPipeBlock.java
index 311338b6a1f..34b8860d158 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/block/LaserPipeBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/block/LaserPipeBlock.java
@@ -4,7 +4,7 @@
 import com.gregtechceu.gtceu.api.block.PipeBlock;
 import com.gregtechceu.gtceu.api.block.property.GTBlockStateProperties;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.pipenet.IPipeNode;
 import com.gregtechceu.gtceu.api.registry.registrate.provider.GTBlockstateProvider;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/block/OpticalPipeBlock.java b/src/main/java/com/gregtechceu/gtceu/common/block/OpticalPipeBlock.java
index c710e296547..63de5f63004 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/block/OpticalPipeBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/block/OpticalPipeBlock.java
@@ -4,7 +4,7 @@
 import com.gregtechceu.gtceu.api.block.PipeBlock;
 import com.gregtechceu.gtceu.api.block.property.GTBlockStateProperties;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.pipenet.IPipeNode;
 import com.gregtechceu.gtceu.api.registry.registrate.provider.GTBlockstateProvider;
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 8d33f3c08f4..c50eb91d80b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/CableBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/CableBlockEntity.java
@@ -2,26 +2,25 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IEnergyContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 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;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.block.CableBlock;
 import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+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;
@@ -322,8 +321,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/DuctPipeBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/DuctPipeBlockEntity.java
index 6a4a060339f..efcf4eb4d6e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/DuctPipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/DuctPipeBlockEntity.java
@@ -1,12 +1,13 @@
 package com.gregtechceu.gtceu.common.blockentity;
 
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardCleaner;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardEmitter;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardCleanerTrait;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
 import com.gregtechceu.gtceu.common.pipelike.duct.*;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
@@ -110,10 +111,11 @@ public boolean canAttachTo(Direction side) {
                 return false;
             }
             BlockPos relative = getBlockPos().relative(side);
-            return GTCapabilityHelper.getHazardContainer(level, relative, side.getOpposite()) !=
-                    null ||
-                    (level.getBlockEntity(relative) instanceof IEnvironmentalHazardCleaner ||
-                            level.getBlockEntity(relative) instanceof IEnvironmentalHazardEmitter);
+            MetaMachine adjacent = MetaMachine.getMachine(level, relative);
+            return GTCapabilityHelper.getHazardContainer(level, relative, side.getOpposite()) != null ||
+                    (adjacent != null &&
+                            (adjacent.getTraitHolder().getTrait(EnvironmentalHazardEmitterTrait.TYPE) != null ||
+                                    adjacent.getTraitHolder().getTrait(EnvironmentalHazardCleanerTrait.TYPE) != null));
         }
         return false;
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/blockentity/FluidPipeBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/FluidPipeBlockEntity.java
index f4d8c653ed4..e35d87c2c81 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/FluidPipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/FluidPipeBlockEntity.java
@@ -2,8 +2,8 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.FluidPipeProperties;
@@ -20,7 +20,7 @@
 import com.gregtechceu.gtceu.common.cover.FluidFilterCover;
 import com.gregtechceu.gtceu.common.cover.PumpCover;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.pipelike.fluidpipe.FluidPipeType;
 import com.gregtechceu.gtceu.common.pipelike.fluidpipe.PipeTankList;
 import com.gregtechceu.gtceu.utils.EntityDamageUtil;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/blockentity/ItemPipeBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/ItemPipeBlockEntity.java
index f222c06da11..c3743878966 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/ItemPipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/ItemPipeBlockEntity.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.common.blockentity;
 
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.ItemPipeProperties;
 import com.gregtechceu.gtceu.common.block.ItemPipeBlock;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/blockentity/LaserPipeBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/LaserPipeBlockEntity.java
index 4e66ec19415..fa11317d696 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/LaserPipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/LaserPipeBlockEntity.java
@@ -2,9 +2,9 @@
 
 import com.gregtechceu.gtceu.api.block.property.GTBlockStateProperties;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.ILaserContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.pipenet.IPipeNode;
 import com.gregtechceu.gtceu.common.pipelike.laser.*;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/blockentity/OpticalPipeBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/OpticalPipeBlockEntity.java
index f6d28f19418..bdadc7fa05c 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/OpticalPipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/OpticalPipeBlockEntity.java
@@ -2,9 +2,9 @@
 
 import com.gregtechceu.gtceu.api.block.property.GTBlockStateProperties;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IDataAccessHatch;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.pipenet.IPipeNode;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
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 3b9463eb764..623fb88f198 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/commands/GTCommands.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/commands/GTCommands.java
@@ -9,6 +9,8 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeManager;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
 import com.gregtechceu.gtceu.api.registry.GTRegistry;
 import com.gregtechceu.gtceu.common.commands.arguments.GTRegistryArgument;
@@ -34,6 +36,7 @@
 
 import com.google.common.collect.Sets;
 import com.google.gson.JsonElement;
+import com.mojang.brigadier.Command;
 import com.mojang.brigadier.CommandDispatcher;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
@@ -72,6 +75,12 @@ public class GTCommands {
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher, CommandBuildContext buildContext) {
         dispatcher.register(
                 literal("gtceu")
+                        .then(Commands.literal("reload_themes")
+                                .executes(ctx -> {
+                                    ThemeManager.reload();
+                                    ctx.getSource().sendSuccess(() -> Component.literal("GTCEu MUI Themes reloaded").withStyle(IKey.GREEN), true);
+                                    return Command.SINGLE_SUCCESS;
+                                }))
                         .then(literal("ui_editor")
                                 .requires(ctx -> ctx.hasPermission(LEVEL_ADMINS))
                                 .executes(context -> {
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 9a4ef87e2c6..1a3b90de9cf 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,12 +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;
@@ -49,7 +45,7 @@
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
 public class ComputerMonitorCover extends CoverBehavior
-                                  implements IUICover, IDataStickInteractable, IPlaceholderInfoProviderCover {
+                                  implements IDataStickInteractable, IPlaceholderInfoProviderCover {
 
     private TickableSubscription subscription;
     private final CoverTextRenderer renderer;
@@ -124,87 +120,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..be8639dc960 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ConveyorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ConveyorCover.java
@@ -4,34 +4,30 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.ItemHandlerDelegate;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 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.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -61,7 +57,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));
@@ -423,54 +419,71 @@ 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 (createConveyorIORow()) {}
+
+        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() {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/FacadeCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/FacadeCover.java
index 7c4863297b0..642b8cd2419 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/FacadeCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/FacadeCover.java
@@ -6,7 +6,7 @@
 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.item.FacadeItemBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.FacadeItemBehaviour;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
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..d345a844d47 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java
@@ -3,23 +3,30 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DynamicSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.client.mui.screen.UISettings;
 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.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 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;
@@ -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 0e63eb3cd2a..e6f2adf0243 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.mui.screen.UISettings;
 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.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 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 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..9de99310817 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java
@@ -3,25 +3,32 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DynamicSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.ItemHandlerDelegate;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 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.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 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;
@@ -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..3a82b270b77 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/MachineControllerCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/MachineControllerCover.java
@@ -5,31 +5,35 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.SliderWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 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.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 
 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;
@@ -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 GTGuis.createPanel(this, 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)
+                                        .alignX(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).alignX(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).alignX(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 GTGuiTextures.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..8df788feb21 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/PumpCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/PumpCover.java
@@ -4,31 +4,31 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.fluid.FluidHandlerDelegate;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.api.transfer.fluid.ModifiableFluidHandlerWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.cover.data.BucketMode;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -44,17 +44,15 @@
 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));
@@ -184,22 +182,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 +268,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));
-
-        group.addWidget(new EnumSelectorWidget<>(10, 45, 20, 20, List.of(IO.IN, IO.OUT), io, this::setIo));
-
-        group.addWidget(new EnumSelectorWidget<>(146, 107, 20, 20,
-                ManualIOMode.VALUES, manualIOMode, this::setManualIOMode)
-                .setHoverTooltips("cover.universal.manual_import_export.mode.description"));
-
-        group.addWidget(filterHandler.createFilterSlotUI(125, 108));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 72, 156, 60));
-
-        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.
+    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);
+
+        syncManager.syncValue("io", ioSync);
+        syncManager.syncValue("transferRate", transferRateSync);
+        syncManager.syncValue("manualIO", manualIOModeSync);
+
+        column.child(GTMuiWidgets.createIntInputWithBucketMode(transferRateSync, bucketModeSync,
+                () -> maxFluidTransferRate));
+
+        column.child(GTMuiWidgets.createFilterRow(filterHandler, data, syncManager, settings)
+                .child(0, GTMuiWidgets.createIOCycleButton(ioSync, false)));
+
+        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() {
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..6fe1ae07372 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,31 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.cover.data.TransferMode;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 lombok.Getter;
 import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.Iterator;
 import java.util.Map;
@@ -157,24 +163,26 @@ 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);
 
-        this.stackSizeInput = new IntInputWidget(64, 45, 80, 20,
-                () -> globalTransferLimit, val -> globalTransferLimit = val);
-        configureStackSizeInput();
+        syncManager.syncValue("transferMode", transferMode);
+        syncManager.syncValue("transferSize", transferSize);
+
+        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) {
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..66647e0bff2 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/StorageCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/StorageCover.java
@@ -3,20 +3,25 @@
 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.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
 import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
 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.client.mui.screen.UISettings;
 
 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;
@@ -27,7 +32,7 @@
 
 import java.util.List;
 
-public class StorageCover extends CoverBehavior implements IUICover {
+public class StorageCover extends CoverBehavior implements IMuiCover {
 
     @SaveField
     @SyncToClient
@@ -69,20 +74,16 @@ 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";
+    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();
     }
 
     @Override
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..4fefeac804c 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.gregtechceu.gtceu.api.mui.drawable.UITexture;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import net.minecraft.resources.ResourceLocation;
 
 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/detector/AdvancedEnergyDetectorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedEnergyDetectorCover.java
index 20fca500a38..6a2b07ad75a 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 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.addMultiLine("cover.advanced_energy_detector.invert.disabled"))
+                                .tooltip(true, t -> t.addMultiLine("cover.advanced_energy_detector.invert.enabled")))
+                        .child(new ToggleButton().value(new BooleanSyncValue(this::isUsePercent, this::setUsePercent))
+                                .selectedBackground(ThemeAPI.INSTANCE.getTheme(settings.getTheme())
+                                        .getToggleButtonTheme().getTheme().getBackground())
+                                .overlay(false, GTGuiTextures.BUTTON_EU)
+                                .overlay(true, GTGuiTextures.BUTTON_PERCENT)
+                                .tooltip(false,
+                                        t -> t.addMultiLine("cover.advanced_energy_detector.use_percent.disabled"))
+                                .tooltip(true,
+                                        t -> t.addMultiLine("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..c7ed19436ff 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,22 @@
 
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
@@ -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.addMultiLine("cover.advanced_fluid_detector.invert.disabled"))
+                        .tooltip(true, t -> t.addMultiLine("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.addMultiLine("cover.advanced_detector.latch.disabled"))
+                        .tooltip(true, t -> t.addMultiLine("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..e546925059f 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,24 @@
 
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -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.addMultiLine("cover.advanced_item_detector.invert.disabled"))
+                        .tooltip(true, t -> t.addMultiLine("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.addMultiLine("cover.advanced_detector.latch.disabled"))
+                        .tooltip(true, t -> t.addMultiLine("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 9532f234cc1..93a42abeefe 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,55 +5,63 @@
 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.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.*;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufAdapter;
 
-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.network.FriendlyByteBuf;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerLevel;
 
+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
@@ -65,19 +73,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
@@ -89,36 +90,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) {
@@ -127,12 +108,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;
@@ -141,372 +116,276 @@ 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);
     }
 
-    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 = new 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;
+                }).align(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::isWorkingEnabled, this::setWorkingEnabled, syncManager));
+        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;
+                }).align(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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(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 3ad32ee9b38..2d27688e13d 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,25 +5,25 @@
 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.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 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.utils.GTTransferUtils;
 
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.core.Direction;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidUtil;
 
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -33,9 +33,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
@@ -47,8 +45,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
@@ -72,11 +68,6 @@ protected EntryTypes<VirtualTank> getEntryType() {
         return EntryTypes.ENDER_FLUID;
     }
 
-    @Override
-    protected String identifier() {
-        return "EFLink#";
-    }
-
     @Override
     protected void transfer() {
         long timer = coverHolder.getOffsetTimer();
@@ -94,6 +85,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();
 
@@ -109,20 +113,4 @@ private int doTransferFluids(int platformTransferLimit) {
         }
         return 0;
     }
-
-    //////////////////////////////////////
-    // ************ 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 8338b7e0e40..06f98d4d559 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,19 +5,19 @@
 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.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
 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.utils.GTTransferUtils;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.core.Direction;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
@@ -32,9 +32,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
@@ -45,8 +43,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
@@ -54,11 +50,6 @@ public boolean canAttach() {
         return true;
     }
 
-    @Override
-    protected String identifier() {
-        return "EILink#";
-    }
-
     @Override
     protected VirtualItemStorage getEntry() {
         return storage;
@@ -96,21 +87,18 @@ private int doTransferItems(int max) {
         };
     }
 
-    public @Nullable IItemHandler getOwnItemHandler() {
-        return coverHolder.getItemHandlerCap(attachedSide, false);
-    }
-
     @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;
+    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);
     }
 
-    @Override
-    protected String getUITitle() {
-        return "cover.ender_item_link.title";
+    public @Nullable IItemHandler getOwnItemHandler() {
+        return coverHolder.getItemHandlerCap(attachedSide, false);
     }
 }
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..bb51d825aa3 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
@@ -5,37 +5,27 @@
 import com.gregtechceu.gtceu.api.misc.virtualregistry.EntryTypes;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEntry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.entries.VirtualRedstone;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
 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 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..579e06bfadc 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.cover.data.BucketMode;
 import com.gregtechceu.gtceu.common.cover.data.VoidingMode;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 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..d15091cedce 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,31 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.EnumSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.cover.data.VoidingMode;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 lombok.Getter;
-import org.jetbrains.annotations.NotNull;
+import lombok.Setter;
 
 import java.util.Map;
 
@@ -38,6 +45,7 @@ public class AdvancedItemVoidingCover extends ItemVoidingCover {
 
     @SaveField
     @Getter
+    @Setter
     protected int globalVoidingLimit = 1;
 
     private IntInputWidget stackSizeInput;
@@ -113,20 +121,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
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 bbd2d2732a1..c883f5442fc 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,18 +2,18 @@
 
 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.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.cover.PumpCover;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -29,7 +29,6 @@
 
 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;
@@ -85,30 +84,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::isWorkingEnabled, this::setWorkingEnabled, syncManager));
+        GTMuiWidgets.createFilterRow(row, filterHandler, data, syncManager, settings);
 
-    @NotNull
-    protected String getUITitle() {
-        return "cover.fluid.voiding.title";
+        column.child(row);
     }
 
     @Override
@@ -129,10 +112,10 @@ 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.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 965a5340dcc..9108db2ac07 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,17 +3,16 @@
 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.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.cover.ConveyorCover;
-
-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 com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -27,7 +26,6 @@
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraftforge.items.IItemHandler;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -36,7 +34,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);
@@ -86,25 +84,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::isWorkingEnabled, this::setWorkingEnabled, syncManager)),
+                filterHandler, data, syncManager,
+                settings));
     }
 
     @Override
@@ -125,12 +111,12 @@ 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) {
         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/GTBlocks.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java
index 241aa9101ff..b2a8f0e4f87 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java
@@ -19,6 +19,8 @@
 import com.gregtechceu.gtceu.common.block.explosive.IndustrialTNTBlock;
 import com.gregtechceu.gtceu.common.block.explosive.PowderbarrelBlock;
 import com.gregtechceu.gtceu.common.data.models.GTModels;
+import com.gregtechceu.gtceu.common.item.LampBlockItem;
+import com.gregtechceu.gtceu.common.item.LaserPipeBlockItem;
 import com.gregtechceu.gtceu.common.pipelike.duct.DuctPipeType;
 import com.gregtechceu.gtceu.common.pipelike.fluidpipe.longdistance.LDFluidPipeType;
 import com.gregtechceu.gtceu.common.pipelike.item.longdistance.LDItemPipeType;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTCreativeModeTabs.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTCreativeModeTabs.java
index a024f476db8..7bc50d31c7a 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTCreativeModeTabs.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTCreativeModeTabs.java
@@ -6,10 +6,10 @@
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.IGTTool;
-import com.gregtechceu.gtceu.api.item.LampBlockItem;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.ToolHelper;
 import com.gregtechceu.gtceu.api.registry.registrate.GTRegistrate;
+import com.gregtechceu.gtceu.common.item.LampBlockItem;
 import com.gregtechceu.gtceu.common.pipelike.cable.Insulation;
 
 import net.minecraft.core.NonNullList;
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 64cac05549e..e87f90735fa 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTItems.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTItems.java
@@ -26,10 +26,12 @@
 import com.gregtechceu.gtceu.common.entity.GTBoat;
 import com.gregtechceu.gtceu.common.item.*;
 import com.gregtechceu.gtceu.common.item.armor.*;
+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.common.item.tool.behavior.LighterBehavior;
-import com.gregtechceu.gtceu.common.item.tool.behavior.MachineConfigCopyBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
@@ -2553,6 +2555,10 @@ 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 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..f48b98a9298 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java
@@ -21,7 +21,10 @@
 import com.gregtechceu.gtceu.client.util.TooltipHelper;
 import com.gregtechceu.gtceu.common.data.machines.*;
 import com.gregtechceu.gtceu.common.data.models.GTModels;
+import com.gregtechceu.gtceu.common.data.mui.GTSingleblockMachinePanels;
 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 +33,7 @@
 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.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..7706ecfb731
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTMenuTypes.java
@@ -0,0 +1,25 @@
+package com.gregtechceu.gtceu.common.data;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+
+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;
+
+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 45fccd4f5de..4330822e328 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTPlaceholders.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTPlaceholders.java
@@ -26,6 +26,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;
@@ -107,6 +108,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") {
 
@@ -120,14 +126,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") {
 
@@ -167,6 +191,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") {
 
@@ -181,9 +210,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") {
 
@@ -241,13 +277,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") {
 
@@ -257,6 +303,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, 0);
                 return MultiLineComponent.literal("█");
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("tick") {
 
@@ -266,6 +317,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") {
 
@@ -277,6 +333,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") {
 
@@ -311,6 +372,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") {
 
@@ -323,6 +389,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") {
 
@@ -335,6 +406,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") {
 
@@ -347,6 +423,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") {
 
@@ -359,6 +440,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") {
 
@@ -371,6 +457,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 throw new NotSupportedException();
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("amperage") {
 
@@ -383,6 +474,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 throw new NotSupportedException();
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("count") {
 
@@ -397,6 +493,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 return MultiLineComponent.literal(cnt);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("data") {
 
@@ -406,6 +507,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", 1, ctx.itemStackHandler().getSlots(), slot);
                     ItemStack stack = ctx.itemStackHandler().getStackInSlot(slot - 1);
@@ -460,6 +563,11 @@ public MultiLineComponent apply(PlaceholderContext ctx, List<MultiLineComponent>
                 }
                 return out.setIgnoreSpaces(true);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("nbt") {
 
@@ -477,6 +585,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") {
 
@@ -489,6 +602,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") {
 
@@ -500,6 +618,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") {
 
@@ -509,6 +632,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") {
 
@@ -526,6 +654,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 out.setIgnoreSpaces(true);
                 return out;
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("cmp") {
 
@@ -545,6 +678,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                     default -> throw new InvalidArgsException();
                 };
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("bf") {
 
@@ -711,6 +849,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") {
 
@@ -732,6 +875,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") {
 
@@ -747,6 +895,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") {
 
@@ -765,29 +918,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());
                     }
@@ -843,9 +978,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..85e59dc40d8 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeTypes.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeTypes.java
@@ -10,6 +10,7 @@
 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.mui.widgets.ProgressWidget;
 import com.gregtechceu.gtceu.api.recipe.*;
 import com.gregtechceu.gtceu.api.recipe.content.Content;
 import com.gregtechceu.gtceu.api.recipe.ingredient.FluidIngredient;
@@ -17,13 +18,14 @@
 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.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;
@@ -82,22 +84,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 +118,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 +173,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 +239,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 +284,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 +493,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 +564,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/machines/GCYMMachines.java b/src/main/java/com/gregtechceu/gtceu/common/data/machines/GCYMMachines.java
index b8ec948322f..cffff9f67e9 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/machines/GCYMMachines.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/machines/GCYMMachines.java
@@ -71,6 +71,9 @@ public static void init() {}
                     .abilities(PartAbility.PARALLEL_HATCH)
                     .modelProperty(IS_FORMED, false)
                     .modelProperty(GTMachineModelProperties.RECIPE_LOGIC_STATUS, RecipeLogic.Status.IDLE)
+                    .ui((guiData, syncManager, uiSettings, machine) -> {
+                        return ((ParallelHatchPartMachine) machine).buildUI(guiData, syncManager, uiSettings);
+                    })
                     .model(createWorkableTieredHullMachineModel(
                             GTCEu.id("block/machines/parallel_hatch_mk" + (tier - 4)))
                             .andThen((ctx, prov, model) -> {
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 57515764f77..a2d59d52967 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
@@ -16,14 +16,13 @@
 import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
 import com.gregtechceu.gtceu.api.fluids.PropertyFluidFilter;
-import com.gregtechceu.gtceu.api.item.DrumMachineItem;
-import com.gregtechceu.gtceu.api.item.QuantumTankMachineItem;
 import com.gregtechceu.gtceu.api.machine.*;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 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;
@@ -38,6 +37,9 @@
 import com.gregtechceu.gtceu.common.block.BoilerFireboxType;
 import com.gregtechceu.gtceu.common.data.*;
 import com.gregtechceu.gtceu.common.data.models.GTMachineModels;
+import com.gregtechceu.gtceu.common.data.mui.GTSingleblockMachinePanels;
+import com.gregtechceu.gtceu.common.item.DrumMachineItem;
+import com.gregtechceu.gtceu.common.item.QuantumTankMachineItem;
 import com.gregtechceu.gtceu.common.machine.electric.BatteryBufferMachine;
 import com.gregtechceu.gtceu.common.machine.electric.ChargerMachine;
 import com.gregtechceu.gtceu.common.machine.electric.ConverterMachine;
@@ -51,6 +53,7 @@
 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.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 
@@ -72,6 +75,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 +131,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 +191,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 +346,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 +372,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 +496,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))
@@ -944,5 +962,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/data/mui/GTGuiScreen.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTGuiScreen.java
new file mode 100644
index 00000000000..9131cc5b8aa
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTGuiScreen.java
@@ -0,0 +1,29 @@
+package com.gregtechceu.gtceu.common.data.mui;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+
+import org.jetbrains.annotations.NotNull;
+
+import static com.gregtechceu.gtceu.GTCEu.MOD_ID;
+
+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);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiMachineUtil.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiMachineUtil.java
new file mode 100644
index 00000000000..c3639d7287e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiMachineUtil.java
@@ -0,0 +1,86 @@
+package com.gregtechceu.gtceu.common.data.mui;
+
+import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+
+import net.minecraftforge.items.IItemHandler;
+
+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();
+    }
+
+    public static Flow createColumn(boolean reverse, Widget<?>... children) {
+        var column = new Column();
+        column.reverseLayout(reverse);
+        for (Widget<?> child : children) {
+            column.child(child);
+        }
+        return column;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiRecipeTypes.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiRecipeTypes.java
new file mode 100644
index 00000000000..b7c316d220a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiRecipeTypes.java
@@ -0,0 +1,5 @@
+package com.gregtechceu.gtceu.common.data.mui;
+
+public class GTMuiRecipeTypes {
+
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiWidgets.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiWidgets.java
new file mode 100644
index 00000000000..f9f1ee60555
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiWidgets.java
@@ -0,0 +1,700 @@
+package com.gregtechceu.gtceu.common.data.mui;
+
+import com.gregtechceu.gtceu.api.GTValues;
+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.SimpleTieredMachine;
+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.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.*;
+import com.gregtechceu.gtceu.api.mui.drawable.text.TextRenderer;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.*;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.api.recipe.gui.GTRecipeTypeUILayout;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.cover.data.BucketMode;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+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 net.minecraftforge.items.IItemHandler;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
+
+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().getTheme()
+                    .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 createPowerButton(BooleanSupplier getter, BooleanConsumer setter,
+                                                 PanelSyncManager syncManager) {
+        BooleanSyncValue power = syncManager.getOrCreateSyncHandler("workingEnabled", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(getter, setter));
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(power::getBoolValue, power::setBoolValue))
+                .selectedBackground(GTGuiTextures.BUTTON_POWER[1])
+                .background(GTGuiTextures.BUTTON_POWER[0])
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable(
+                        power.getBoolValue() ? "behaviour.soft_hammer.enabled" :
+                                "behaviour.soft_hammer.disabled"))));
+    }
+
+    public static ToggleButton createPowerButton(IRecipeLogicMachine recipeLogicMachine, PanelSyncManager syncManager) {
+        return createPowerButton(
+                () -> recipeLogicMachine.getRecipeLogic().isWorkingEnabled(),
+                recipeLogicMachine::setWorkingEnabled,
+                syncManager);
+    }
+
+    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(SimpleTieredMachine tieredMachine, PanelSyncManager syncManager) {
+        ItemSlotSyncHandler battery = new ItemSlotSyncHandler(new ModularSlot(tieredMachine.getChargerInventory(), 0));
+        syncManager.syncValue("battery", battery);
+        return new ItemSlot().syncHandler("battery").background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY);
+    }
+
+    public static ItemSlot createBatterySlot(IItemHandler itemHandler, int slot, PanelSyncManager syncManager) {
+        ItemSlotSyncHandler battery = new ItemSlotSyncHandler(new ModularSlot(itemHandler, slot));
+        syncManager.syncValue("battery", battery);
+        return new ItemSlot().syncHandler("battery").background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY);
+    }
+
+    public static ToggleButton createVoidingButton(IVoidable machine, PanelSyncManager syncManager) {
+        // TODO pull in voiding mode pr
+        return new ToggleButton();
+        // EnumSyncValue voidMode = new EnumSyncValue(IVoidable.VoidingMode.class, machine.)
+    }
+
+    public static ToggleButton createAutoOutputItemButton(AutoOutputTrait autoOutput, PanelSyncManager syncManager) {
+        BooleanSyncValue itemOutputs = new BooleanSyncValue(autoOutput::isAutoOutputItems,
+                autoOutput::setAllowAutoOutputItems);
+        syncManager.syncValue("auto_output_items", itemOutputs);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(itemOutputs::getBoolValue, itemOutputs::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_ITEM_OUTPUT)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable("gtceu.gui.item_auto_output",
+                        Component.translatable(itemOutputs.getBoolValue() ? "cover.voiding.label.enabled" :
+                                "cover.voiding.label.disabled")))));
+    }
+
+    public static ToggleButton createAutoOutputFluidButton(AutoOutputTrait autoOutput, PanelSyncManager syncManager) {
+        BooleanSyncValue fluidOutputs = new BooleanSyncValue(autoOutput::isAutoOutputFluids,
+                autoOutput::setAllowAutoOutputFluids);
+        syncManager.syncValue("auto_output_fluids", fluidOutputs);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(fluidOutputs::getBoolValue, fluidOutputs::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_FLUID_OUTPUT)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable("gtceu.gui.fluid_auto_output",
+                        Component.translatable(fluidOutputs.getBoolValue() ? "cover.voiding.label.enabled" :
+                                "cover.voiding.label.disabled")))));
+    }
+
+    public static ToggleButton createInputFromOutputItem(AutoOutputTrait autoOutput, PanelSyncManager syncManager) {
+        BooleanSyncValue inputFromOutputItem = new BooleanSyncValue(autoOutput::allowsItemInputFromOutputSide,
+                autoOutput::setAllowItemInputFromOutputSide);
+        syncManager.syncValue("input_from_output_item", inputFromOutputItem);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(inputFromOutputItem::getBoolValue, inputFromOutputItem::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_ITEM_OUTPUT)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable("gtceu.gui.item_input_from_output",
+                        Component.translatable(inputFromOutputItem.getBoolValue() ? "cover.voiding.label.enabled" :
+                                "cover.voiding.label.disabled")))));
+    }
+
+    public static ToggleButton createInputFromOutputFluid(AutoOutputTrait autoOutput, PanelSyncManager syncManager) {
+        BooleanSyncValue inputFromOutputFluid = new BooleanSyncValue(autoOutput::allowsFluidInputFromOutputSide,
+                autoOutput::setAllowFluidInputFromOutputSide);
+        syncManager.syncValue("input_from_output_fluid", inputFromOutputFluid);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(inputFromOutputFluid::getBoolValue, inputFromOutputFluid::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_FLUID_OUTPUT)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable("gtceu.gui.fluid_input_from_output",
+                        Component.translatable(inputFromOutputFluid.getBoolValue() ? "cover.voiding.label.enabled" :
+                                "cover.voiding.label.disabled")))));
+    }
+
+    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,
+                                circuitGetter.get().isEmpty() ? 1 : circuitGetter.get().getCount())));
+    }
+
+    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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(true)
+                .height(105)
+                .child(new Column()
+                        .padding(2)
+                        .fullHeight()
+                        .coverChildren()
+                        .childPadding(7)
+                        .top(3)
+                        .alignX(Alignment.Center)
+                        .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);
+
+        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(new TextFieldWidget()
+                        .left(18).right(18)
+                        .setTextAlignment(Alignment.Center)
+                        .setTextColor(Color.WHITE.darker(1))
+                        .setNumbers(minValue, maxValue)
+                        .onMouseScrolled((mouseX, mouseY, 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;
+                        })
+                        .value(formattedValue)
+                        .background(background))
+                .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);
+
+        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(new TextFieldWidget()
+                        .left(18).right(18)
+                        .setTextAlignment(Alignment.Center)
+                        .setTextColor(Color.WHITE.darker(1))
+                        .setNumbersLong(minValue, maxValue)
+                        .onMouseScrolled((mouseX, mouseY, 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;
+                        })
+                        .value(formattedValue)
+                        .background(background))
+                .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));
+
+        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(new TextFieldWidget()
+                        .left(18).right(36)
+                        .setTextAlignment(Alignment.Center)
+                        .setTextColor(Color.WHITE.darker(1))
+                        .setNumbers(0, maxMB.getAsInt())
+                        .onMouseScrolled((mouseX, mouseY, 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;
+                        })
+                        .value(formattedValue)
+                        .background(GTGuiTextures.DISPLAY))
+                .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 EnumSyncValue<T> syncValue;
+        private final Class<T> enumValue;
+        private IKey lang;
+        private IDrawable[] background;
+        private IDrawable selectedBackground;
+        private IDrawable[] 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(GTGuiTextures.MC_BUTTON);
+
+                    if (this.selectedBackground != null)
+                        button.selectedBackground(this.selectedBackground);
+                    else
+                        button.selectedBackground(GTGuiTextures.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().align(Alignment.CenterRight).height(18));
+
+            return row;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMultiblockPanelUtil.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMultiblockPanelUtil.java
new file mode 100644
index 00000000000..0a48dfd1c4d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMultiblockPanelUtil.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.common.data.mui;
+
+import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
+import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
+import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+public class GTMultiblockPanelUtil {
+
+    private final MultiblockControllerMachine controller;
+
+    public GTMultiblockPanelUtil(MultiblockControllerMachine controller) {
+        this.controller = controller;
+    }
+
+    public Widget<?> getMainTextPanel(PanelSyncManager syncManager, int width, int height) {
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>()
+                .width(width - 6)
+                .height(height - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .alignX(Alignment.CenterLeft);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.MUI_DISPLAY);
+
+        listWidget.children(controller.getWidgetsForDisplay(syncManager));
+        parentWidget.child(listWidget.left(3).top(3));
+        return parentWidget;
+    }
+
+    public IWidget getRecipeActionWidget() {
+        if (controller instanceof IRecipeLogicMachine recipeLogicMachine) {
+            RecipeLogic rl = recipeLogicMachine.getRecipeLogic();
+            DynamicSyncedWidget<?> recipeActionResultWidget = new DynamicSyncedWidget<>();
+
+            if (rl.isWaiting()) {
+                var reason = rl.getWaitingReason();
+                // recipeActionResultWidget.
+                // recipeActionResultWidget = rl
+            }
+        }
+        return new EmptyWidget();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMultiblockTextUtil.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMultiblockTextUtil.java
new file mode 100644
index 00000000000..743f25e6886
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMultiblockTextUtil.java
@@ -0,0 +1,488 @@
+package com.gregtechceu.gtceu.common.data.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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.FluidDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+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.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
+import com.gregtechceu.gtceu.utils.GTUtil;
+import com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
+
+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 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(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> 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,
+                () -> new GenericSyncValue.Builder<>(GTRecipe.class)
+                        .getter(() -> rlmachine.getRecipeLogic().getLastRecipe())
+                        .setter((newRecipe) -> {})
+                        .adapter(ByteBufAdapters.GTRECIPE)
+                        .copy((toCopy) -> {
+                            if (toCopy == null) return null;
+                            return toCopy.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/data/mui/GTSingleblockMachinePanels.java b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTSingleblockMachinePanels.java
new file mode 100644
index 00000000000..f17d233222d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/mui/GTSingleblockMachinePanels.java
@@ -0,0 +1,343 @@
+package com.gregtechceu.gtceu.common.data.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.WorkableTieredMachine;
+import com.gregtechceu.gtceu.api.machine.steam.SimpleSteamMachine;
+import com.gregtechceu.gtceu.api.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.recipe.gui.GTRecipeTypeUIs;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+public class GTSingleblockMachinePanels {
+
+    public static PanelFactory GENERAL_MACHINE = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                                  MetaMachine machine) -> {
+        ModularPanel panel = new ModularPanel(machine.getDefinition().getName());
+        if (!(machine instanceof WorkableTieredMachine workableMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+
+        if (!(machine instanceof SimpleTieredMachine simpleTieredMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+
+        var inputItemGrid = GTMuiWidgets.createGrid(workableMachine.importItems.getSize(), 3, false, 'i');
+        var inputFluidGrid = GTMuiWidgets.createGrid(workableMachine.importFluids.getSize(), 3, false, 'f');
+        var outputItemGrid = GTMuiWidgets.createGrid(workableMachine.exportItems.getSize(), 3, true, 'i');
+        var outputFluidGrid = GTMuiWidgets.createGrid(workableMachine.exportFluids.getSize(), 3, true, 'f');
+
+        int slotHeight = Math.max(inputItemGrid.length + inputFluidGrid.length,
+                outputItemGrid.length + outputFluidGrid.length);
+
+        boolean ghostCircuit = simpleTieredMachine.isCircuitSlotEnabled();
+
+        panel.size(176, 76 + 21 + 18 + 9 + 18 * Math.max(2, slotHeight));
+
+        boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(workableMachine.getRecipeType());
+
+        var theme = machine.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
+
+        var autoOutput = machine.getTraitHolder().getTrait(AutoOutputTrait.TYPE);
+
+        panel.child(GTMuiWidgets.createTitleBar(machine.getDefinition(), 176))
+                .child(Flow.row()
+                        .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(workableMachine.getRecipeType())
+                                .getBackedSlotsRow(syncManager, theme, simpleTieredMachine.importItems,
+                                        simpleTieredMachine.exportItems,
+                                        simpleTieredMachine.importFluids, simpleTieredMachine.exportFluids,
+                                        simpleTieredMachine.recipeLogic::getProgressPercent,
+                                        -1)
+                                .alignX(Alignment.CENTER))
+                        .coverChildrenHeight()
+                        // .left(7)
+                        .bottom(76 + 7 + 18 + 9))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(Flow.col()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .padding(2, 4, 4, 4)
+                        .bottom(16)
+                        .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                        .childPadding(2)
+                        .background(backgroundTexture.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(workableMachine, syncManager))
+                        .child(GTMuiWidgets.createBatterySlot(simpleTieredMachine, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputItems(),
+                                () -> GTMuiWidgets.createAutoOutputItemButton(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputFluids(),
+                                () -> GTMuiWidgets.createAutoOutputFluidButton(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputItems(),
+                                () -> GTMuiWidgets.createInputFromOutputItem(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputFluids(),
+                                () -> GTMuiWidgets.createInputFromOutputFluid(autoOutput, syncManager)))
+                .child(Flow.col()
+                        .coverChildren()
+                        .rightRel(1.0f)
+                        .reverseLayout(true)
+                        .padding(4, 2, 4, 4)
+                        .bottom(16)
+                        .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0f, 0f, 0.75f, 1.0f))
+                        .childIf(ghostCircuit,
+                                () -> GTMuiWidgets.createCircuitSlotPanel(simpleTieredMachine, panel, syncManager)))
+                .child(GTMuiWidgets.createGTLogo()
+                        .right(7).bottom(7 + 78));
+        if (hasXEI && false) {
+            panel.child(GTMuiWidgets.createXEIWidget(GTRecipeTypeUIs.recipeTypeUIs.get(workableMachine.getRecipeType()))
+                    .left(190));
+        }
+        panel.excludeAreaInRecipeViewer();
+        return panel;
+    };
+
+    public static PanelFactory MACERATOR = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                            MetaMachine machine) -> {
+        ModularPanel panel = new ModularPanel(machine.getDefinition().getName());
+        if (!(machine instanceof WorkableTieredMachine workableMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+
+        if (!(machine instanceof SimpleTieredMachine simpleTieredMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+
+        var inputItemGrid = GTMuiWidgets.createGrid(workableMachine.importItems.getSize(), 3, false, 'i');
+        var inputFluidGrid = GTMuiWidgets.createGrid(workableMachine.importFluids.getSize(), 3, false, 'f');
+        var outputItemGrid = GTMuiWidgets.createGrid(workableMachine.exportItems.getSize(), 3, true, 'i');
+        var outputFluidGrid = GTMuiWidgets.createGrid(workableMachine.exportFluids.getSize(), 3, true, 'f');
+
+        int slotHeight = Math.max(inputItemGrid.length + inputFluidGrid.length,
+                outputItemGrid.length + outputFluidGrid.length);
+
+        boolean ghostCircuit = simpleTieredMachine.isCircuitSlotEnabled();
+
+        panel.size(176, 76 + 21 + 18 + 9 + 18 * slotHeight);
+
+        boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(workableMachine.getRecipeType());
+
+        var theme = machine.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
+
+        var autoOutput = machine.getTraitHolder().getTrait(AutoOutputTrait.TYPE);
+
+        panel.child(GTMuiWidgets.createTitleBar(machine.getDefinition(), 176))
+                .child(Flow.row()
+                        .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(workableMachine.getRecipeType())
+                                .getBackedSlotsRow(syncManager, theme, simpleTieredMachine.importItems,
+                                        simpleTieredMachine.exportItems,
+                                        simpleTieredMachine.importFluids, simpleTieredMachine.exportFluids,
+                                        simpleTieredMachine.recipeLogic::getProgressPercent,
+                                        simpleTieredMachine.getTier())
+                                .alignX(Alignment.CENTER))
+                        .coverChildrenHeight()
+                        // .left(7)
+                        .bottom(76 + 7 + 18 + 9))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(Flow.col()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(backgroundTexture.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(workableMachine, syncManager))
+                        .child(GTMuiWidgets.createBatterySlot(simpleTieredMachine, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputItems(),
+                                () -> GTMuiWidgets.createAutoOutputItemButton(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputFluids(),
+                                () -> GTMuiWidgets.createAutoOutputFluidButton(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputItems(),
+                                () -> GTMuiWidgets.createInputFromOutputItem(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputFluids(),
+                                () -> GTMuiWidgets.createInputFromOutputFluid(autoOutput, syncManager)))
+                .child(Flow.col()
+                        .coverChildren()
+                        .rightRel(1.0f)
+                        .reverseLayout(true)
+                        .padding(0, 8, 4, 4)
+                        .bottom(16)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0f, 0f, 0.75f, 1.0f))
+                        .childIf(ghostCircuit,
+                                () -> GTMuiWidgets.createCircuitSlotPanel(simpleTieredMachine, panel, syncManager)))
+                .child(GTMuiWidgets.createGTLogo()
+                        .right(7).bottom(7 + 78));
+        if (hasXEI && false) {
+            panel.child(GTMuiWidgets.createXEIWidget(GTRecipeTypeUIs.recipeTypeUIs.get(workableMachine.getRecipeType()))
+                    .left(190));
+        }
+        panel.excludeAreaInRecipeViewer();
+        return panel;
+    };
+
+    public static PanelFactory ARC_FURNACE = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                              MetaMachine machine) -> {
+        ModularPanel panel = new ModularPanel(machine.getDefinition().getName());
+        if (!(machine instanceof WorkableTieredMachine workableMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+
+        if (!(machine instanceof SimpleTieredMachine simpleTieredMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+
+        var inputItemGrid = GTMuiWidgets.createGrid(workableMachine.importItems.getSize(), 3, false, 'i');
+        var inputFluidGrid = GTMuiWidgets.createGrid(workableMachine.importFluids.getSize(), 3, false, 'f');
+        var outputItemGrid = GTMuiWidgets.createGrid(workableMachine.exportItems.getSize(), 3, true, 'i');
+        var outputFluidGrid = GTMuiWidgets.createGrid(workableMachine.exportFluids.getSize(), 3, true, 'f');
+
+        int slotHeight = Math.max(inputItemGrid.length + inputFluidGrid.length,
+                outputItemGrid.length + outputFluidGrid.length);
+
+        boolean ghostCircuit = simpleTieredMachine.isCircuitSlotEnabled();
+
+        panel.size(176, 76 + 21 + 18 + 9 + 18 * slotHeight);
+
+        var theme = machine.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
+
+        boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(workableMachine.getRecipeType());
+
+        var autoOutput = machine.getTraitHolder().getTrait(AutoOutputTrait.TYPE);
+
+        panel.child(GTMuiWidgets.createTitleBar(machine.getDefinition(), 176))
+                .child(Flow.row()
+                        .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(workableMachine.getRecipeType())
+                                .getBackedSlotsRow(syncManager, theme, simpleTieredMachine.importItems,
+                                        simpleTieredMachine.exportItems,
+                                        simpleTieredMachine.importFluids, simpleTieredMachine.exportFluids,
+                                        simpleTieredMachine.recipeLogic::getProgressPercent,
+                                        0)
+                                .alignX(Alignment.CENTER))
+                        .coverChildrenHeight()
+                        // .left(7)
+                        .bottom(76 + 7 + 18 + 9))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(Flow.col()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(backgroundTexture.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(workableMachine, syncManager))
+                        .child(GTMuiWidgets.createBatterySlot(simpleTieredMachine, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputItems(),
+                                () -> GTMuiWidgets.createAutoOutputItemButton(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputFluids(),
+                                () -> GTMuiWidgets.createAutoOutputFluidButton(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputItems(),
+                                () -> GTMuiWidgets.createInputFromOutputItem(autoOutput, syncManager))
+                        .childIf(autoOutput != null && autoOutput.supportsAutoOutputFluids(),
+                                () -> GTMuiWidgets.createInputFromOutputFluid(autoOutput, syncManager)))
+                .child(Flow.col()
+                        .coverChildren()
+                        .rightRel(1.0f)
+                        .reverseLayout(true)
+                        .padding(0, 8, 4, 4)
+                        .bottom(16)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0f, 0f, 0.75f, 1.0f))
+                        .childIf(ghostCircuit,
+                                () -> GTMuiWidgets.createCircuitSlotPanel(simpleTieredMachine, panel, syncManager)))
+                .child(GTMuiWidgets.createGTLogo()
+                        .right(7).bottom(7 + 78));
+        if (hasXEI && false) {
+            panel.child(GTMuiWidgets.createXEIWidget(GTRecipeTypeUIs.recipeTypeUIs.get(workableMachine.getRecipeType()))
+                    .left(190));
+        }
+        panel.excludeAreaInRecipeViewer();
+        return panel;
+    };
+
+    public static PanelFactory STEAM_MACHINE = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                                MetaMachine machine) -> {
+        ModularPanel panel = new ModularPanel(machine.getDefinition().getName());
+        if (!(machine instanceof SimpleSteamMachine steamMachine)) {
+            GTCEu.LOGGER.error("{} is not a SimpleSteamMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return panel;
+        }
+        // panel.widgetTheme(GTGuiTheme.BRONZE.getId());
+
+        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);
+
+        panel.size(176, 76 + 21 + 18 + 9 + 18 * Math.max(2, slotHeight));
+
+        boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(steamMachine.getRecipeType());
+
+        var theme = machine.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
+
+        panel.child(GTMuiWidgets.createTitleBar(machine.getDefinition(), 176))
+                .child(Flow.row()
+                        .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(steamMachine.getRecipeType())
+                                .getBackedSlotsRow(syncManager, theme, steamMachine.importItems,
+                                        steamMachine.exportItems,
+                                        null, null,
+                                        steamMachine.recipeLogic::getProgressPercent,
+                                        steamMachine.getTier())
+                                .alignX(Alignment.CENTER))
+                        .coverChildrenHeight()
+                        // .left(7)
+                        .bottom(76 + 7 + 18 + 9))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(Flow.col()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(backgroundTexture.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(steamMachine, syncManager)))
+                .child(GTMuiWidgets.createGTLogo()
+                        .right(7).bottom(7 + 78));
+
+        return panel;
+    };
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/DrumMachineItem.java b/src/main/java/com/gregtechceu/gtceu/common/item/DrumMachineItem.java
similarity index 94%
rename from src/main/java/com/gregtechceu/gtceu/api/item/DrumMachineItem.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/DrumMachineItem.java
index c4dc9e6c6a5..17d5e7fd41d 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/DrumMachineItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/DrumMachineItem.java
@@ -1,9 +1,10 @@
-package com.gregtechceu.gtceu.api.item;
+package com.gregtechceu.gtceu.common.item;
 
 import com.gregtechceu.gtceu.api.block.MetaMachineBlock;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.FluidPipeProperties;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
+import com.gregtechceu.gtceu.api.item.MetaMachineItem;
 import com.gregtechceu.gtceu.api.misc.forge.ThermalFluidHandlerItemStack;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.common.data.machines.GTMachineUtils;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/FluidFilterBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/FluidFilterBehaviour.java
deleted file mode 100644
index e816afb4ccf..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/common/item/FluidFilterBehaviour.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package com.gregtechceu.gtceu.common.item;
-
-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 net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-
-import java.util.function.Function;
-
-public record FluidFilterBehaviour(Function<ItemStack, FluidFilter> filterCreator) implements IItemUIFactory {
-
-    @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));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/GTBoatItem.java b/src/main/java/com/gregtechceu/gtceu/common/item/GTBoatItem.java
index 945cc8a0098..3b3845b9e3e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/GTBoatItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/GTBoatItem.java
@@ -2,6 +2,7 @@
 
 import com.gregtechceu.gtceu.common.entity.GTBoat;
 import com.gregtechceu.gtceu.common.entity.GTChestBoat;
+import com.gregtechceu.gtceu.common.item.behavior.GTBoatItemDispenseBehaviour;
 
 import net.minecraft.stats.Stats;
 import net.minecraft.world.InteractionHand;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/GTBucketItem.java b/src/main/java/com/gregtechceu/gtceu/common/item/GTBucketItem.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/api/item/GTBucketItem.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/GTBucketItem.java
index 510a7348163..01d7375ab4d 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/GTBucketItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/GTBucketItem.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.api.item;
+package com.gregtechceu.gtceu.common.item;
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/IntCircuitBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/IntCircuitBehaviour.java
deleted file mode 100644
index 5661008cfa5..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/common/item/IntCircuitBehaviour.java
+++ /dev/null
@@ -1,159 +0,0 @@
-package com.gregtechceu.gtceu.common.item;
-
-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.common.data.GTItems;
-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 org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-
-public class IntCircuitBehaviour implements IItemUIFactory, IAddInformation {
-
-    public static final int CIRCUIT_MAX = 32;
-
-    public static ItemStack stack(int configuration) {
-        var stack = GTItems.PROGRAMMED_CIRCUIT.asStack();
-        setCircuitConfiguration(stack, 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!");
-        var tagCompound = itemStack.getOrCreateTag();
-        tagCompound.putInt("Configuration", configuration);
-    }
-
-    public static int getCircuitConfiguration(ItemStack itemStack) {
-        if (!isIntegratedCircuit(itemStack)) return 0;
-        var tagCompound = itemStack.getTag();
-        if (tagCompound != null) {
-            return tagCompound.getInt("Configuration");
-        }
-        return 0;
-    }
-
-    public static boolean isIntegratedCircuit(ItemStack itemStack) {
-        boolean isCircuit = GTItems.PROGRAMMED_CIRCUIT.isIn(itemStack);
-        if (isCircuit && !itemStack.hasTag()) {
-            var compound = new CompoundTag();
-            compound.putInt("Configuration", 0);
-            itemStack.setTag(compound);
-        }
-        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) {
-        int configuration = getCircuitConfiguration(stack);
-        tooltipComponents.add(Component.translatable("metaitem.int_circuit.configuration", configuration));
-    }
-
-    @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;
-    }
-
-    @Override
-    public InteractionResult useOn(UseOnContext context) {
-        var stack = context.getItemInHand();
-        int circuitSetting = getCircuitConfiguration(stack);
-        BlockEntity entity = context.getLevel().getBlockEntity(context.getClickedPos());
-        if (entity instanceof MetaMachine machine && context.isSecondaryUseActive()) {
-            if (machine instanceof IHasCircuitSlot circuitMachine &&
-                    circuitMachine.getCircuitInventory().getSlots() > 0) {
-                setCircuitConfig(circuitMachine.getCircuitInventory(), 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));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ItemFilterBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/ItemFilterBehaviour.java
deleted file mode 100644
index aac74875106..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ItemFilterBehaviour.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package com.gregtechceu.gtceu.common.item;
-
-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 net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-
-import java.util.function.Function;
-
-public record ItemFilterBehaviour(Function<ItemStack, ItemFilter> filterCreator) implements IItemUIFactory {
-
-    @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));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/LampBlockItem.java b/src/main/java/com/gregtechceu/gtceu/common/item/LampBlockItem.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/api/item/LampBlockItem.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/LampBlockItem.java
index edb5174a25a..c1e59d991b2 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/LampBlockItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/LampBlockItem.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.api.item;
+package com.gregtechceu.gtceu.common.item;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.client.renderer.block.LampItemRenderer;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/LaserPipeBlockItem.java b/src/main/java/com/gregtechceu/gtceu/common/item/LaserPipeBlockItem.java
similarity index 91%
rename from src/main/java/com/gregtechceu/gtceu/api/item/LaserPipeBlockItem.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/LaserPipeBlockItem.java
index 3f34616dc3c..9a0629b52be 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/LaserPipeBlockItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/LaserPipeBlockItem.java
@@ -1,6 +1,7 @@
-package com.gregtechceu.gtceu.api.item;
+package com.gregtechceu.gtceu.common.item;
 
 import com.gregtechceu.gtceu.api.block.PipeBlock;
+import com.gregtechceu.gtceu.api.item.PipeBlockItem;
 import com.gregtechceu.gtceu.common.block.LaserPipeBlock;
 
 import net.minecraft.client.color.item.ItemColor;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/QuantumTankMachineItem.java b/src/main/java/com/gregtechceu/gtceu/common/item/QuantumTankMachineItem.java
similarity index 92%
rename from src/main/java/com/gregtechceu/gtceu/api/item/QuantumTankMachineItem.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/QuantumTankMachineItem.java
index 65a6b1df1dd..b5ce32473af 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/QuantumTankMachineItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/QuantumTankMachineItem.java
@@ -1,7 +1,8 @@
-package com.gregtechceu.gtceu.api.item;
+package com.gregtechceu.gtceu.common.item;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.block.MetaMachineBlock;
+import com.gregtechceu.gtceu.api.item.MetaMachineItem;
 import com.gregtechceu.gtceu.api.misc.forge.QuantumFluidHandlerItemStack;
 import com.gregtechceu.gtceu.common.machine.storage.QuantumTankMachine;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/AntidoteBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/AntidoteBehavior.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/AntidoteBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/AntidoteBehavior.java
index fa9729751e0..3046608a508 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/AntidoteBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/AntidoteBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IMedicalConditionTracker;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ColorSprayBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ColorSprayBehaviour.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/ColorSprayBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/ColorSprayBehaviour.java
index e20d2c282cb..97e3470d53b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ColorSprayBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ColorSprayBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.blockentity.IPaintable;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ConsumedBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ConsumedBehaviour.java
similarity index 96%
rename from src/main/java/com/gregtechceu/gtceu/common/item/ConsumedBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/ConsumedBehaviour.java
index feca36f1270..35c04941bdb 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ConsumedBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ConsumedBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/CoverPlaceBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/CoverPlaceBehavior.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/CoverPlaceBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/CoverPlaceBehavior.java
index 320bd4bc140..57aee262726 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/CoverPlaceBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/CoverPlaceBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/DataItemBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/DataItemBehavior.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/DataItemBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/DataItemBehavior.java
index 047f36f7484..58a3e79039d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/DataItemBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/DataItemBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/DynamiteBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/DynamiteBehaviour.java
similarity index 97%
rename from src/main/java/com/gregtechceu/gtceu/common/item/DynamiteBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/DynamiteBehaviour.java
index f4bcff20550..0118e81f790 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/DynamiteBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/DynamiteBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
 import com.gregtechceu.gtceu.common.entity.DynamiteEntity;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/FacadeItemBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FacadeItemBehaviour.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/FacadeItemBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/FacadeItemBehaviour.java
index c4c27d6380c..4a5a4f38df9 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/FacadeItemBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FacadeItemBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.ICustomDescriptionId;
 import com.gregtechceu.gtceu.api.item.component.ISubItemHandler;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/FertilizerBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FertilizerBehavior.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/FertilizerBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/FertilizerBehavior.java
index 3d44f33e50e..612fc336e33 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/FertilizerBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FertilizerBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
 
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
new file mode 100644
index 00000000000..6c30d858113
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FluidFilterBehaviour.java
@@ -0,0 +1,42 @@
+package com.gregtechceu.gtceu.common.item.behavior;
+
+import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
+import com.gregtechceu.gtceu.api.mui.base.IItemUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.factory.UIFactories;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
+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 java.util.function.Function;
+
+public record FluidFilterBehaviour(Function<ItemStack, FluidFilter> filterCreator) implements IItemUIHolder {
+
+    @Override
+    public void onAttached(Item item) {
+        FluidFilter.FILTERS.put(item, filterCreator);
+    }
+
+    @Override
+    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/GTBoatItemDispenseBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/GTBoatItemDispenseBehaviour.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/GTBoatItemDispenseBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/GTBoatItemDispenseBehaviour.java
index edad3734666..d0451fb09fd 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/GTBoatItemDispenseBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/GTBoatItemDispenseBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.common.entity.GTBoat;
 import com.gregtechceu.gtceu.common.entity.GTChestBoat;
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
new file mode 100644
index 00000000000..112b69f65a1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/IntCircuitBehaviour.java
@@ -0,0 +1,73 @@
+package com.gregtechceu.gtceu.common.item.behavior;
+
+import com.gregtechceu.gtceu.api.item.component.IAddInformation;
+import com.gregtechceu.gtceu.api.mui.base.IItemUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+
+import net.minecraft.nbt.CompoundTag;
+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 org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class IntCircuitBehaviour implements IAddInformation, IItemUIHolder {
+
+    public static final int CIRCUIT_MAX = 32;
+
+    public static ItemStack stack(int configuration) {
+        return stack(configuration, 1);
+    }
+
+    public static ItemStack stack(int configuration, int count) {
+        var stack = GTItems.PROGRAMMED_CIRCUIT.asStack(count);
+        setCircuitConfiguration(stack, configuration);
+        return stack;
+    }
+
+    public static void setCircuitConfiguration(ItemStack itemStack, int configuration) {
+        if (configuration < 0 || configuration > CIRCUIT_MAX)
+            throw new IllegalArgumentException("Given configuration number is out of range!");
+        var tagCompound = itemStack.getOrCreateTag();
+        tagCompound.putInt("Configuration", configuration);
+    }
+
+    public static int getCircuitConfiguration(ItemStack itemStack) {
+        if (!isIntegratedCircuit(itemStack)) return 0;
+        var tagCompound = itemStack.getTag();
+        if (tagCompound != null) {
+            return tagCompound.getInt("Configuration");
+        }
+        return 0;
+    }
+
+    public static boolean isIntegratedCircuit(ItemStack itemStack) {
+        boolean isCircuit = GTItems.PROGRAMMED_CIRCUIT.isIn(itemStack);
+        if (isCircuit && !itemStack.hasTag()) {
+            var compound = new CompoundTag();
+            compound.putInt("Configuration", 0);
+            itemStack.setTag(compound);
+        }
+        return isCircuit;
+    }
+
+    @Override
+    public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltipComponents,
+                                TooltipFlag isAdvanced) {
+        int configuration = getCircuitConfiguration(stack);
+        tooltipComponents.add(Component.translatable("metaitem.int_circuit.configuration", configuration));
+    }
+
+    @Override
+    public ModularPanel buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        return GTMuiWidgets.createCircuitSlotPanel(data::setUsedItemStack, data::getUsedItemStack, syncManager);
+    }
+}
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
new file mode 100644
index 00000000000..e430d081f2c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFilterBehaviour.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.common.item.behavior;
+
+import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
+import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
+import com.gregtechceu.gtceu.api.mui.base.IItemUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.factory.UIFactories;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+
+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 java.util.function.Function;
+
+public record ItemFilterBehaviour(Function<ItemStack, ItemFilter> filterCreator)
+        implements IInteractionItem, IItemUIHolder {
+
+    @Override
+    public void onAttached(Item item) {
+        ItemFilter.FILTERS.put(item, filterCreator);
+    }
+
+    @Override
+    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/ItemFluidContainer.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFluidContainer.java
similarity index 93%
rename from src/main/java/com/gregtechceu/gtceu/common/item/ItemFluidContainer.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFluidContainer.java
index f75a70ca6a4..1e309e069b4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ItemFluidContainer.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFluidContainer.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IRecipeRemainder;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ItemMagnetBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/ItemMagnetBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java
index 4002ff888c5..c0af0800eec 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ItemMagnetBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTValues;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/LighterBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/LighterBehavior.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/LighterBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/LighterBehavior.java
index 72e07cc5c39..bf60c8214ab 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/LighterBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/LighterBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item.tool.behavior;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
 import com.gregtechceu.gtceu.api.item.component.IDurabilityBar;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/MachineConfigCopyBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/MachineConfigCopyBehaviour.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/MachineConfigCopyBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/MachineConfigCopyBehaviour.java
index 88434f8236d..64776f5f582 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/MachineConfigCopyBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/MachineConfigCopyBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item.tool.behavior;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
@@ -6,7 +6,6 @@
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.feature.*;
 import com.gregtechceu.gtceu.api.machine.trait.AutoOutputTrait;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.common.machine.owner.MachineOwner;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/NanoSaberBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/NanoSaberBehavior.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/NanoSaberBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/NanoSaberBehavior.java
index c2fa9cbf5ef..37ed298b630 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/NanoSaberBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/NanoSaberBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.item.component.IEnchantableItem;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/PortableScannerBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/PortableScannerBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java
index b23654b2d24..fa7cc09023a 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/PortableScannerBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java
@@ -1,10 +1,10 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.block.property.GTBlockStateProperties;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
 import com.gregtechceu.gtceu.api.capability.*;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockfluid.BedrockFluidVeinSavedData;
 import com.gregtechceu.gtceu.api.gui.misc.ProspectorMode;
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ProspectorScannerBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ProspectorScannerBehavior.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/common/item/ProspectorScannerBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/ProspectorScannerBehavior.java
index f0a393bd457..33de34a5288 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ProspectorScannerBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ProspectorScannerBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IElectricItem;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/TapeBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TapeBehaviour.java
similarity index 90%
rename from src/main/java/com/gregtechceu/gtceu/common/item/TapeBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/TapeBehaviour.java
index af76b0a04c7..917e77f04c8 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/TapeBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TapeBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/TerminalBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TerminalBehavior.java
similarity index 97%
rename from src/main/java/com/gregtechceu/gtceu/common/item/TerminalBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/TerminalBehavior.java
index 2402ee1113d..e761841727f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/TerminalBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TerminalBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ToggleEnergyConsumerBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ToggleEnergyConsumerBehavior.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/ToggleEnergyConsumerBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/ToggleEnergyConsumerBehavior.java
index 90d0d1ad649..3bde4751251 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/ToggleEnergyConsumerBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ToggleEnergyConsumerBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IElectricItem;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/TooltipBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TooltipBehavior.java
similarity index 94%
rename from src/main/java/com/gregtechceu/gtceu/common/item/TooltipBehavior.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/TooltipBehavior.java
index df6d1faec04..00c1b336582 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/TooltipBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TooltipBehavior.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/TurbineRotorBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TurbineRotorBehaviour.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/common/item/TurbineRotorBehaviour.java
rename to src/main/java/com/gregtechceu/gtceu/common/item/behavior/TurbineRotorBehaviour.java
index 482519ee168..24d2a6a2e03 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/TurbineRotorBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/TurbineRotorBehaviour.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.common.item;
+package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.GTCEuAPI;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
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..7a8f39bfc6a
--- /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.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+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 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..c6c023844b6 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,53 @@
 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.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
 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 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)
+                                .align(Alignment.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)))
+                                        .align(Alignment.CENTER)
+                                        .widthRel(.8f))));
     }
 
     @Override
@@ -53,4 +62,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 beb0f1289f3..e276c58534d 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,8 +1,9 @@
 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.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
 import com.gregtechceu.gtceu.api.placeholder.MultiLineComponent;
 import com.gregtechceu.gtceu.api.placeholder.PlaceholderContext;
 import com.gregtechceu.gtceu.api.placeholder.PlaceholderHandler;
@@ -10,46 +11,25 @@
 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 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()),
@@ -57,74 +37,48 @@ private PlaceholderContext makeContext(ItemStack stack, CentralMonitorMachine ma
                 group.getPlaceholderSlotsHandler(),
                 group.getTargetCover(machine.getLevel()),
                 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
@@ -137,6 +91,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);
     }
 
@@ -144,6 +100,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..45f38348bf9 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,17 +1,23 @@
 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.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.InteractionSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
-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 org.jetbrains.annotations.NotNull;
 
@@ -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(GTGuiTextures.MC_BUTTON,
+                                                        GTGuiTextures.REMOVE.asIcon().size(10))
+                                                .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED,
+                                                        GTGuiTextures.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(GTGuiTextures.MC_BUTTON,
+                                                        GTGuiTextures.ADD.asIcon().size(10))
+                                                .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED,
+                                                        GTGuiTextures.ADD.asIcon().size(10))
+                                                .syncHandler(plusCols)))
+                                .child(Flow.row()
+                                        .coverChildren()
+                                        .childPadding(2)
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GTGuiTextures.MC_BUTTON,
+                                                        GTGuiTextures.REMOVE.asIcon().size(10))
+                                                .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED,
+                                                        GTGuiTextures.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(GTGuiTextures.MC_BUTTON,
+                                                        GTGuiTextures.ADD.asIcon().size(10))
+                                                .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED,
+                                                        GTGuiTextures.ADD.asIcon().size(10))
+                                                .syncHandler(plusRows)))
+                                .child(Flow.row()
+                                        .coverChildren()
+                                        .childPadding(2)
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GTGuiTextures.MC_BUTTON,
+                                                        GTGuiTextures.REMOVE.asIcon().size(10))
+                                                .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED,
+                                                        GTGuiTextures.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(GTGuiTextures.MC_BUTTON,
+                                                        GTGuiTextures.ADD.asIcon().size(10))
+                                                .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED,
+                                                        GTGuiTextures.ADD.asIcon().size(10))
+                                                .syncHandler(plusLayers)))));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/AirScrubberMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/AirScrubberMachine.java
index 2b4458f88e3..ecdbbc256b5 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/AirScrubberMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/AirScrubberMachine.java
@@ -1,48 +1,36 @@
 package com.gregtechceu.gtceu.common.machine.electric;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
 import com.gregtechceu.gtceu.api.machine.SimpleTieredMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardCleaner;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardCleanerTrait;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
-import com.gregtechceu.gtceu.common.blockentity.DuctPipeBlockEntity;
-import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
 import com.gregtechceu.gtceu.common.data.machines.GTMachineUtils;
-import com.gregtechceu.gtceu.common.network.GTNetwork;
-import com.gregtechceu.gtceu.common.network.packets.hazard.SPacketRemoveHazardZone;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.builder.GTRecipeBuilder;
-import com.gregtechceu.gtceu.utils.GTUtil;
 
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.util.Mth;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.LevelChunk;
-
-import it.unimi.dsi.fastutil.objects.Object2FloatMap;
-import it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
 import static com.gregtechceu.gtceu.api.GTValues.LV;
 import static com.gregtechceu.gtceu.api.GTValues.VHA;
 
-public class AirScrubberMachine extends SimpleTieredMachine implements IEnvironmentalHazardCleaner {
+public class AirScrubberMachine extends SimpleTieredMachine {
 
     public static final float MIN_CLEANING_PER_OPERATION = 10;
 
-    private float cleaningPerOperation;
+    private MedicalCondition currentRecipeMedicalCondition;
 
     @Getter
     private float removedLastSecond;
 
+    @Getter
+    private final EnvironmentalHazardCleanerTrait cleanerTrait;
+
     public AirScrubberMachine(BlockEntityCreationInfo info, int tier) {
         super(info, tier, GTMachineUtils.largeTankSizeFunction);
-        this.cleaningPerOperation = MIN_CLEANING_PER_OPERATION;
+        this.cleanerTrait = new EnvironmentalHazardCleanerTrait(this, tier / 2, this::validateCleaningOperation);
     }
 
     @Override
@@ -50,16 +38,17 @@ public boolean regressWhenWaiting() {
         return false;
     }
 
-    @Override
-    public void cleanHazard(MedicalCondition condition, float amount) {
+    public boolean validateCleaningOperation(MedicalCondition condition, float amount) {
         if (this.recipeLogic.isActive()) {
-            return;
+            return false;
         }
 
+        currentRecipeMedicalCondition = condition;
+
         GTRecipeBuilder builder = GTRecipeTypes.AIR_SCRUBBER_RECIPES.recipeBuilder(condition.name + "_autogen")
                 .duration(200).EUt(VHA[LV]);
         condition.recipeModifier.accept(builder);
-        this.recipeLogic.checkMatchedRecipeAvailable(builder.buildRawRecipe());
+        return this.recipeLogic.checkMatchedRecipeAvailable(builder.buildRawRecipe());
     }
 
     @Override
@@ -72,8 +61,8 @@ public boolean isRecipeLogicAvailable() {
     public boolean beforeWorking(@Nullable GTRecipe recipe) {
         if (super.beforeWorking(recipe) && recipe != null) {
             // Sets the amount of hazard to clean based on the recipe tier, not the machine tier
-            this.cleaningPerOperation = MIN_CLEANING_PER_OPERATION * (recipe.ocLevel + 1);
-            return true;
+            return cleanerTrait.beginCleaningOperation(currentRecipeMedicalCondition,
+                    MIN_CLEANING_PER_OPERATION * (recipe.ocLevel + 1));
         }
         return false;
     }
@@ -83,57 +72,12 @@ public boolean onWorking() {
         if (!super.onWorking() || !ConfigHolder.INSTANCE.gameplay.environmentalHazards) {
             return false;
         }
-
-        if (getOffsetTimer() % 20 == 0) {
-            removedLastSecond = 0;
-
-            for (Direction dir : GTUtil.DIRECTIONS) {
-                BlockPos offset = getBlockPos().relative(dir);
-                if (GTCapabilityHelper.getHazardContainer(getLevel(), offset, dir.getOpposite()) != null) {
-                    if (getLevel().getBlockEntity(offset) instanceof DuctPipeBlockEntity duct &&
-                            !duct.isConnected(dir.getOpposite())) {
-                        continue;
-                    }
-                    return true;
-                }
-            }
-
-            final ServerLevel serverLevel = (ServerLevel) getLevel();
-            EnvironmentalHazardSavedData savedData = EnvironmentalHazardSavedData.getOrCreate(serverLevel);
-
-            final ChunkPos pos = new ChunkPos(getBlockPos());
-            Object2FloatMap<ChunkPos> relativePositions = new Object2FloatOpenHashMap<>();
-            int radius = tier / 2;
-            if (radius <= 0) {
-                // LV scrubber can only process the chunk it's in
-                relativePositions.put(pos, 1);
-            } else {
-                for (int x = -radius; x <= radius; ++x) {
-                    for (int z = -radius; z <= radius; ++z) {
-                        relativePositions.put(new ChunkPos(pos.x + x, pos.z + z), Mth.sqrt(Mth.abs(x * z)) + 1);
-                    }
-                }
-            }
-            for (ChunkPos rel : relativePositions.keySet()) {
-                final float distance = relativePositions.getFloat(rel);
-                savedData.getHazardZones().compute(rel, (chunkPos, zone) -> {
-                    if (zone == null || zone.strength() <= 0) {
-                        return null;
-                    }
-
-                    float toClean = cleaningPerOperation / distance;
-                    removedLastSecond += toClean;
-                    zone.removeStrength(toClean);
-                    if (zone.strength() <= 0) {
-                        if (serverLevel.hasChunk(chunkPos.x, chunkPos.z)) {
-                            LevelChunk chunk = serverLevel.getChunk(chunkPos.x, chunkPos.z);
-                            GTNetwork.sendToAllPlayersTrackingChunk(chunk, new SPacketRemoveHazardZone(chunkPos));
-                        }
-                        return null;
-                    } else return zone;
-                });
-            }
-        }
+        cleanerTrait.cleanHazard();
         return true;
     }
+
+    @Override
+    public void afterWorking() {
+        cleanerTrait.endCleaningOperation();
+    }
 }
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 579b251e1df..58de690b620 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,24 +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.trait.NotifiableEnergyContainer;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraftforge.energy.IEnergyStorage;
 
 import lombok.Getter;
@@ -39,7 +46,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class BatteryBufferMachine extends TieredEnergyMachine
-                                  implements IControllable, IFancyUIMachine, IMonitorComponent {
+                                  implements IControllable, IMonitorComponent, IMuiMachine {
 
     public static final long AMPS_PER_BATTERY = 2L;
 
@@ -91,40 +98,59 @@ 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 ModularPanel buildUI(PosGuiData data, 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));
+
+        return new ModularPanel("battery_buffer")
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 172))
+                .child(Flow.row()
+                        .height(90)
+                        .margin(6)
+                        .marginLeft(7)
+                        .marginTop(2)
+                        .height(80)
+                        .child(new ProgressWidget()
+                                .texture(GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_STEEL,
+                                        GTGuiTextures.PROGRESS_BAR_BOILER_HEAT, 60)
+                                .direction(ProgressWidget.Direction.UP)
+                                .value(energyPercentage)
+                                .marginRight(50)
+                                .size(18, 60)
+                                .verticalCenter()
+                                .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()))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .excludeAreaInRecipeViewer()
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled,
+                                syncManager)))
+                .bindPlayerInventory();
+    }
 
-        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();
     }
 
     //////////////////////////////////////
@@ -196,8 +222,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 {
@@ -262,7 +288,7 @@ public void serverTick() {
                 }
 
                 if (changed) {
-                    machine.markAsDirty();
+                    machine.markAsChanged();
                     checkOutputSubscription();
                 }
 
@@ -321,7 +347,7 @@ public long acceptEnergyFromNetwork(@Nullable Direction side, long voltage, long
                 }
 
                 if (changed) {
-                    machine.markAsDirty();
+                    machine.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 a507abd0720..9bdfeca8425 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,32 @@
 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.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.trait.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -41,14 +42,13 @@
 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 {
 
     @SaveField
     protected final NotifiableItemStackHandler cache;
@@ -273,77 +273,116 @@ 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]));
-        });
+    /*
+     * 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        ModularPanel panel = new ModularPanel(this.getDefinition().getName());
+        var slotHeight = (int) Math.sqrt(inventorySize);
+        panel
+                .size(176, 104 + 18 * slotHeight)
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 190))
+                .child(new Column()
+                        .coverChildren()
+                        .child(GTMuiMachineUtil.createSquareSlotGroupFromInventory(this.cache, "output_cache",
+                                syncManager))
+                        .alignX(Alignment.CENTER)
+                        .top(10))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled,
+                                syncManager))
+                        .child(createBatterySlot(syncManager))
+                        .child(GTMuiWidgets.createAutoOutputItemButton(autoOutput, syncManager))
+                        .excludeAreaInRecipeViewer());
+        return panel;
     }
 
-    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);
-                }
-            });
-        });
+    public ItemSlot createBatterySlot(PanelSyncManager syncManager) {
+        ItemSlotSyncHandler battery = new ItemSlotSyncHandler(new ModularSlot(this.chargerInventory, 0));
+        syncManager.syncValue("battery", battery);
+        return new ItemSlot().syncHandler("battery").background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY);
     }
 }
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 d7d8dd37ead..22adb67719f 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,26 +4,33 @@
 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.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableEnergyContainer;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.level.block.state.properties.EnumProperty;
 import net.minecraftforge.energy.IEnergyStorage;
@@ -39,7 +46,7 @@
 
 @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;
 
@@ -120,39 +127,55 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        String[] matrix = GTMuiMachineUtil.createSquareMatrix(inventorySize, 'B');
+
+        DoubleSyncValue energyPercentage = syncManager.getOrCreateSyncHandler("energyPercentage", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(this::getEnergyPercentage));
+
+        return new ModularPanel(getDefinition().getName())
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 172))
+                .child(Flow.row()
+                        .height(90)
+                        .margin(6)
+                        .marginLeft(7)
+                        .marginTop(2)
+                        .height(80)
+                        .child(new ProgressWidget()
+                                .texture(GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_STEEL,
+                                        GTGuiTextures.PROGRESS_BAR_BOILER_HEAT, 60)
+                                .direction(ProgressWidget.Direction.UP)
+                                .value(energyPercentage)
+                                .marginRight(50)
+                                .size(18, 60)
+                                .verticalCenter()
+                                .addTooltipLine(IKey.dynamic(() -> Component.literal(
+                                        "%s/%s EU".formatted(
+                                                GTStringUtils.formatInt(energyContainer.getEnergyStored()),
+                                                GTStringUtils.formatInt(energyContainer.getEnergyCapacity()))))))
+                        .child(GTMuiMachineUtil.createSlotGroupFromInventory(
+                                chargerInventory, "charger_inv",
+                                inventorySize, 'B',
+                                slot -> slot.background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY),
+                                syncManager,
+                                matrix)
+                                .center()))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .excludeAreaInRecipeViewer()
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled,
+                                syncManager)))
+                .bindPlayerInventory();
+    }
 
-        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();
     }
 
     //////////////////////////////////////
@@ -252,7 +275,7 @@ public long acceptEnergyFromNetwork(@Nullable Direction side, long voltage, long
                 }
 
                 if (changed) {
-                    machine.markAsDirty();
+                    machine.markAsChanged();
                     machine.changeState(State.RUNNING);
                 }
 
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 6f2cf812f04..2957e91b9c0 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,13 +3,12 @@
 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.api.mui.drawable.UITexture;
 import com.gregtechceu.gtceu.common.machine.trait.ConverterTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -96,10 +95,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 08396e77709..94414d99ea3 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,43 @@
 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.trait.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.network.chat.Component;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.projectile.FishingHook;
@@ -50,14 +59,12 @@
 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;
@@ -284,111 +291,142 @@ 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]));
-        });
-    }
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        ModularPanel panel = new ModularPanel(getDefinition().getName());
 
-    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]));
-        });
-    }
+        var outputItemGrid = GTMuiWidgets.createGrid(cache.getSize(), (int) Math.sqrt(cache.getSize()), true, 'i');
 
-    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);
-                }
-            }
+        int inputWidth = 18;
+        int outputWidth = 18 * outputItemGrid.length;
 
-            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);
-            });
-        });
+        int slotHeight = outputItemGrid.length;
+
+        int topMargin = 0;
+        if (slotHeight == 2) {
+            topMargin = 9;
+        } else if (slotHeight > 2) {
+            topMargin = 18;
+        }
+
+        // input slots + centering gap + output slots
+
+        /**
+         * 1 -> 1.5
+         * 2 -> 1
+         * 3 -> .5
+         * 36 - (inputWidth / 2)
+         *
+         * 1:1 -> 18 + 18 + 36
+         * 1:2 -> 18 + 36 + 27
+         * 1:3 -> 18 + 54 + 3
+         * 2 - input + 2 - output
+         */
+        int fullWidth = (inputWidth + outputWidth) + (77 - ((inputWidth + outputWidth) / 2));
+
+        int inputShift = switch (tier) {
+            case 1 -> 27;
+            case 2 -> 27;
+            case 3 -> 18;
+            case 4 -> 0;
+            case 5 -> 0;
+            case 6 -> -2;
+            default -> 0;
+        };
+
+        int padding = switch (tier) {
+            case 1 -> 10;
+            case 2 -> 7;
+            case 3 -> 7;
+            case 4 -> 10;
+            case 5 -> 5;
+            case 6 -> 2;
+            default -> 2;
+        };
+
+        BooleanSyncValue power = new BooleanSyncValue(() -> active,
+                (b) -> active = b);
+        syncManager.syncValue("working_enabled", power);
+
+        ItemSlotSyncHandler battery = new ItemSlotSyncHandler(new ModularSlot(getChargerInventory(), 0));
+        syncManager.syncValue("battery", battery);
+
+        panel.size(176, 124 + Math.max(36, 18 * slotHeight));
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> progress / (double) maxProgress));
+
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 176, GTGuiTextures.BACKGROUND))
+                .child(new Row()
+                        .coverChildrenHeight()
+                        .width(fullWidth + 16 - inputShift)
+                        .left(7 + inputShift)
+                        .childPadding(padding)
+                        .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                        .child(new Column()
+                                .coverChildrenWidth()
+                                .mainAxisAlignment(Alignment.MainAxis.CENTER)
+                                .child(new ItemSlot().slot(new ModularSlot(baitHandler, 0))
+                                        .background(GTGuiTextures.SLOT, GTGuiTextures.STRING_SLOT_OVERLAY)))
+                        .child(new ProgressWidget()
+                                .alignY(Alignment.Center)
+                                .texture(GTGuiTextures.PROGRESS_BAR_ARROW, 16)
+                                .value(progressPercent))
+                        .child(new Column()
+                                .coverChildrenWidth()
+                                .mainAxisAlignment(Alignment.MainAxis.CENTER)
+                                .childIf(!(outputItemGrid.length == 0),
+                                        () -> GTMuiMachineUtil.createSlotGroupFromInventory(cache,
+                                                "output_item_inv", cache.getSize(), 'i',
+                                                syncManager, outputItemGrid)
+                                                .alignX(Alignment.CenterRight))
+                                .align(Alignment.CenterRight))
+                        .top(30 - topMargin))
+
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(new ToggleButton()
+                                .value(new BoolValue.Dynamic(power::getBoolValue, power::setBoolValue))
+                                .selectedBackground(GTGuiTextures.BUTTON_POWER[1])
+                                .background(GTGuiTextures.BUTTON_POWER[0])
+                                .tooltipAutoUpdate(true)
+                                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable(
+                                        active ? "behaviour.soft_hammer.enabled" :
+                                                "behaviour.soft_hammer.disabled")))))
+                        .child(new ItemSlot().syncHandler("battery").background(GTGuiTextures.SLOT,
+                                GTGuiTextures.CHARGER_OVERLAY))
+                        .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);
+                                    }
+                                })))
+                /*
+                 * .child(new Column()
+                 * .coverChildren()
+                 * .rightRel(1.0f)
+                 * .reverseLayout(true)
+                 * .padding(0, 8, 4, 4)
+                 * .bottom(16)
+                 * .background(GTGuiTextures.BACKGROUND.getSubArea(0f, 0f, 0.75f, 1.0f))
+                 * .childIf(ghostCircuit,
+                 * GTMuiWidgets.createCircuitSlotPanel(simpleTieredMachine, panel, syncManager)))
+                 */
+                .child(GTMuiWidgets.createGTLogo()
+                        .right(7).bottom(7 + 78));
+
+        return panel;
     }
 }
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 5eac4c89cb2..090339f3950 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,16 +4,15 @@
 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.mui.base.drawable.IDrawable;
 import com.gregtechceu.gtceu.api.sync_system.ClassSyncData;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.data_transformers.ValueTransformer;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -121,7 +120,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 GTGuiTextures.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 94949b1816a..c905ff8d5cb 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,40 +1,41 @@
 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.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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;
@@ -48,14 +49,13 @@
 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 };
@@ -308,102 +308,50 @@ public void setWorkingEnabled(boolean workingEnabled) {
     }
 
     //////////////////////////////////////
-    // ********** GUI ***********//
+    // ******* Rendering ********//
     //////////////////////////////////////
-
-    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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return new ModularPanel(getDefinition().getName())
+                .height(220)
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 174))
+                .bindPlayerInventory()
+                .child(Flow.column()
+                        .coverChildrenHeight()
+                        .widthRel(1)
+                        .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())))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .excludeAreaInRecipeViewer()
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled,
+                                syncManager))
+                        .child(GTMuiWidgets.createBatterySlot(getChargerInventory(), 0, syncManager))
+                        .child(GTMuiWidgets.createAutoOutputItemButton(this.autoOutput, syncManager)));
     }
 }
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 a2bb710eaf2..4440ed17fc4 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,38 +5,36 @@
 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.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.PortableScannerBehavior;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.trait.miner.MinerLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.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.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -50,14 +48,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
@@ -145,107 +142,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(@NotNull List<Component> textList) {
+    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")
@@ -313,4 +218,46 @@ public List<Component> getDataInfo(PortableScannerBehavior.DisplayMode mode) {
         }
         return new ArrayList<>();
     }
+
+    // TODO(Onion): fix the gui stuff for this
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return new ModularPanel(getDefinition().getName())
+                .width(220)
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 220))
+                .bindPlayerInventory()
+                .child(Flow.row()
+                        .coverChildrenHeight()
+                        .margin(5)
+                        .childPadding(5)
+                        .widthRel(1f)
+                        .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)))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .excludeAreaInRecipeViewer()
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled,
+                                syncManager))
+                        .child(GTMuiWidgets.createBatterySlot(getChargerInventory(), 0, syncManager))
+                        .child(GTMuiWidgets.createAutoOutputItemButton(this.autoOutput, 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 49894373849..a52179fd6e0 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,36 @@
 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.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
-
-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.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+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;
@@ -53,7 +59,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;
@@ -74,8 +80,8 @@ public PumpMachine(BlockEntityCreationInfo info, int tier) {
         super(info, tier);
         this.cache = new NotifiableFluidTank(this, 1, 16 * FluidType.BUCKET_VOLUME * Math.max(1, getTier()), IO.NONE,
                 IO.OUT);
-        environmentalExplosionTrait.setEnableEnvironmentalExplosions(false);
         this.autoOutput = AutoOutputTrait.ofFluids(this, cache);
+        environmentalExplosionTrait.setEnableEnvironmentalExplosions(false);
     }
 
     //////////////////////////////////////
@@ -529,21 +535,47 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        IntSyncValue bucketSyncer = new IntSyncValue(() -> cache.getFluidInTank(0).getAmount(), (ignored) -> {});
+        syncManager.syncValue("bucket_amount", bucketSyncer);
+
+        return new ModularPanel(this.getDefinition().getName())
+                .child(
+                        // Top half of the screen
+                        new ParentWidget<>()
+                                .widthRel(1)
+                                .height(20 + 60)
+                                // Box that has the display texture BG +
+                                // the buttons / text / etc
+                                .child(new ParentWidget<>()
+                                        .background(GTGuiTextures.DISPLAY)
+                                        .size(90, 63)
+                                        .align(Alignment.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,
+                                                        syncManager)))
+                                        .child(Flow.column()
+                                                .margin(68, 0, 23, 0)
+                                                .coverChildren()
+                                                .child(createFluidSlot(syncManager)))))
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 176, GTGuiTextures.BACKGROUND))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+    }
+
+    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 4828888116c..14b77a88f4e 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,21 +5,20 @@
 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;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableEnergyContainer;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
 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.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -223,10 +222,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..11bebc88145
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine.java
@@ -0,0 +1,741 @@
+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.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.*;
+import com.gregtechceu.gtceu.api.mui.drawable.text.AnimatedText;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.schema.ArraySchema;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.Interpolation;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.IntValue;
+import com.gregtechceu.gtceu.api.mui.value.StringValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.widget.EmptyWidget;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.*;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.*;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.client.mui.schemarenderer.BlockHighlight;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+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 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 ModularPanel buildUI(PosGuiData data, 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(data.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 new Column()
+                            .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(colorPickerBackground::color, colorPickerBackground.getColor(), true)
+                         .setDraggable(true)
+                         .relative(panel)
+                         .top(0)
+                         .rightRel(1f),
+                true);
+        PagedWidget.Controller tabController = new PagedWidget.Controller();
+        panel.resizer()                        // returns object which is responsible for sizing
+                .size(176, 220)       // set a static size for the main panel
+                .align(Alignment.Center);    // center the panel in the screen
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class, () ->
+                new DoubleSyncValue(() -> (this.progress / (double) this.duration)));
+
+        var babyFop = new Fox(EntityType.FOX, data.getLevel());
+        babyFop.setAge(-1);
+        panel.child(new 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").displayAmount(true))
+                                        .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(new Row()
+                                                        .name("buttons, slots and more tests")
+                                                        .height(137)
+                                                        .coverChildrenWidth()
+                                                        .alignY(Alignment.Center)
+                                                        // .padding(7)
+                                                        .child(new Column()
+                                                                .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(GTGuiTextures.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(new Column()
+                                                                .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(new 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(new Column()
+                                                                        .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(new Column()
+                                                .name("Slots test page")
+                                                .coverChildren()
+                                                // .height(120)
+                                                .padding(7)
+                                                .alignX(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(new 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(new Row()
+                                                                .name("test config 1")
+                                                                .widthRel(1f).coverChildrenHeight()
+                                                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                                                .childPadding(2)
+                                                                .child(new CycleButtonWidget()
+                                                                        .value(new BoolValue(false))
+                                                                        .stateOverlay(GTGuiTextures.CHECK_BOX)
+                                                                        .size(14, 14)
+                                                                        .margin(8, 4))
+                                                                .child(IKey.str("Boolean config").asWidget().height(14)))
+                                                        .child(new 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(new Row()
+                                                                .name("test config 3")
+                                                                .widthRel(1f).height(14)
+                                                                .childPadding(2)
+                                                                .child(new CycleButtonWidget()
+                                                                        .value(new BoolValue(false))
+                                                                        .stateOverlay(GTGuiTextures.CHECK_BOX)
+                                                                        .size(14, 14))
+                                                                .child(IKey.str("Boolean config 3").asWidget().height(14)))))
+                                        .addPage(new ParentWidget<>()
+                                                .name("page 4 storage")
+                                                .sizeRel(1f)
+                                                .child(new Column()
+                                                        .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(data))))
+                        .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
+        return panel;
+    }
+
+    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", null)
+                .setDisablePanelsBelow(false)
+                .setCloseOnOutOfBoundsClick(false)
+                .setDraggable(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", null)
+                .setDisablePanelsBelow(false)
+                .setCloseOnOutOfBoundsClick(false)
+                .setDraggable(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.setDraggable(true);
+        dialog.child(new TextFieldWidget()
+                .resizer(flex -> flex.size(100, 20).align(Alignment.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<>()
+                                .collapseDisabledChild()
+                                .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(GTGuiTextures.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..895397b131d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine2.java
@@ -0,0 +1,97 @@
+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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.drawable.graph.GraphDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.DAM;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+
+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 ModularPanel buildUI(PosGuiData data, 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();
+
+        return GTGuis.createPanel(this, 176, 168)
+                .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(new 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..7df6a1a443c 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,28 +5,40 @@
 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;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.pattern.TraceabilityPredicate;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 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 it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -44,7 +56,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class ActiveTransformerMachine extends WorkableElectricMultiblockMachine
-                                      implements IControllable, IFancyUIMachine, IDisplayUIMachine {
+                                      implements IControllable {
 
     private IEnergyContainer powerOutput;
     private IEnergyContainer powerInput;
@@ -169,53 +181,135 @@ public static TraceabilityPredicate getHatchPredicates() {
     }
 
     @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;
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 176);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(Flow.row()
+                                .child(getMainTextPanel(syncManager, 170, 84))))
+                .child(Flow.column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager))
+                        .excludeAreaInRecipeViewer())
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+        return panel;
     }
 
-    @Override
-    public @NotNull ModularUI createUI(@NotNull Player entityPlayer) {
-        return new ModularUI(198, 208, this, entityPlayer).widget(new FancyMachineUIWidget(this, 198, 208));
+    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)
+                .alignX(Alignment.CenterLeft)
+                .left(3)
+                .top(3);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.MUI_DISPLAY);
+        // 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));
+
+        // 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);
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.work_paused"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !workingEnabled.getBoolValue()));
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.running"))
+                .asWidget()
+                .setEnabledIf(
+                        (widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() && active.getBoolValue()));
+
+        listWidget.child(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()));
+
+        listWidget.child(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()));
+
+        listWidget.child(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()));
+
+        listWidget.child(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()));
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.active_transformer.danger_enabled"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() &&
+                        active.getBoolValue() && !ConfigHolder.INSTANCE.machines.harmlessActiveTransformers));
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.idling"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() &&
+                        !active.getBoolValue()));
+
+        listWidget.child(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()));
+
+        parentWidget.child(listWidget);
+        return parentWidget;
     }
 }
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 5933ae2b079..f9deb48aff3 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 84cf9d94b28..73239774a04 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,21 +1,17 @@
 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;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
 import com.gregtechceu.gtceu.api.pattern.*;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
@@ -23,36 +19,26 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.data.GTMachines;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+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 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,18 +54,16 @@ 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 MultiblockState patternFindingState;
 
     private static TraceabilityPredicate MULTI_PREDICATE = null;
 
-    public CentralMonitorMachine(BlockEntityCreationInfo info) {
-        super(info, CentralMonitorLogic::new);
+    public CentralMonitorMachine(BlockEntityCreationInfo holder) {
+        super(holder, CentralMonitorLogic::new);
     }
 
     public static TraceabilityPredicate getMultiPredicate() {
@@ -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<MonitorGroup> configGroup = new ArrayList<>();
-        configGroup.add(null);
-
-        Consumer<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 46006d60b70..1aecbed33cf 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,9 +9,7 @@
 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.IMufflerMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.CleanroomType;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
@@ -19,22 +17,44 @@
 import com.gregtechceu.gtceu.api.machine.trait.CleanroomProviderTrait;
 import com.gregtechceu.gtceu.api.machine.trait.CleanroomReceiverTrait;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.GenericSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.StringSyncValue;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.pattern.BlockPattern;
 import com.gregtechceu.gtceu.api.pattern.FactoryBlockPattern;
 import com.gregtechceu.gtceu.api.pattern.Predicates;
 import com.gregtechceu.gtceu.api.pattern.TraceabilityPredicate;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.data.GTMachines;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.electric.HullMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.generator.LargeCombustionEngineMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.generator.LargeTurbineMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.DiodePartMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.part.MufflerPartMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.primitive.CokeOvenMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.primitive.PrimitiveBlastFurnaceMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.primitive.PrimitivePumpMachine;
 import com.gregtechceu.gtceu.common.machine.trait.CleanroomLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 import com.gregtechceu.gtceu.utils.GTUtil;
@@ -70,11 +90,12 @@
 
 import static com.gregtechceu.gtceu.api.pattern.Predicates.*;
 import static com.gregtechceu.gtceu.api.pattern.util.RelativeDirection.*;
+import static com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters.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;
@@ -441,7 +462,7 @@ public boolean addCache() {
     protected boolean isMachineBanned(MetaMachine machine) {
         // blacklisted machines: mufflers and all generators, miners/drills, primitives
         if (machine.getTraitHolder().getTrait(CleanroomProviderTrait.TYPE) != null) return true;
-        if (machine instanceof IMufflerMachine) return true;
+        if (machine instanceof MufflerPartMachine) return true;
         if (machine instanceof SimpleGeneratorMachine) return true;
         if (machine instanceof LargeCombustionEngineMachine) return true;
         if (machine instanceof LargeTurbineMachine) return true;
@@ -456,54 +477,151 @@ protected boolean isMachineBanned(MetaMachine machine) {
     }
 
     @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"));
-            }
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 176);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(Flow.row()
+                                .child(getMainTextPanel(syncManager, 170, 84))))
+                .child(Flow.column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager))
+                        .excludeAreaInRecipeViewer())
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+        return panel;
+    }
 
-            if (recipeLogic.isWaiting()) {
-                textList.add(Component.translatable("gtceu.multiblock.waiting")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-            }
+    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)
+                .alignX(Alignment.CenterLeft)
+                .left(3)
+                .top(3);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.MUI_DISPLAY);
+        // 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 = new 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 {
+        listWidget.child(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()));
+
+        listWidget.child(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));
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (cleanroomTypeIsNull.getBoolValue()) {
+                return Component.empty();
+            } else {
+                return Component.translatable(cleanroomTranslationKey.getStringValue());
+            }
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !cleanroomTypeIsNull.getBoolValue()));
+
+        listWidget.child(IKey.dynamic(() -> Component.translatable("gtceu.multiblock.work_paused"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !workingEnabled.getBoolValue()));
+
+        listWidget.child(GTMultiblockTextUtil.addProgressLine(this, syncManager));
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.idling"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() &&
+                        !active.getBoolValue()));
+
+        listWidget.child(IKey
+                .lang(Component.translatable("gtceu.multiblock.waiting")
+                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && waiting.getBoolValue()));
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.cleanroom.clean_state"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && cleanroomProviderTraitIsActive.getBoolValue()));
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.cleanroom.dirty_state"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !cleanroomProviderTraitIsActive.getBoolValue()));
+
+        listWidget.child(IKey.dynamic(
+                () -> Component.translatable("gtceu.multiblock.cleanroom.clean_amount", cleanAmount.getIntValue()))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue()));
+
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.dimensions.0"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue()));
+        listWidget.child(IKey.dynamic(() -> distComponent.getValue())
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue()));
+
+        parentWidget.child(listWidget);
+        return parentWidget;
     }
 
     /**
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 cd114c360ee..9a26468df25 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 d22921206a8..3a267d1d40f 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
@@ -275,15 +275,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 a2f4a715e9b..68ec81f4f3d 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
@@ -16,19 +16,14 @@
 import com.gregtechceu.gtceu.api.transfer.fluid.FluidHandlerList;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.trait.miner.LargeMinerLogic;
 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.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -184,54 +179,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 2e71fb67cac..2ccc4ce4edd 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,22 +3,32 @@
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
-
-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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -34,7 +44,7 @@
 
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
-public class MultiblockTankMachine extends MultiblockControllerMachine implements IFancyUIMachine {
+public class MultiblockTankMachine extends MultiblockControllerMachine implements IMuiMachine {
 
     @SaveField
     @Getter
@@ -73,20 +83,40 @@ public IFluidHandlerModifiable getFluidHandlerCap(@Nullable Direction side, bool
     /////////////////////////////////////
 
     @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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        IntSyncValue bucketSyncer = new IntSyncValue(() -> tank.getFluidInTank(0).getAmount(), (ignored) -> {});
+        syncManager.syncValue("bucket_amount", bucketSyncer);
+
+        return new ModularPanel(this.getDefinition().getName())
+                .child(
+                        // Top half of the screen
+                        new ParentWidget<>()
+                                .widthRel(1)
+                                .height(20 + 60)
+                                .child(new ParentWidget<>()
+                                        .background(GTGuiTextures.DISPLAY)
+                                        .size(90, 63)
+                                        .align(Alignment.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.column()
+                                                .margin(68, 0, 23, 0)
+                                                .coverChildren()
+                                                .child(createFluidSlot(syncManager)))))
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 176, GTGuiTextures.BACKGROUND))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
-    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 2aaebf9fc9d..237ecc5ec9b 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,14 +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.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.IMuiMachine;
 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;
@@ -21,11 +16,28 @@
 import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.BigIntegerSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 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;
@@ -34,7 +46,6 @@
 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 com.google.common.annotations.VisibleForTesting;
@@ -51,7 +62,7 @@
 import java.util.Map;
 
 public class PowerSubstationMachine extends WorkableMultiblockMachine
-                                    implements IEnergyInfoProvider, IFancyUIMachine, IDisplayUIMachine {
+                                    implements IEnergyInfoProvider, IMuiMachine {
 
     // Structure Constants
     public static final int MAX_BATTERY_LAYERS = 18;
@@ -196,81 +207,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)));
-            }
-
-            if (energyBank != null) {
-                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
@@ -319,20 +255,6 @@ public long getPassiveDrain() {
         return passiveDrain;
     }
 
-    public String getStored() {
-        if (energyBank == null) {
-            return "0";
-        }
-        return FormattingUtil.formatNumbers(energyBank.getStored());
-    }
-
-    public String getCapacity() {
-        if (energyBank == null) {
-            return "0";
-        }
-        return FormattingUtil.formatNumbers(energyBank.getCapacity());
-    }
-
     @Override
     public EnergyInfo getEnergyInfo() {
         return new EnergyInfo(energyBank.getCapacity(), energyBank.getStored());
@@ -344,33 +266,175 @@ 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));
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 176);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(Flow.row()
+                                .child(getMainTextPanel(syncManager, 170, 84))))
+                .child(Flow.column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+        return panel;
     }
 
-    @Override
-    public List<IFancyUIProvider> getSubTabs() {
-        return getParts().stream().filter(IFancyUIProvider.class::isInstance).map(IFancyUIProvider.class::cast)
-                .toList();
-    }
-
-    @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)
+                .alignX(Alignment.CenterLeft)
+                .left(3)
+                .top(3);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.MUI_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 == null) ? BigInteger.ZERO : energyBank.getStored(), $ -> {});
+        syncManager.syncValue("energyStored", energyStored);
+
+        BigIntegerSyncValue capacity = new BigIntegerSyncValue(
+                () -> (energyBank == null) ? BigInteger.ZERO : 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..8e592c18136 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,17 +7,37 @@
 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.multiblock.WorkableMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockPanelUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 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;
@@ -37,7 +57,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,17 +196,75 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 164);
+
+        var panelUtil = new GTMultiblockPanelUtil(this);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(new Row()
+                                .child(getMainTextPanel(syncManager, 170, 70))))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+
+        return panel;
+    }
+
+    public Widget<?> getMainTextPanel(PanelSyncManager syncManager, int width, int height) {
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>()
+                .width(width - 6)
+                .height(height - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .alignX(Alignment.CenterLeft);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.MUI_DISPLAY);
+
+        LongSyncValue energyStoredSyncValue = new LongSyncValue(this::getEnergyUsage);
+        syncManager.syncValue("dataBankEnergyStored", energyStoredSyncValue);
+        listWidget.child(GTMultiblockTextUtil.addEnergyUsageExactLine(this, syncManager, energyStoredSyncValue));
+        listWidget.child(addWorkingStatusLine(this, syncManager));
+        parentWidget.child(listWidget.left(3).top(3));
+        return parentWidget;
     }
 
+    public static TextWidget<?> addWorkingStatusLine(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()));
+        BooleanSyncValue isWorkingEnabled = syncManager.getOrCreateSyncHandler("isWorkingEnabled",
+                BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> rlMachine.getRecipeLogic().isWorkingEnabled()));
+
+        return IKey
+                .dynamic(() -> {
+                    if (!isFormed.getBoolValue()) return Component.empty();
+                    if (!isWorkingEnabled.getBoolValue() || !isActive.getBoolValue()) {
+                        return Component.translatable("gtceu.multiblock.idling").withStyle(ChatFormatting.GRAY);
+                    }
+                    return Component.translatable("gtceu.multiblock.data_bank.providing")
+                            .withStyle(ChatFormatting.GREEN);
+                })
+                .asWidget()
+                .setEnabledIf((w) -> isFormed.getBoolValue());
+    }
     /*
      * @Override
      * protected void addWarningText(List<Component> textList) {
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 7718f9ab4a0..d3c71b5451c 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,38 +6,38 @@
 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.machine.trait.hpca.HPCAComponentTrait;
 import com.gregtechceu.gtceu.api.machine.trait.hpca.HPCAComputationProviderTrait;
 import com.gregtechceu.gtceu.api.machine.trait.hpca.HPCACoolantProviderTrait;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.value.sync.GenericSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 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.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.fluid.FluidHandlerList;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.hpca.HPCAComponentPartMachine;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 com.gregtechceu.gtceu.utils.serialization.network.ByteBufAdapters;
 
 import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
@@ -48,6 +48,8 @@
 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;
@@ -61,7 +63,6 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
-import java.util.function.Supplier;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -251,67 +252,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(ByteBufAdapters.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 +677,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 +748,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 d7b119c7492..01fe43a3ee9 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
@@ -7,12 +7,10 @@
 import com.gregtechceu.gtceu.api.capability.recipe.CWURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-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;
@@ -116,18 +114,18 @@ public boolean canBridge(@NotNull 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 c4e8ed6f154..d59ce424e88 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
@@ -1,22 +1,38 @@
 package com.gregtechceu.gtceu.common.machine.multiblock.electric.research;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationReceiver;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 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.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockPanelUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.ObjectHolderMachine;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 
+import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
@@ -25,14 +41,13 @@
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collections;
-import java.util.List;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
 public class ResearchStationMachine extends WorkableElectricMultiblockMachine
-                                    implements IOpticalComputationReceiver, IDisplayUIMachine {
+                                    implements IOpticalComputationReceiver {
 
     @Getter
     private IOpticalComputationProvider computationProvider;
@@ -101,16 +116,56 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 164);
+
+        var panelUtil = new GTMultiblockPanelUtil(this);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(new Row()
+                                .child(getMainTextPanel(syncManager, 170, 70))))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager))
+                        .child(GTMuiWidgets.createVoidingButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+
+        return panel;
+    }
+
+    public Widget<?> getMainTextPanel(PanelSyncManager syncManager, int width, int height) {
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>()
+                .width(width - 6)
+                .height(height - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .alignX(Alignment.CenterLeft);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.MUI_DISPLAY);
+
+        listWidget.child(GTMultiblockTextUtil.addWorkingStatusLine(this, syncManager,
+                () -> Component.translatable("gtceu.multiblock.work_paused").withStyle(ChatFormatting.GOLD),
+                () -> Component.translatable("gtceu.multiblock.research_station.researching")
+                        .withStyle(ChatFormatting.GREEN),
+                () -> Component.translatable("gtceu.multiblock.idling").withStyle(ChatFormatting.GRAY)));
+        listWidget.child(GTMultiblockTextUtil.addEnergyTierLine(this, syncManager));
+        listWidget.child(GTMultiblockTextUtil.addEnergyUsageLine(this, syncManager));
+        listWidget.child(GTMultiblockTextUtil.addOutputLines(this, syncManager));
+        listWidget.child(GTMultiblockTextUtil.addProgressLinePercentOnly(this, syncManager));
+        parentWidget.child(listWidget.left(3).top(3));
+        return parentWidget;
     }
 
     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 4009a885b10..7b0573b1758 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,37 @@
 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.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+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.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;
@@ -52,6 +57,7 @@ public class DataAccessHatchMachine extends TieredPartMachine
     private final Set<GTRecipe> recipes;
     @Getter
     private final boolean isCreative;
+    @SyncToClient
     @SaveField
     public final NotifiableItemStackHandler importItems;
 
@@ -72,9 +78,8 @@ public void onContentsChanged() {
                 rebuildData(isFormed() && getControllers().first() instanceof DataBankMachine);
             }
 
-            @NotNull
             @Override
-            public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
+            public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
                 boolean isDataBank = isFormed() && getControllers().first() instanceof DataBankMachine;
                 if (ResearchManager.isStackDataItem(stack, isDataBank)) {
                     return super.insertItem(slot, stack, simulate);
@@ -84,21 +89,31 @@ public ItemStack insertItem(int slot, @NotNull 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager,
+                                UISettings settings) {
+        int size = (int) Math.sqrt(getInventorySize());
+
+        var grid = GTMuiMachineUtil.createSlotGroupFromInventory(importItems, "data_inventory", getInventorySize(), 'I',
+                i -> i.background(GTGuiTextures.SLOT, GTGuiTextures.DATA_ORB_OVERLAY), syncManager,
+                GTMuiMachineUtil.createSquareMatrix(importItems.getSlots(), 'I'));
+
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 100 + (18 * size))
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(1)
+                        .height(20 + 18 * size)
+                        .child(Flow.row()
+                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                .align(Alignment.CENTER)
+                                .coverChildren()
+                                .child(grid
+                                        .marginLeft(30)
+                                        .marginRight(30)
+                                        .verticalCenter())))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
     @Override
@@ -139,12 +154,11 @@ private void rebuildData(boolean isDataBank) {
     }
 
     @Override
-    public boolean isRecipeAvailable(@NotNull GTRecipe recipe, @NotNull Collection<IDataAccessHatch> seen) {
+    public boolean isRecipeAvailable(GTRecipe recipe, @NotNull Collection<IDataAccessHatch> seen) {
         seen.add(this);
         return recipe.conditions.stream().noneMatch(ResearchCondition.class::isInstance) || recipes.contains(recipe);
     }
 
-    @NotNull
     @Override
     public List<Component> getDataInfo(PortableScannerBehavior.DisplayMode mode) {
         if (mode == PortableScannerBehavior.DisplayMode.SHOW_ALL ||
@@ -187,8 +201,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 910ef071f66..db844fd2526 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,43 @@
 
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTMachines;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.Style;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraftforge.fluids.FluidType;
 
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
@@ -153,31 +169,64 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        int rowSize = (int) Math.sqrt(getInventorySize());
+        int panelWidth = Math.max(176 + 18 + 3, 18 * rowSize + 18 + 14);
+        int panelHeight = 74 + Math.max(30, 9 + rowSize * 18) + 14;
+        String slotGroupName = "inv_slot_group";
+        SlotGroup slotGroup = new SlotGroup(slotGroupName, getInventorySize());
+        return new ModularPanel(this.getDefinition().getName())
+                .size(panelWidth, panelHeight)
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), panelWidth))
+                .bindPlayerInventory()
+                .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()
+                        .center()
+                        .marginBottom(89))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .excludeAreaInRecipeViewer()
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(new ToggleButton()
+                                .value(new BoolValue.Dynamic(this::isWorkingEnabled, this::setWorkingEnabled))
+                                .selectedBackground(GTGuiTextures.BUTTON_POWER[1])
+                                .background(GTGuiTextures.BUTTON_POWER[0])
+                                .tooltipAutoUpdate(true)
+                                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable(
+                                        isWorkingEnabled() ? "behaviour.soft_hammer.enabled" :
+                                                "behaviour.soft_hammer.disabled")))))
+                        .childIf(io.support(IO.IN), () -> new ToggleButton()
+                                .value(new BoolValue.Dynamic(this::isDistinct, this::setDistinct))
+                                .stateOverlay(GTGuiTextures.BUTTON_DISTINCT)
+                                .tooltipAutoUpdate(true)
+                                .tooltipBuilder((
+                                                 richTooltip) -> richTooltip
+                                                         .add(Component
+                                                                 .translatable("gtceu.multiblock.universal.distinct")
+                                                                 .setStyle(Style.EMPTY.withColor(ChatFormatting.YELLOW))
+                                                                 .append(Component.translatable(isDistinct() ?
+                                                                         "gtceu.multiblock.universal.distinct.yes" :
+                                                                         "gtceu.multiblock.universal.distinct.no"))))));
     }
 }
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 e8bf27a31fb..23324c45d19 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,32 +3,43 @@
 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.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredIOPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTMachines;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
+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;
@@ -263,119 +274,105 @@ 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;
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        int width = 176;
+        int height = Math.max(168, (int) (18 * Math.sqrt(slots)) + 78 + 19);
+        var panel = GTGuis.createPanel(this, width, height);
+
+        // magic numbers are me favorite :3
+        int topOffset = slots == 1 ? 10 : slots == 9 ? 16 : 20;
+
+        var theme = this.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
         }
 
-        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));
-            }
-        }
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 174))
+                .child(SlotGroupWidget.playerInventory(true)
+                        .left(7)
+                        .bottom(7))
+                .child((slots == 1 ? createSingleSlotUI(syncManager) : createMultiSlotUI(syncManager))
+                        .top(topOffset)
+                        .horizontalCenter())
+                .child(new Column()
+                        .coverChildren()
+                        .rightRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(8, 0, 4, 4)
+                        .childPadding(2)
+                        .background(backgroundTexture.getSubArea(0.0f, 0f, 0.75f, 1.0f))
+                        .excludeAreaInRecipeViewer()
+                        .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled,
+                                syncManager))
+                        .childIf(this.isCircuitSlotEnabled(),
+                                () -> GTMuiWidgets.createCircuitSlotPanel(this, panel, syncManager)));
+
+        return panel;
+    }
 
-        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 new Column()
+                .widthRel(.6f)
+                .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(new Row()
+                        .childPadding(2)
+                        .coverChildren()
+                        .childIf(io.support(IO.OUT), () -> new FluidSlot()
+                                .name("lockedFluid")
+                                .syncHandler(new FluidSlotSyncHandler(tank.getLockedFluid()))
+                                .alwaysShowFull(true)
+                                .displayAmount(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(GTGuiTextures.MC_BUTTON)
+                                .selectedBackground(GTGuiTextures.MC_BUTTON_PRESSED)
+
+                        )
+                        .child(new FluidSlot()
+                                .name("regularFluid")
+                                .syncHandler(new FluidSlotSyncHandler(tank.getStorages()[0])
+                                        .canFillSlot(io.support(IO.IN)))
+                                .displayAmount(true)));
+    }
 
-        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 0660dbb5c56..ba0efe5e22c 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,32 +6,45 @@
 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;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredIOPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTMachines;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 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.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.InteractionHand;
@@ -98,7 +111,7 @@ protected int getInventorySize() {
     }
 
     protected NotifiableItemStackHandler createInventory() {
-        return new NotifiableItemStackHandler(this, getInventorySize(), io);
+        return new NotifiableItemStackHandler(this, getInventorySize(), io, IO.BOTH);
     }
 
     protected boolean matchesFilter(ItemStack stack) {
@@ -277,7 +290,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.
@@ -291,41 +304,112 @@ 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 ModularPanel buildUI(PosGuiData data, 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;
-        group.addWidget(filterHandler.createFilterSlotUI(-115 + (18 * rowSize) / 2, 35 + 11 * rowSize));
-        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));
-            }
+
+        int width = Math.max(176, 18 * rowSize + 14);
+        int height = Math.max(168, (18 * rowSize) + 78 + 19);
+        var panel = GTGuis.createPanel(this, width, height);
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), width));
+
+        int smallHatchOffset = tier < 2 ? 9 * (3 - rowSize) : 0;
+
+        SlotGroup group = new SlotGroup("item_inv", rowSize, 0, true);
+        panel.child(new Grid()
+                .coverChildren()
+                .top(10 + smallHatchOffset)
+                .alignX(0.5f)
+                .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))))
+
+                .child(SlotGroupWidget.playerInventory(true)
+                        // .alignX(Alignment.CENTER)
+                        .left(7)
+                        .bottom(7));
+
+        var theme = this.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
         }
 
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-        return group;
+        panel.child(new Column()
+                .coverChildren()
+                .rightRel(1.0f)
+                .reverseLayout(true)
+                .bottom(16)
+                .padding(8, 0, 4, 4)
+                .childPadding(2)
+                .background(backgroundTexture.getSubArea(0.0f, 0f, 0.75f, 1.0f))
+                .child(new ToggleButton()
+                        .value(new BoolValue.Dynamic(this::isWorkingEnabled, this::setWorkingEnabled))
+                        .selectedBackground(GTGuiTextures.BUTTON_POWER[1])
+                        .background(GTGuiTextures.BUTTON_POWER[0])
+                        .tooltipAutoUpdate(true)
+                        .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable(
+                                isWorkingEnabled() ? "behaviour.soft_hammer.enabled" :
+                                        "behaviour.soft_hammer.disabled")))))
+                .childIf(isCircuitSlotEnabled(), () -> GTMuiWidgets.createCircuitSlotPanel(this, panel, syncManager))
+                .childIf(io.support(IO.IN), () -> new ToggleButton()
+                        .value(new BoolValue.Dynamic(this::isDistinct, this::setDistinct))
+                        .stateOverlay(GTGuiTextures.BUTTON_DISTINCT)
+                        .tooltipAutoUpdate(true)
+                        .tooltipBuilder((
+                                         richTooltip) -> richTooltip
+                                                 .add(Component.translatable("gtceu.multiblock.universal.distinct")
+                                                         .setStyle(Style.EMPTY.withColor(ChatFormatting.YELLOW))
+                                                         .append(Component
+                                                                 .translatable("gtceu.multiblock.universal.distinct" +
+                                                                         (isDistinct() ? ".yes" : ".no")))))));
+
+        return panel;
     }
+
+    /*
+     * 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() {
+     * 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;
+     * 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;
+     * }
+     */
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/LaserHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/LaserHatchPartMachine.java
index 27d21392633..c3bc038a5cf 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/LaserHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/LaserHatchPartMachine.java
@@ -7,7 +7,7 @@
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredIOPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableLaserContainer;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionHand;
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 9bef4765b0a..11c998b88c7 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,8 +3,6 @@
 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;
@@ -12,14 +10,31 @@
 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;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.FloatSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.InteractionSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.core.BlockPos;
@@ -27,7 +42,6 @@
 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;
@@ -48,6 +62,7 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.function.DoubleSupplier;
+import java.util.stream.Stream;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -76,7 +91,6 @@ public class MaintenanceHatchPartMachine extends TieredPartMachine
     @SaveField
     @SyncToClient
     protected byte maintenanceProblems = startProblems();
-    @Getter
     @SaveField
     private float durationMultiplier = 1f;
     @Nullable
@@ -107,6 +121,11 @@ public byte startProblems() {
         return ALL_PROBLEMS;
     }
 
+    public void setDurationMultiplier(float durationMultiplier) {
+        this.durationMultiplier = durationMultiplier;
+        syncDataHolder.markClientSyncFieldDirty("durationMultiplier");
+    }
+
     //////////////////////////////////////
     // ********* Logic **********//
     //////////////////////////////////////
@@ -335,44 +354,120 @@ public InteractionResult onUse(BlockState state, Level world, BlockPos pos, Play
     //////////////////////////////////////
     // ******** 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);
-                            }
-                        }
-                    })));
+    /*
+     * @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;
+     * }
+     */
 
-        } 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 ModularPanel buildUI(PosGuiData guiData, PanelSyncManager syncManager, UISettings uiSettings) {
+        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();
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 200)
+                .bindPlayerInventory()
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(Flow.column()
+                        .crossAxisAlignment(Alignment.CrossAxis.START)
+                        .childIf(this.isConfigurable, () -> Flow.column()
+                                .coverChildren()
+                                .padding(5)
+                                .paddingLeft(0)
+                                .marginLeft(5)
+                                .child(Flow.row()
+                                        .coverChildren()
+                                        .childPadding(5)
+                                        .alignX(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() }))
+                                        .alignX(0)))
+                        .child(Flow.row()
+                                .alignX(.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));
     }
 
     private static Component getTextWidgetText(String type, DoubleSupplier multiplier) {
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 f0b24e28460..36d8031fc56 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
@@ -2,25 +2,33 @@
 
 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.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
 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.IMufflerMachine;
+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;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.GTMedicalConditions;
+import com.gregtechceu.gtceu.common.data.GTParticleTypes;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
 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;
@@ -28,14 +36,18 @@
 
 import lombok.Getter;
 import org.jetbrains.annotations.MustBeInvokedByOverriders;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.stream.IntStream;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
+import static com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil.createSquareSlotGroupFromInventory;
+
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class MufflerPartMachine extends TieredPartMachine implements IMufflerMachine, IUIMachine {
+public class MufflerPartMachine extends TieredPartMachine implements IMuiMachine {
 
     @Getter
     private final int recoveryChance;
@@ -44,18 +56,21 @@ public class MufflerPartMachine extends TieredPartMachine implements IMufflerMac
     private final CustomItemStackHandler inventory;
 
     private TickableSubscription snowSubscription;
+    @Getter
+    private final EnvironmentalHazardEmitterTrait hazardEmitter;
 
     public MufflerPartMachine(BlockEntityCreationInfo info, int tier) {
         super(info, tier);
         this.recoveryChance = Math.max(1, tier * 10);
         this.inventory = new CustomItemStackHandler((int) Math.pow(tier + 1, 2));
+        this.hazardEmitter = new EnvironmentalHazardEmitterTrait(this, GTMedicalConditions.CARBON_MONOXIDE_POISONING,
+                2.5f / Math.max(tier, 1));
     }
 
     //////////////////////////////////////
     // ******** Muffler *********//
     //////////////////////////////////////
 
-    @Override
     public void recoverItemsTable(ItemStack... recoveryItems) {
         int numRolls = Math.min(recoveryItems.length, inventory.getSlots());
         IntStream.range(0, numRolls).forEach(slot -> {
@@ -82,6 +97,21 @@ public void clientTick() {
         }
     }
 
+    @Override
+    public @Nullable GTRecipe modifyRecipe(GTRecipe recipe) {
+        return isFrontFaceFree() ? recipe : super.modifyRecipe(recipe);
+    }
+
+    @Override
+    public boolean afterWorking(IWorkableMultiController controller) {
+        hazardEmitter.emitHazard();
+        var supplier = controller.self().getDefinition().getRecoveryItems();
+        if (supplier != null) {
+            recoverItemsTable(supplier.get());
+        }
+        return super.afterWorking(controller);
+    }
+
     @Override
     public void addedToController(MultiblockControllerMachine controller) {
         super.addedToController(controller);
@@ -112,28 +142,67 @@ private void tryBreakSnow() {
         }
     }
 
+    public boolean isFrontFaceFree() {
+        var frontPos = self().getBlockPos().relative(self().getFrontFacing());
+        return self().getLevel().getBlockState(frontPos).isAir() ||
+                GTCapabilityHelper.getHazardContainer(self().getLevel(),
+                        frontPos, self().getFrontFacing().getOpposite()) != null;
+    }
+
+    public void emitPollutionParticles() {
+        var pos = self().getBlockPos();
+        var facing = self().getFrontFacing();
+
+        IHazardParticleContainer container = GTCapabilityHelper.getHazardContainer(self().getLevel(),
+                pos.relative(facing), facing.getOpposite());
+        if (container != null) {
+            // do not emit particles if front face has a duct on it.
+            return;
+        }
+
+        var center = pos.getCenter();
+        var offset = .75f;
+        var xPos = (float) (center.x + facing.getStepX() * offset + (GTValues.RNG.nextFloat() - .5f) * .35f);
+        var yPos = (float) (center.y + facing.getStepY() * offset + (GTValues.RNG.nextFloat() - .5f) * .35f);
+        var zPos = (float) (center.z + facing.getStepZ() * offset + (GTValues.RNG.nextFloat() - .5f) * .35f);
+
+        var ySpd = facing.getStepY() + (GTValues.RNG.nextFloat() - .15f) * .5f;
+        var xSpd = facing.getStepX() + (GTValues.RNG.nextFloat() - .5f) * .5f;
+        var zSpd = facing.getStepZ() + (GTValues.RNG.nextFloat() - .5f) * .5f;
+
+        self().getLevel().addParticle(GTParticleTypes.MUFFLER_PARTICLE.get(),
+                xPos, yPos, zPos, xSpd, ySpd, zSpd);
+    }
+
     //////////////////////////////////////
     // ********** 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 @NotNull ModularPanel buildUI(@NotNull PosGuiData data, @NotNull PanelSyncManager syncManager,
+                                         @NotNull UISettings settings) {
+        int size = (int) Math.sqrt(inventory.getSlots());
+
+        return new ModularPanel(this.getDefinition().getName())
+                .size(Math.max(176, 20 + (18 * size)), 100 + (18 * size))
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(1)
+                        .height(20 + 18 * size)
+                        .child(Flow.row()
+                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                .align(Alignment.CENTER)
+                                .coverChildren()
+                                .child(createSquareSlotGroupFromInventory(inventory, "muffler_inventory", syncManager)
+                                        .marginLeft(30)
+                                        .marginRight(30)
+                                        .verticalCenter())))
+                .child(new ParentWidget<>()
+                        .bottom(7)
+                        .widthRel(1)
+                        .height(76)
+                        .child(Flow.row()
+                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                .align(Alignment.CENTER).coverChildren().child(
+                                        SlotGroupWidget.playerInventory(false))));
     }
 }
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 7ccba6fbe58..66f0a5e6c11 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,22 +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.BlockableSlotWidget;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.component.IDataItem;
 import com.gregtechceu.gtceu.api.item.component.IItemComponent;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.MultiblockPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
@@ -89,15 +96,43 @@ public void onMachineDestroyed() {
     }
 
     @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 @NotNull ModularPanel buildUI(@NotNull PosGuiData data, @NotNull PanelSyncManager syncManager,
+                                         @NotNull UISettings settings) {
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 166)
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(1)
+                        .heightRel(0.5f)
+                        .child(internalUI(syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+    }
+
+    private Widget<?> internalUI(PanelSyncManager syncManager) {
+        SlotGroup objectGroup = new SlotGroup("object_slot", 1);
+        SlotGroup orbGroup = new SlotGroup("orb_slot", 1);
+
+        return Flow.row()
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .align(Alignment.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/OpticalDataHatchMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/OpticalDataHatchMachine.java
index ea68cddff72..be745807be5 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/OpticalDataHatchMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/OpticalDataHatchMachine.java
@@ -1,9 +1,9 @@
 package com.gregtechceu.gtceu.common.machine.multiblock.part;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IDataAccessHatch;
 import com.gregtechceu.gtceu.api.capability.IOpticalDataAccessHatch;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IWorkableMultiController;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
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..5c3e95068ec 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,32 @@
 
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.DynamicDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.utils.GTMath;
 
 import net.minecraft.util.Mth;
 
 import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
 
-public class ParallelHatchPartMachine extends TieredPartMachine implements IFancyUIMachine {
+public class ParallelHatchPartMachine extends TieredPartMachine implements IMuiMachine {
 
     private static final int MIN_PARALLEL = 1;
 
@@ -41,18 +52,113 @@ 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;
-    }
+    /*
+     * @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;
+     * }
+     */
 
     @Override
     public boolean canShared() {
         return false;
     }
+
+    @Override
+    public @NotNull ModularPanel buildUI(@NotNull PosGuiData data, @NotNull PanelSyncManager syncManager,
+                                         @NotNull UISettings settings) {
+        IntSyncValue parallels = new IntSyncValue(this::getCurrentParallel, this::setCurrentParallel);
+        ModularPanel panel = new ModularPanel(this.getDefinition().getName());
+        panel
+                .size(180, 60)
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 240))
+                .child(createParallelRow(parallels));
+        return panel;
+    }
+
+    private Flow createParallelRow(IntSyncValue parallels) {
+        return Flow.row()
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .align(Alignment.CENTER)
+                .coverChildren()
+                .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 26201a8a62e..0b320d91c3d 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,33 +4,37 @@
 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.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTDamageTypes;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.TurbineRotorBehaviour;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.TurbineRotorBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -43,8 +47,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 import static com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties.*;
@@ -243,16 +245,41 @@ public InteractionResult onUse(BlockState state, Level level, BlockPos pos, Play
     //////////////////////////////////////
     // ********** 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 @NotNull ModularPanel buildUI(@NotNull PosGuiData data, @NotNull PanelSyncManager syncManager,
+                                         @NotNull UISettings settings) {
+        SlotGroup rotorSlotGroup = new SlotGroup("rotor", 1);
+
+        var slot = new ItemSlot()
+                .slot(new ModularSlot(inventory, 0)
+                        .slotGroup(rotorSlotGroup))
+                .background(GTGuiTextures.SLOT, GTGuiTextures.TURBINE_OVERLAY)
+                .marginLeft(30)
+                .marginRight(30)
+                .verticalCenter();
+
+        var rotorSync = new IntSyncValue(this::getRotorSpeed, (speed) -> {});
+        rotorSync.setChangeListener(() -> {
+            boolean canEdit = rotorSync.getIntValue() == 0;
+            slot.getSlot().accessibility(canEdit, canEdit);
+        });
+
+        syncManager.syncValue("rotor_speed", rotorSync);
+
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 100 + (18 * 4))
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(1)
+                        .height(20 + 18 * 4)
+                        .child(Flow.row()
+                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                .align(Alignment.CENTER)
+                                .coverChildren()
+                                .child(slot)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
     //////////////////////////////////////
@@ -266,24 +293,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 39b92b49c7e..68eabcd3f6a 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,10 +2,9 @@
 
 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.machine.trait.hpca.HPCAComponentTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
@@ -25,7 +24,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 2a8a773c546..9fa0e84a7d0 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
@@ -3,10 +3,9 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.MultiblockPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.hpca.HPCAComponentTrait;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.player.Player;
@@ -35,7 +34,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 ffaf98023c2..220aaad2c51 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,11 +2,10 @@
 
 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.machine.trait.hpca.HPCAComponentTrait;
 import com.gregtechceu.gtceu.api.machine.trait.hpca.HPCAComputationProviderTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
@@ -35,12 +34,12 @@ public static HPCAComponentTrait createHPCATrait(HPCAComponentPartMachine machin
     }
 
     @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 bed1051e82a..849491d8f59 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,11 +2,10 @@
 
 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.machine.trait.hpca.HPCAComponentTrait;
 import com.gregtechceu.gtceu.api.machine.trait.hpca.HPCACoolantProviderTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
@@ -35,7 +34,7 @@ public static HPCAComponentTrait createHPCATrait(HPCAComponentPartMachine machin
     }
 
     @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 e919369ef5b..6d5b0dcf713 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,10 +1,9 @@
 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.api.machine.trait.hpca.HPCAComponentTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
@@ -24,7 +23,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 cd451b26b1d..abc8a92bb14 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,12 +2,10 @@
 
 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 net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -16,7 +14,9 @@
 import net.minecraft.world.phys.BlockHitResult;
 
 import lombok.Getter;
+import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Vector2d;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -36,6 +36,10 @@ public class AdvancedMonitorPartMachine extends MonitorPartMachine {
     @SaveField
     private boolean resetClickedNextTick = false;
 
+    @Getter
+    @Setter
+    private boolean clickedThisFrame = false;
+
     @Nullable
     private TickableSubscription clickResetSubscription;
 
@@ -48,14 +52,10 @@ public InteractionResult onUse(BlockState state, Level world, BlockPos pos, Play
                                    BlockHitResult hit) {
         if (hit.getDirection() != getFrontFacing()) return super.onUse(state, world, pos, player, hand, hit);
         clicked = true;
-        clickPosX = hit.getLocation()
-                .get(RelativeDirection.RIGHT.getRelative(getFrontFacing(), getUpwardsFacing(), false).getAxis());
-        clickPosY = hit.getLocation()
-                .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(hit);
+        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..c0dca272b49 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.mui.base.drawable.IDrawable;
+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 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/CharcoalPileIgniterMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CharcoalPileIgniterMachine.java
index c1daf9ad56e..b7a05fa2d02 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CharcoalPileIgniterMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CharcoalPileIgniterMachine.java
@@ -13,7 +13,7 @@
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
-import com.gregtechceu.gtceu.common.item.tool.behavior.LighterBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.LighterBehavior;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 
 import com.lowdragmc.lowdraglib.utils.BlockInfo;
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 e587e36b14d..80827654aea 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,19 +2,24 @@
 
 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.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.*;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+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.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -32,34 +37,58 @@
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
+import static com.gregtechceu.gtceu.common.data.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 ModularPanel buildUI(PosGuiData data, 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();
+                }));
+
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 166)
+                // Top half of the screen
+                .child(new ItemSlot().syncHandler(new ItemSlotSyncHandler(
+                        new ModularSlot(importItems.storage, 0)
+                                .slotGroup(new SlotGroup("import_items", 1))))
+                        .background(uiTheme.getItemSlotTheme().getTheme().getBackground(),
+                                GTGuiTextures.PRIMITIVE_FURNACE_OVERLAY)
+                        .margin(52, 0, 30, 0))
+
+                .child(new ItemSlot().syncHandler(new ItemSlotSyncHandler(
+                        new ModularSlot(exportItems.storage, 0)
+                                .slotGroup(new SlotGroup("export_items", 1))
+                                .accessibility(false, true)))
+                        .background(uiTheme.getItemSlotTheme().getTheme().getBackground(),
+                                GTGuiTextures.PRIMITIVE_FURNACE_OVERLAY)
+                        .margin(103, 0, 30, 0))
+                .child(new ProgressWidget()
+                        .value(progressPercent)
+                        .size(20, 15)
+                        .texture(GTGuiTextures.PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR, 18)
+                        .margin(76, 32))
+
+                .child(createTankWidget()
+                        .overlay(GTGuiTextures.PRIMITIVE_LARGE_FLUID_TANK_OVERLAY)
+                        .background(GTGuiTextures.PRIMITIVE_LARGE_FLUID_TANK)
+                        .syncHandler(new FluidSlotSyncHandler(
+                                exportFluids.getStorages()[0])
+                                .canFillSlot(false))
+                        .margin(134, 0, 13, 0))
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 176, (UITexture) uiTheme.getPanelTheme().getTheme()
+                        .getBackground()))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
     @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 292be3ff768..99df2796fb5 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,33 @@
 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.feature.multiblock.IFluidRenderMulti;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.ItemSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+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,7 +38,6 @@
 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;
@@ -39,6 +46,7 @@
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
@@ -47,7 +55,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class PrimitiveBlastFurnaceMachine extends PrimitiveWorkableMachine implements IUIMachine, IFluidRenderMulti {
+public class PrimitiveBlastFurnaceMachine extends PrimitiveWorkableMachine implements IMuiMachine, IFluidRenderMulti {
 
     private TickableSubscription hurtSubscription;
 
@@ -146,32 +154,74 @@ 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 ModularPanel buildUI(PosGuiData data, 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();
+                }));
+
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 166)
+                // Top half of the screen
+                .child(createImportItemSlot(syncManager, theme).margin(52, 16))
+                .child(new ProgressWidget()
+                        .value(progressPercent)
+                        .size(20, 15)
+                        .texture(GTGuiTextures.PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR, 0).margin(77, 35))
+                .child(createExportItemSlot(syncManager, theme).margin(104, 0, 34, 0))
+
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 176, (UITexture) theme.getPanelTheme().getTheme()
+                        .getBackground()))
+                .child(SlotGroupWidget
+                        .playerInventory(false).left(7)
+                        .bottom(7));
+    }
+
+    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().getTheme().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().getTheme().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
index 1dc01efe414..5c245a7fd5f 100644
--- 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
@@ -3,6 +3,7 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
 
+// TODO figure out how this should work with mui
 public class PrimitiveFancyUIWorkableMachine extends PrimitiveWorkableMachine implements IFancyUIMachine {
 
     public PrimitiveFancyUIWorkableMachine(BlockEntityCreationInfo info) {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveWorkableMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveWorkableMachine.java
index 69e17bf6007..0c525dd8c36 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveWorkableMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveWorkableMachine.java
@@ -4,21 +4,23 @@
 import com.gregtechceu.gtceu.api.capability.recipe.FluidRecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardEmitter;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.common.data.GTMedicalConditions;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraftforge.fluids.FluidType;
 
+import lombok.Getter;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class PrimitiveWorkableMachine extends WorkableMultiblockMachine
-                                      implements IEnvironmentalHazardEmitter {
+public class PrimitiveWorkableMachine extends WorkableMultiblockMachine {
 
     @SaveField
     public final NotifiableItemStackHandler importItems;
@@ -29,12 +31,17 @@ public class PrimitiveWorkableMachine extends WorkableMultiblockMachine
     @SaveField
     public final NotifiableFluidTank exportFluids;
 
+    @Getter
+    private final EnvironmentalHazardEmitterTrait hazardEmitter;
+
     public PrimitiveWorkableMachine(BlockEntityCreationInfo info) {
         super(info);
         this.importItems = createImportItemHandler();
         this.exportItems = createExportItemHandler();
         this.importFluids = createImportFluidHandler();
         this.exportFluids = createExportFluidHandler();
+        this.hazardEmitter = new EnvironmentalHazardEmitterTrait(this, GTMedicalConditions.CARBON_MONOXIDE_POISONING,
+                0.1f);
     }
 
     //////////////////////////////////////
@@ -66,14 +73,9 @@ public void onMachineDestroyed() {
         exportItems.dropInventoryInWorld();
     }
 
-    @Override
-    public float getHazardStrengthPerOperation() {
-        return 0.1f;
-    }
-
     @Override
     public void afterWorking() {
         super.afterWorking();
-        spreadEnvironmentalHazard();
+        hazardEmitter.emitHazard();
     }
 }
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 3256314df3d..fe1d0322c55 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,33 +3,48 @@
 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.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.StringSyncValue;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.ingredient.FluidIngredient;
 import com.gregtechceu.gtceu.api.recipe.modifier.ModifierFunction;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 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.MethodsReturnNonnullByDefault;
 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;
@@ -45,7 +60,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class LargeBoilerMachine extends WorkableMultiblockMachine implements IDisplayUIMachine {
+public class LargeBoilerMachine extends WorkableMultiblockMachine implements IMuiMachine {
 
     public static final int TICKS_PER_STEAM_GENERATION = 5;
 
@@ -202,40 +217,150 @@ public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @Not
         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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 176);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(Flow.row()
+                                .child(getMainTextPanel(syncManager, 170, 84))))
+                .child(Flow.column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 4, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .excludeAreaInRecipeViewer()
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+        return panel;
+    }
+
+    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)
+                .alignX(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);
+
+        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(new TextFieldWidget()
+                        .left(18).right(18)
+                        .setTextAlignment(Alignment.Center)
+                        .setTextColor(Color.WHITE.darker(1))
+                        .setNumbers(25, 100)
+                        .onMouseScrolled((mouseX, mouseY, delta) -> {
+                            int inc = (int) delta;
+                            int val = Mth.clamp(syncValue.getIntValue() + inc, 25, 100);
+                            syncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .value(formattedValue))
+                .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..fa6e0c5c9ca 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,54 +4,58 @@
 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;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
+import com.gregtechceu.gtceu.api.mui.drawable.Icon;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.RecipeHelper;
 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.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.data.mui.GTMultiblockTextUtil;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 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 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 +82,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;
                     }
@@ -128,56 +133,111 @@ public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @Not
                 .build();
     }
 
-    @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()));
-            }
+    /*
+     * @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)));
+     * }
+     * }
+     * }
+     */
 
-            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"));
-            }
+    /*
+     * @Override
+     * public IGuiTexture getScreenTexture() {
+     * return GuiTextures.DISPLAY_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks);
+     * }
+     */
 
-            if (recipeLogic.isWaiting()) {
-                textList.add(Component.translatable("gtceu.multiblock.steam.low_steam")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-            }
-        }
-    }
+    /*
+     * @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));
+     * }
+     */
 
     @Override
-    public IGuiTexture getScreenTexture() {
-        return GuiTextures.DISPLAY_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks);
-    }
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 164);
+
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>()
+                .width(170 - 6)
+                .height(70 - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .alignX(Alignment.CenterLeft);
+        parentWidget.size(170, 70)
+                .background(GTGuiTextures.MUI_DISPLAY);
+
+        listWidget.child(GTMultiblockTextUtil.addSteamUsageLine(this.steamEnergy, syncManager))
+                .child(GTMultiblockTextUtil.addProgressLine(this, syncManager))
+                .child(GTMultiblockTextUtil.addParallelLine(this, syncManager))
+                .child(GTMultiblockTextUtil.addOutputLines(this, syncManager));
+
+        parentWidget.child(listWidget.left(3).top(3));
+
+        var theme = this.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
 
-    @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));
+        panel.child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(0.95f)
+                        .heightRel(.45f)
+                        .margin(4, 0)
+                        .left(3).top(5)
+                        .child(parentWidget))
+                .child(Flow.col()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(3, 5, 4, 4)
+                        .childPadding(2)
+                        .background(backgroundTexture.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createPowerButton(this, syncManager)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+
+        return panel;
     }
 }
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 78ee8dc9936..e954c354858 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,16 +3,23 @@
 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.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+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.ProgressTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.particles.ParticleTypes;
@@ -75,14 +82,46 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings 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();
+                }));
+
+        return super.buildUI(data, syncManager, settings)
+                .child(new 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)
+                                .displayAmount(false)));
     }
 
+    /*
+     * @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)));
+     * }
+     */
+
     @Override
     protected void randomDisplayTick(RandomSource random, float x, float y, float z) {
         super.randomDisplayTick(random, x, y, z);
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 664a0cb5a73..29f075a9456 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,43 @@
 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.steam.SteamWorkableMachine;
+import com.gregtechceu.gtceu.api.machine.trait.ExhaustVentMachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
-import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.trait.miner.SteamMinerLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -47,13 +51,9 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class SteamMinerMachine extends SteamWorkableMachine implements IControllable, IExhaustVentMachine,
-                               IUIMachine, IDataInfoProvider, IMiner {
+public class SteamMinerMachine extends SteamWorkableMachine implements IControllable,
+                               IDataInfoProvider, IMiner, IMuiMachine {
 
-    @Getter
-    @SaveField
-    @SyncToClient
-    private boolean needsVenting;
     @SaveField
     public final NotifiableItemStackHandler importItems;
     @SaveField
@@ -65,6 +65,9 @@ public class SteamMinerMachine extends SteamWorkableMachine implements IControll
     @Nullable
     protected ISubscription exportItemSubs;
 
+    @Getter
+    private final ExhaustVentMachineTrait exhaustVentTrait;
+
     public SteamMinerMachine(BlockEntityCreationInfo info, boolean isHighPressure, int speed, int maximumRadius,
                              int fortune, int energyPerTick) {
         super(info, isHighPressure, (m) -> new SteamMinerLogic(m, fortune, speed, maximumRadius));
@@ -73,6 +76,9 @@ public SteamMinerMachine(BlockEntityCreationInfo info, boolean isHighPressure, i
         this.energyPerTick = energyPerTick;
         this.importItems = createImportItemHandler();
         this.exportItems = createExportItemHandler();
+        this.exhaustVentTrait = new ExhaustVentMachineTrait(this);
+        exhaustVentTrait.setVentingDirection(Direction.UP);
+        exhaustVentTrait.setVentingDamageAmount(isHighPressure() ? 12F : 6F);
     }
 
     @Override
@@ -143,62 +149,68 @@ protected void autoOutput() {
         updateAutoOutputSubscription();
     }
 
-    public void setNeedsVenting(boolean venting) {
-        this.needsVenting = venting;
-        syncDataHolder.markClientSyncFieldDirty("needsVenting");
-    }
-
     //////////////////////////////////////
     // *********** 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())));
-            }
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var theme = getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
         }
 
-        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));
-
-        return builder;
-    }
-
-    void addDisplayText(List<Component> textList) {
+        return new ModularPanel(getDefinition().getName())
+                .width(200)
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 200))
+                .bindPlayerInventory()
+                .child(Flow.row()
+                        .coverChildrenHeight()
+                        .margin(5)
+                        .childPadding(5)
+                        .widthRel(1f)
+                        .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).alignX(0.875f).alignY(0.5f)));
+    }
+
+    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));
-        if (isVentingBlocked())
+                    .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
+        if (exhaustVentTrait.isVentingBlocked())
             textList.add(Component.translatable("gtceu.multiblock.large_miner.vent")
                     .withStyle(ChatFormatting.RED));
         else if (!drainInput(true))
@@ -206,16 +218,10 @@ 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;
-        if (!this.isVentingBlocked() && resultSteam >= 0L && resultSteam <= steamTank.getTankCapacity(0)) {
+        if (!exhaustVentTrait.isVentingBlocked() && resultSteam >= 0L && resultSteam <= steamTank.getTankCapacity(0)) {
             if (!simulate)
                 steamTank.drainInternal(energyPerTick, IFluidHandler.FluidAction.EXECUTE);
             return true;
@@ -223,22 +229,6 @@ public boolean drainInput(boolean simulate) {
         return false;
     }
 
-    @Override
-    public @NotNull Direction getVentingDirection() {
-        return Direction.UP;
-    }
-
-    @Override
-    public void markVentingComplete() {
-        this.needsVenting = false;
-    }
-
-    @Override
-    public float getVentingDamage() {
-        return isHighPressure() ? 12F : 6F;
-    }
-
-    @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 ccd6bb5309e..b864e352861 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,22 @@
 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.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+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 org.jetbrains.annotations.NotNull;
 
@@ -68,17 +71,22 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings 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;
+                }));
+
+        return super.buildUI(data, syncManager, settings)
+                .child(new ProgressWidget()
+                        .top(30).right(18)
+                        .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 65601e402c6..3cf0ea7a254 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,21 +6,24 @@
 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.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.DoubleSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ProgressWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 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;
@@ -68,7 +71,7 @@ public SteamSolidBoilerMachine(BlockEntityCreationInfo info, boolean isHighPress
     //////////////////////////////////////
 
     protected NotifiableItemStackHandler createFuelHandler() {
-        return new NotifiableItemStackHandler(this, 1, IO.IN, IO.IN);
+        return new NotifiableItemStackHandler(this, 1, IO.IN, IO.BOTH);
     }
 
     protected NotifiableItemStackHandler createAshHandler() {
@@ -121,21 +124,51 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings 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();
+                }));
+
+        return super.buildUI(data, syncManager, settings)
+                .child(new Column()
+                        .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))));
     }
 
+    /*
+     * @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));
+     * }
+     */
+
     @Override
     public void onMachineDestroyed() {
         super.onMachineDestroyed();
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 31fee41b765..9d9f3ca05a1 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,23 +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.TieredMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.trait.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 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 com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
 import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
@@ -26,7 +37,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class BufferMachine extends TieredMachine implements IFancyUIMachine {
+public class BufferMachine extends TieredMachine implements IMuiMachine {
 
     public static final int TANK_SIZE = 64000;
 
@@ -73,32 +84,93 @@ protected NotifiableFluidTank createTank() {
     // ********** 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 @NotNull ModularPanel buildUI(@NotNull PosGuiData data, @NotNull PanelSyncManager syncManager,
+                                         @NotNull 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++) {
+            var row = new StringBuilder(size + 1);
+            for (int j = 0; j < size; j++) {
+                row.append("I");
+            }
+            row.append("F");
+            matrix[i] = row.toString();
         }
 
-        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();
+
+        return new ModularPanel(this.getDefinition().getName())
+                .size(176, 100 + (18 * size))
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(new ParentWidget<>()
+                        .widthRel(1)
+                        .height(20 + 18 * size)
+                        .child(Flow.row()
+                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                .align(Alignment.CENTER)
+                                .coverChildren()
+                                .child(slotWidget
+                                        .marginLeft(30)
+                                        .marginRight(30)
+                                        .verticalCenter())))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7))
+                .child(new Column()
+                        .coverChildren()
+                        .leftRel(1.0f)
+                        .reverseLayout(true)
+                        .bottom(16)
+                        .padding(0, 8, 4, 4)
+                        .childPadding(2)
+                        .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                        .child(GTMuiWidgets.createAutoOutputItemButton(autoOutput, syncManager))
+                        .child(GTMuiWidgets.createAutoOutputFluidButton(autoOutput, syncManager))
+                        .child(GTMuiWidgets.createInputFromOutputItem(autoOutput, syncManager))
+                        .child(GTMuiWidgets.createInputFromOutputFluid(autoOutput, syncManager))
+                        .excludeAreaInRecipeViewer());
     }
+    /*
+     * @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));
+     * }
+     * }
+     *
+     * 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));
+     * }
+     *
+     * container.setBackground(GuiTextures.BACKGROUND_INVERSE);
+     * group.addWidget(container);
+     * return group;
+     * }
+     */
 
     ////////////////////////////////
     // ********** Misc ***********//
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 11b1a93ff98..18ca26f21f4 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,20 +3,24 @@
 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.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTItems;
-
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -38,7 +42,8 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class CrateMachine extends MetaMachine implements IUIMachine, IDropSaveMachine {
+public class CrateMachine extends MetaMachine implements IMuiMachine,
+                          IDropSaveMachine {
 
     public static final BooleanProperty TAPED_PROPERTY = GTMachineModelProperties.IS_TAPED;
 
@@ -47,6 +52,8 @@ public class CrateMachine extends MetaMachine implements IUIMachine, IDropSaveMa
     @Getter
     private final int inventorySize;
     @Getter
+    private final int rowLength;
+    @Getter
     @RerenderOnChanged
     @SaveField
     @SyncToClient
@@ -55,36 +62,35 @@ 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 = new NotifiableItemStackHandler(this, 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        syncManager.registerSlotGroup("item_inv", inventorySize);
+
+        int rows = inventorySize / rowLength;
+        ParentWidget<?> slots = new ParentWidget<>();
+        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;
+
+        return GTGuis.createPanel(this, rowLength * 18 + 14, 18 + 4 * 18 + 5 + 14 + 18 * rows)
+                .background(GTGuiTextures.BACKGROUND)
+                .child(IKey.lang(getBlockState().getBlock().getName()).asWidget().pos(5, 5))
+                .child(slots.top(18).left(7).right(7).height(rows * 18))
+                .bindPlayerInventory();
     }
 
     @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 ec436be4bfa..a23f95bedd0 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,17 +2,10 @@
 
 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.MetaMachine;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 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.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
@@ -105,35 +98,36 @@ public InteractionResult onUse(BlockState state, Level world, BlockPos pos, Play
         return super.onUse(state, world, pos, player, hand, hit);
     }
 
-    @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;
-    }
-
+    /*
+     * @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;
+     * }
+     */
     private class InfiniteCache extends ItemCache {
 
         public InfiniteCache(MetaMachine holder) {
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..ee9e8fd7da2 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
@@ -2,22 +2,26 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 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.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 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 com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.entity.player.Player;
 
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
@@ -30,7 +34,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class CreativeComputationProviderMachine extends MetaMachine
-                                                implements IUIMachine, IOpticalComputationProvider {
+                                                implements IMuiMachine, IOpticalComputationProvider {
 
     @SaveField
     private int maxCWUt;
@@ -98,20 +102,50 @@ public void setActive(boolean active) {
         updateComputationSubscription();
     }
 
+    public void setMaxCWUt(int maxCWUt) {
+        this.maxCWUt = maxCWUt;
+        syncDataHolder.markClientSyncFieldDirty("maxCWUt");
+    }
+
     @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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return new ModularPanel(this.getDefinition().getName())
+                .height(100)
+                .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                .child(Flow.column()
+                        .padding(10)
+                        .childPadding(5)
+                        .child(Flow.row()
+                                .alignX(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(this::getMaxCWUt, this::setMaxCWUt))))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .alignX(0)
+                                .childPadding(5)
+                                .coverChildren()
+                                .child(new TextWidget<>(IKey.lang("gtceu.creative.computation.average",
+                                        () -> new Object[] { lastRequestedCWUt }))))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .alignX(0)
+                                .childPadding(5)
+                                .coverChildren()
+                                .child(new ToggleButton()
+                                        .value(new BooleanSyncValue(this::isActive, this::setActive))
+                                        .selectedBackground(GTGuiTextures.BUTTON_POWER[1])
+                                        .background(GTGuiTextures.BUTTON_POWER[0])
+                                        .tooltipAutoUpdate(true)
+                                        .tooltipBuilder((r) -> r.addLine(IKey.lang(() -> this.isActive() ?
+                                                "behaviour.soft_hammer.enabled" :
+                                                "behaviour.soft_hammer.disabled"))))
+                                .child(new TextWidget<>(IKey
+                                        .lang(() -> "gtceu.creative.activity." + (this.isActive() ? "on" : "off"))))));
     }
 }
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..f3a31bba910 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
@@ -5,33 +5,46 @@
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 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.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.DynamicDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.Rectangle;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.MouseData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.IntSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.Dialog;
+import com.gregtechceu.gtceu.api.mui.widgets.ListWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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 javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class CreativeEnergyContainerMachine extends TieredMachine implements ILaserContainer, IUIMachine {
+public class CreativeEnergyContainerMachine extends TieredMachine implements ILaserContainer, IMuiMachine {
 
     @SaveField
     private long voltage = 0;
@@ -180,62 +193,190 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        // syncing
+        LongSyncValue voltage = new LongSyncValue(() -> this.voltage, (v) -> this.voltage = v);
+        IntSyncValue amps = new IntSyncValue(() -> this.amps, (a) -> this.amps = a < 1 ? 1 : a);
+        IntSyncValue tier = new IntSyncValue(() -> this.tier, (t) -> this.setTier = t);
+        BooleanSyncValue sourceSync = new BooleanSyncValue(() -> this.source, (b) -> this.source = b);
+        BooleanSyncValue isActive = new BooleanSyncValue(() -> this.active, (b) -> this.active = b);
+        syncManager.syncValue("tier", tier);
+
+        IPanelHandler panelSyncHandler = syncManager.syncedPanel("voltage popup", false,
+                (manager, handler) -> createAmpSelector(voltage, tier));
+
+        return new ModularPanel("main panel")
+                .coverChildrenHeight()
+                .width(166)
+                .background(GTGuiTextures.BACKGROUND)
+                .child(new Column()
+                        .widthRel(1)
+                        .name("main")
+                        .padding(7)
+                        .mainAxisAlignment(Alignment.MainAxis.START)
+                        .coverChildrenHeight()
+                        .child(GTMuiWidgets.createTitleBar(this.getDefinition(), 176))
+                        .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))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(new Row()
+                                .coverChildrenHeight()
+                                .name("Power")
+                                .coverChildrenHeight()
+                                .child(new ToggleButton()
+                                        .value(isActive)
+                                        .overlay(true, GTGuiTextures.BUTTON_POWER[1])
+                                        .overlay(false, GTGuiTextures.BUTTON_POWER[0]))
+                                .child(IKey.str("Enable")
+                                        .asWidget()
+                                        .paddingLeft(4)
+
+                                )));
+    }
+
+    private Flow createVoltageRow(IPanelHandler panel, LongSyncValue voltage) {
+        return Flow.row()
+                .coverChildrenHeight()
+                .paddingBottom(4)
+                .child(new TextFieldWidget()
+                        .setTextAlignment(Alignment.CENTER)
+                        .setNumbersLong(() -> 1, () -> Long.MAX_VALUE)
+                        .value(voltage))
+                .child(new ButtonWidget<>()
+                        .height(16)
+                        .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;
+                        })
+
+                )
+                .child(IKey.str("Voltage").asWidget()
+                        .anchorRight(0)
+                        .paddingRight(4)
+                        .verticalCenter()
+
+                );
+    }
+
+    static Flow createAmpRow(IntSyncValue amps) {
+        return Flow.row()
+                .coverChildrenHeight()
+                .child(
+                        new TextFieldWidget()
+                                .setTextAlignment(Alignment.CENTER)
+                                .setNumbers(1, Integer.MAX_VALUE)
+                                .value(amps)
+                                .setDefaultNumber(1))
+                .child(IKey.lang("gtceu.creative.energy.amperage")
+                        .asWidget()
+                        .anchorRight(0)
+                        .paddingRight(4)
+                        .verticalCenter())
+                .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(32)
+                        .height(16)
+                        .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 GTGuiTextures.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 GTGuiTextures.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")
+                .setDisablePanelsBelow(false)
+                .setDraggable(true)
+                .setCloseOnOutOfBoundsClick(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 d7e5cd1972a..7e485409624 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,16 +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.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
-
-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 com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -135,33 +133,41 @@ public InteractionResult onUse(BlockState state, Level world, BlockPos pos, Play
     }
 
     @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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        // TODO
+        return super.buildUI(data, syncManager, settings)
+                .child(GTMuiWidgets.createPowerButton(this::isWorkingEnabled, this::setWorkingEnabled, syncManager));
     }
 
+    /*
+     * 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;
+     * }
+     */
+
     private class InfiniteCache extends FluidCache {
 
         public InfiniteCache(MetaMachine holder) {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/LongDistanceEndpointMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/LongDistanceEndpointMachine.java
index 5ab331b46a8..abd4454b021 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/LongDistanceEndpointMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/LongDistanceEndpointMachine.java
@@ -9,7 +9,7 @@
 import com.gregtechceu.gtceu.api.pipenet.longdistance.LongDistanceNetwork;
 import com.gregtechceu.gtceu.api.pipenet.longdistance.LongDistancePipeType;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
-import com.gregtechceu.gtceu.common.item.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
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 64f5ad3c7fd..487c348ebd0 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,36 +3,48 @@
 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.MetaMachine;
 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.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.PhantomItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
 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.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-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;
@@ -57,7 +69,7 @@
 
 @NotNullByDefault
 public class QuantumChestMachine extends TieredMachine implements IControllable,
-                                 IDropSaveMachine, IFancyUIMachine {
+                                 IDropSaveMachine, IMuiMachine {
 
     /**
      * Sourced from FunctionalStorage's
@@ -242,50 +254,106 @@ 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 ModularPanel buildUI(PosGuiData data, 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);
+
+        return new ModularPanel(this.getDefinition().getName())
+                .child(
+                        // Top half of the screen
+                        new ParentWidget<>()
+                                .widthRel(1)
+                                .height(20 + 60)
+                                // Box that has the display texture BG +
+                                // the buttons / text / etc
+                                .child(new ParentWidget<>()
+                                        .background(GTGuiTextures.DISPLAY)
+                                        .size(90, 63)
+                                        .align(Alignment.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(createAutoOutputItemButton(syncManager))
+                                                .child(createItemLockButton(syncManager))
+                                                .child(createVoidButton(syncManager)))
+                                        .child(Flow.column()
+                                                .margin(68, 0, 15, 0)
+                                                .coverChildren()
+                                                .child(createItemSlot(syncManager))
+                                                .child(createPhantomLockeditemSlot(syncManager))))
+
+                )
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 176, GTGuiTextures.BACKGROUND))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+    }
+
+    private ToggleButton createAutoOutputItemButton(PanelSyncManager syncManager) {
+        BooleanSyncValue itemOutputs = new BooleanSyncValue(this.autoOutput::isAutoOutputItems,
+                this.autoOutput::setAllowAutoOutputItems);
+        syncManager.syncValue("auto_output_items", itemOutputs);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(itemOutputs::getBoolValue, itemOutputs::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_ITEM_OUTPUT)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder(
+                        (r) -> r.addLine(IKey.lang(Component.translatable("gtceu.machine.quantum_chest.items_stored",
+                                Component.translatable(itemOutputs.getBoolValue() ? "cover.voiding.label.enabled" :
+                                        "cover.voiding.label.disabled")))));
+    }
+
+    private ToggleButton createItemLockButton(PanelSyncManager syncManager) {
+        BooleanSyncValue itemLocked = new BooleanSyncValue(this::isLocked,
+                this::setLocked);
+        syncManager.syncValue("item_locked", itemLocked);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(itemLocked::getBoolValue, itemLocked::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_LOCK)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(itemLocked.getBoolValue() ?
+                        "gtceu.gui.item_lock.tooltip.enabled" :
+                        "gtceu.gui.item_lock.tooltip.disabled")));
+    }
+
+    private ToggleButton createVoidButton(PanelSyncManager syncManager) {
+        BooleanSyncValue voiding = new BooleanSyncValue(() -> this.isVoiding,
+                (voidingBool) -> { this.isVoiding = voidingBool; });
+        syncManager.syncValue("is_voiding", voiding);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(voiding::getBoolValue, voiding::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_VOID)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(voiding.getBoolValue() ?
+                        "gtceu.gui.item_voiding_partial.tooltip.enabled" :
+                        "gtceu.gui.item_voiding_partial.tooltip.disabled")));
+    }
+
+    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");
     }
 
     private @NotNull CustomItemStackHandler createImportItems() {
@@ -306,8 +374,8 @@ public Widget createUIWidget() {
     // ******* 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 dfaa3c775fb..2535d215dfa 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,33 +3,43 @@
 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.AutoOutputTrait;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.FluidSlotSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.LongSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
 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.CustomFluidTank;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 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.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;
@@ -38,6 +48,7 @@
 import net.minecraft.world.phys.BlockHitResult;
 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;
 
@@ -51,8 +62,8 @@
 import java.util.function.Predicate;
 
 @NotNullByDefault
-public class QuantumTankMachine extends TieredMachine implements IControllable,
-                                IDropSaveMachine, IFancyUIMachine {
+public class QuantumTankMachine extends TieredMachine implements IDropSaveMachine, IControllable,
+                                IMuiMachine {
 
     public static Object2LongMap<MachineDefinition> TANK_CAPACITY = new Object2LongArrayMap<>();
 
@@ -202,35 +213,85 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        LongSyncValue bucketSyncer = new LongSyncValue(this::getStoredAmount, (ignored) -> {});
+        syncManager.syncValue("bucket_amount", bucketSyncer);
+
+        return new ModularPanel(this.getDefinition().getName())
+                .child(
+                        // Top half of the screen
+                        new ParentWidget<>()
+                                .widthRel(1)
+                                .height(20 + 60)
+                                // Box that has the display texture BG +
+                                // the buttons / text / etc
+                                .child(new ParentWidget<>()
+                                        .background(GTGuiTextures.DISPLAY)
+                                        .size(90, 63)
+                                        .align(Alignment.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,
+                                                        syncManager))
+                                                .child(createFluidLockButton(syncManager))
+                                                .child(createVoidButton(syncManager)))
+                                        .child(Flow.column()
+                                                .margin(68, 0, 23, 0)
+                                                .coverChildren()
+                                                .child(createFluidSlot(syncManager))
+                                                .child(createPhantomLockedFluidSlot(syncManager)))))
+                .child(GTMuiWidgets.createTitleBar(getDefinition(), 176, GTGuiTextures.BACKGROUND))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+    }
+
+    private ToggleButton createFluidLockButton(PanelSyncManager syncManager) {
+        BooleanSyncValue fluidLocked = new BooleanSyncValue(this::isLocked,
+                this::setLocked);
+        syncManager.syncValue("fluid_locked", fluidLocked);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(fluidLocked::getBoolValue, fluidLocked::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_LOCK)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(fluidLocked.getBoolValue() ?
+                        "gtceu.gui.fluid_lock.tooltip.enabled" :
+                        "gtceu.gui.fluid_lock.tooltip.disabled")));
+    }
+
+    private ToggleButton createVoidButton(PanelSyncManager syncManager) {
+        BooleanSyncValue voiding = new BooleanSyncValue(() -> this.isVoiding,
+                (voidingBool) -> { this.isVoiding = voidingBool; });
+        syncManager.syncValue("is_voiding", voiding);
+        return new ToggleButton()
+                .value(new BoolValue.Dynamic(voiding::getBoolValue, voiding::setBoolValue))
+                .overlay(GTGuiTextures.BUTTON_VOID)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(voiding.getBoolValue() ?
+                        "gtceu.gui.fluid_voiding_partial.tooltip.enabled" :
+                        "gtceu.gui.fluid_voiding_partial.tooltip.disabled")));
+    }
+
+    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 {
@@ -313,4 +374,48 @@ public void exportToNearby(@NotNull Direction... facings) {
             }
         }
     }
+
+    protected class FluidCacheTankWrapper implements IFluidTank {
+
+        private final FluidCache cache;
+
+        public FluidCacheTankWrapper(FluidCache cache) {
+            this.cache = cache;
+        }
+
+        @Override
+        public @NotNull 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 @NotNull FluidStack drain(int i, IFluidHandler.FluidAction fluidAction) {
+            return cache.drain(i, fluidAction);
+        }
+
+        @Override
+        public @NotNull FluidStack drain(FluidStack fluidStack, IFluidHandler.FluidAction fluidAction) {
+            return cache.drain(fluidStack, fluidAction);
+        }
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/CentralMonitorLogic.java b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/CentralMonitorLogic.java
index 0d4b9cec954..57636fa2525 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/CentralMonitorLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/CentralMonitorLogic.java
@@ -9,6 +9,8 @@
 
 import net.minecraft.util.Mth;
 
+import org.jetbrains.annotations.NotNull;
+
 public class CentralMonitorLogic extends RecipeLogic implements IWorkable {
 
     private static final int BASE_UPDATE_INTERVAL = 8 * 20;
@@ -17,7 +19,7 @@ public CentralMonitorLogic(IRecipeLogicMachine machine) {
         super(machine);
     }
 
-    public CentralMonitorMachine getMachine() {
+    public @NotNull CentralMonitorMachine getMachine() {
         return (CentralMonitorMachine) machine;
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/ArcFurnaceLogic.java b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/ArcFurnaceLogic.java
index 5a9d9c32d3e..05b6059f338 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/ArcFurnaceLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/ArcFurnaceLogic.java
@@ -13,7 +13,7 @@
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterialItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.TurbineRotorBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.TurbineRotorBehaviour;
 
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/MaceratorLogic.java b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/MaceratorLogic.java
index e1eea214c9c..a2f219c094f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/MaceratorLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/customlogic/MaceratorLogic.java
@@ -13,7 +13,7 @@
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterialItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.TurbineRotorBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.TurbineRotorBehaviour;
 
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
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 bd52ba3ec2b..0ca49abb045 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
@@ -14,6 +14,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;
@@ -68,12 +69,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
@@ -89,12 +93,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;
@@ -109,8 +116,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;
@@ -271,6 +280,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());
@@ -434,6 +446,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();
 
@@ -455,11 +470,15 @@ private void mineAndInsertItems(NonNullList<ItemStack> blockDrops, ServerLevel w
     public void initPos(@NotNull 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();
@@ -470,11 +489,14 @@ public void initPos(@NotNull 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");
         onRemove();
     }
 
@@ -561,6 +583,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/machine/trait/miner/SteamMinerLogic.java b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/SteamMinerLogic.java
index 5e5753a1e5d..3435e999ebf 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/SteamMinerLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/SteamMinerLogic.java
@@ -1,10 +1,12 @@
 package com.gregtechceu.gtceu.common.machine.trait.miner;
 
-import com.gregtechceu.gtceu.api.machine.feature.IExhaustVentMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
+import com.gregtechceu.gtceu.common.machine.steam.SteamMinerMachine;
 
 public class SteamMinerLogic extends MinerLogic {
 
+    private final SteamMinerMachine steamMiner;
+
     /**
      * Creates the logic for steam miners
      *
@@ -15,17 +17,17 @@ public class SteamMinerLogic extends MinerLogic {
      */
     public SteamMinerLogic(IRecipeLogicMachine metaTileEntity, int fortune, int speed, int maximumRadius) {
         super(metaTileEntity, fortune, speed, maximumRadius);
+        steamMiner = (SteamMinerMachine) metaTileEntity;
     }
 
     @Override
     protected boolean checkCanMine() {
-        IExhaustVentMachine machine = (IExhaustVentMachine) this.machine;
-        return super.checkCanMine() && machine.checkVenting();
+        return super.checkCanMine() && steamMiner.getExhaustVentTrait().checkVenting();
     }
 
     @Override
     protected void onMineOperation() {
         super.onMineOperation();
-        ((IExhaustVentMachine) machine).setNeedsVenting(true);
+        steamMiner.getExhaustVentTrait().setNeedsVenting(true);
     }
 }
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..8b1848cd82f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTextures.java
@@ -0,0 +1,900 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.mui.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.drawable.ColorType;
+import com.gregtechceu.gtceu.api.mui.drawable.TabTexture;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+
+import net.minecraft.resources.ResourceLocation;
+
+import org.jetbrains.annotations.NotNull;
+
+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 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 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 IDrawable PLUS = IKey.str("+").asIcon().marginLeft(1);
+    // public static final IDrawable MINUS = IKey.str("-").asIcon().marginLeft(1);
+
+    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[] 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_DISTINCT = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/button_distinct_buses.png")
+            .subAreaXYWH(0, 0, 16, 16)
+            .build();
+
+    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);
+
+    // BASE MUI2
+
+    public static final UITexture GEAR = fullImage("textures/gui/icon/mui2/gear.png");
+    public static final UITexture MORE = fullImage("textures/gui/icon/mui2/more.png");
+    public static final UITexture SAVED = fullImage("textures/gui/icon/mui2/saved.png");
+    public static final UITexture SAVE = fullImage("textures/gui/icon/mui2/save.png");
+    public static final UITexture ADD = fullImage("textures/gui/icon/mui2/add.png");
+    public static final UITexture DUPE = fullImage("textures/gui/icon/mui2/dupe.png");
+    public static final UITexture REMOVE = fullImage("textures/gui/icon/mui2/remove.png");
+    public static final UITexture POSE = fullImage("textures/gui/icon/mui2/pose.png");
+    public static final UITexture FILTER = fullImage("textures/gui/icon/mui2/filter.png");
+    public static final UITexture MOVE_UP = fullImage("textures/gui/icon/mui2/move_up.png");
+    public static final UITexture MOVE_DOWN = fullImage("textures/gui/icon/mui2/move_down.png");
+    public static final UITexture LOCKED = fullImage("textures/gui/icon/mui2/locked.png");
+    public static final UITexture UNLOCKED = fullImage("textures/gui/icon/mui2/unlocked.png");
+    public static final UITexture COPY = fullImage("textures/gui/icon/mui2/copy.png");
+    public static final UITexture PASTE = fullImage("textures/gui/icon/mui2/paste.png");
+    public static final UITexture CUT = fullImage("textures/gui/icon/mui2/cut.png");
+    public static final UITexture REFRESH = fullImage("textures/gui/icon/mui2/refresh.png");
+
+    public static final UITexture DOWNLOAD = fullImage("textures/gui/icon/mui2/download.png");
+    public static final UITexture UPLOAD = fullImage("textures/gui/icon/mui2/upload.png");
+    public static final UITexture SERVER = fullImage("textures/gui/icon/mui2/server.png");
+    public static final UITexture FOLDER = fullImage("textures/gui/icon/mui2/folder.png");
+    public static final UITexture IMAGE = fullImage("textures/gui/icon/mui2/image.png");
+    public static final UITexture EDIT = fullImage("textures/gui/icon/mui2/edit.png");
+    public static final UITexture MATERIAL = fullImage("textures/gui/icon/mui2/material.png");
+    public static final UITexture CLOSE = fullImage("textures/gui/icon/mui2/close.png");
+    public static final UITexture LIMB = fullImage("textures/gui/icon/mui2/limb.png");
+    public static final UITexture CODE = fullImage("textures/gui/icon/mui2/code.png");
+    public static final UITexture MOVE_LEFT = fullImage("textures/gui/icon/mui2/move_left.png");
+    public static final UITexture MOVE_RIGHT = fullImage("textures/gui/icon/mui2/move_right.png");
+    public static final UITexture HELP = fullImage("textures/gui/icon/mui2/help.png");
+    public static final UITexture LEFT_HANDLE = fullImage("textures/gui/icon/mui2/left_handle.png");
+    public static final UITexture MAIN_HANDLE = fullImage("textures/gui/icon/mui2/main_handle.png");
+    public static final UITexture RIGHT_HANDLE = fullImage("textures/gui/icon/mui2/right_handle.png");
+    public static final UITexture REVERSE = fullImage("textures/gui/icon/mui2/reverse.png");
+    public static final UITexture BLOCK = fullImage("textures/gui/icon/mui2/block.png");
+
+    public static final UITexture FAVORITE = fullImage("textures/gui/icon/mui2/favorite.png");
+    public static final UITexture VISIBLE = fullImage("textures/gui/icon/mui2/visible.png");
+    public static final UITexture INVISIBLE = fullImage("textures/gui/icon/mui2/invisible.png");
+    public static final UITexture PLAY = fullImage("textures/gui/icon/mui2/play.png");
+    public static final UITexture PAUSE = fullImage("textures/gui/icon/mui2/pause.png");
+    public static final UITexture MAXIMIZE = fullImage("textures/gui/icon/mui2/maximize.png");
+    public static final UITexture MINIMIZE = fullImage("textures/gui/icon/mui2/minimize.png");
+    public static final UITexture STOP = fullImage("textures/gui/icon/mui2/stop.png");
+    public static final UITexture FULLSCREEN = fullImage("textures/gui/icon/mui2/fullscreen.png");
+    public static final UITexture ALL_DIRECTIONS = fullImage("textures/gui/icon/mui2/all_directions.png");
+    public static final UITexture SPHERE = fullImage("textures/gui/icon/mui2/sphere.png");
+    public static final UITexture SHIFT_TO = fullImage("textures/gui/icon/mui2/shift_to.png");
+    public static final UITexture SHIFT_FORWARD = fullImage("textures/gui/icon/mui2/shift_forward.png");
+    public static final UITexture SHIFT_BACKWARD = fullImage("textures/gui/icon/mui2/shift_backward.png");
+    public static final UITexture MOVE_TO = fullImage("textures/gui/icon/mui2/move_to.png");
+    public static final UITexture GRAPH = fullImage("textures/gui/icon/mui2/graph.png");
+
+    public static final UITexture WRENCH = fullImage("textures/gui/icon/mui2/wrench.png");
+    public static final UITexture EXCLAMATION = fullImage("textures/gui/icon/mui2/exclamation.png");
+    public static final UITexture LEFTLOAD = fullImage("textures/gui/icon/mui2/leftload.png");
+    public static final UITexture RIGHTLOAD = fullImage("textures/gui/icon/mui2/rightload.png");
+    public static final UITexture BUBBLE = fullImage("textures/gui/icon/mui2/bubble.png");
+    public static final UITexture FILE = fullImage("textures/gui/icon/mui2/file.png");
+    public static final UITexture PROCESSOR = fullImage("textures/gui/icon/mui2/processor.png");
+    public static final UITexture MAZE = fullImage("textures/gui/icon/mui2/maze.png");
+    public static final UITexture BOOKMARK = fullImage("textures/gui/icon/mui2/bookmark.png");
+    public static final UITexture SOUND = fullImage("textures/gui/icon/mui2/sound.png");
+    public static final UITexture SEARCH = fullImage("textures/gui/icon/mui2/search.png");
+
+    public static final UITexture CHECKBOARD = fullImage("textures/gui/icon/mui2/checkboard.png");
+    public static final UITexture DISABLED = fullImage("textures/gui/icon/mui2/disabled.png");
+    public static final UITexture CURSOR = fullImage("textures/gui/icon/mui2/cursor.png");
+
+    public static final UITexture MUI_LOGO = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/icon/modular_ui_logo.png")
+            .imageSize(603, 603)
+            .name("logo")
+            .build();
+
+    public static final UITexture MC_BUTTON = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/mc_button.png")
+            .imageSize(16, 32) // texture is 32x64, but this looks nicer
+            .subAreaUV(0f, 0f, 1f, 0.5f)
+            .adaptable(2).tiled()
+            .name("mc_button")
+            .defaultColorType()
+            .build();
+
+    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 UITexture MC_BUTTON_PRESSED = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/mc_button.png")
+            .imageSize(16, 32)
+            .subAreaUV(0f, 0.5f, 1f, 1f)
+            .adaptable(2).tiled()
+            .name("mc_button_pressed")
+            .defaultColorType()
+            .build();
+
+    public static final UITexture MC_BUTTON_HOVERED = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/mc_button_hovered.png")
+            .imageSize(16, 32)
+            .subAreaUV(0f, 0f, 1f, 0.5f)
+            .adaptable(2).tiled()
+            .name("mc_button_hovered")
+            .build();
+
+    public static final UITexture MC_BUTTON_HOVERED_PRESSED = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/mc_button_hovered.png")
+            .imageSize(16, 32)
+            .subAreaUV(0f, 0.5f, 1f, 1f)
+            .adaptable(2).tiled()
+            .name("mc_button_hovered_pressed")
+            .build();
+
+    public static final UITexture MC_BUTTON_DISABLED = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/mc_button_disabled.png")
+            .imageSize(16, 16)
+            .subAreaUV(0f, 0f, 1f, 0.5f)
+            .adaptable(1).tiled()
+            .name("mc_button_disabled")
+            .build();
+
+    public static final UITexture MUI_DISPLAY = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/mui_display.png")
+            .imageSize(143, 75)
+            .adaptable(2)
+            .name("display")
+            .build();
+
+    public static final UITexture MUI_DISPLAY_SMALL = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/mui_display_small.png")
+            .imageSize(18, 18)
+            .adaptable(1)
+            .name("display_small")
+            .build();
+
+    public static final UITexture CHECK_BOX = fullImage("textures/gui/icon/mui2/toggle_config.png");
+    public static final UITexture CROSS = fullImage("textures/gui/icon/mui2/cross.png");
+    public static final UITexture CROSS_TINY = fullImage("textures/gui/icon/mui2/cross_tiny.png");
+
+    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 TabTexture TAB_BOTTOM = TabTexture.of(
+            fullImage("textures/gui/tab/tabs_bottom.png", ColorType.DEFAULT),
+            GuiAxis.Y,
+            true, 28, 32, 4);
+    public static final TabTexture TAB_LEFT = TabTexture.of(
+            fullImage("textures/gui/tab/tabs_left.png", ColorType.DEFAULT),
+            GuiAxis.X, false,
+            32, 28, 4);
+    public static final TabTexture TAB_RIGHT = TabTexture.of(
+            fullImage("textures/gui/tab/tabs_right.png", ColorType.DEFAULT),
+            GuiAxis.X, true,
+            32, 28, 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..26a9f09276a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTheme.java
@@ -0,0 +1,419 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.base.IThemeApi;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.theme.ReloadThemeEvent;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetTheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeKey;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.utils.serialization.json.JsonBuilder;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+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();
+
+    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));
+    }
+
+    public static void registerThemes() {
+        MinecraftForge.EVENT_BUS.register(GTGuiTheme.class);
+        THEMES.forEach(GTGuiTheme::register);
+    }
+
+    @SubscribeEvent
+    public static void onReloadThemes(ReloadThemeEvent.Pre event) {
+        THEMES.forEach(GTGuiTheme::buildJson);
+    }
+
+    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/GTGuis.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuis.java
new file mode 100644
index 00000000000..e55977acc66
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuis.java
@@ -0,0 +1,143 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.cover.CoverBehavior;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+
+public class GTGuis {
+
+    public static final int DEFAULT_WIDTH = 176, DEFAULT_HEIGHT = 166;
+
+    public static ModularPanel createPanel(String name, int width, int height) {
+        return ModularPanel.defaultPanel(name, width, height);
+    }
+
+    public static ModularPanel createPanel(MetaMachine machine, int width, int height) {
+        return createPanel(machine.getDefinition().getId().getPath(), width, height);
+    }
+
+    public static ModularPanel createPanel(CoverBehavior cover, int width, int height) {
+        return createPanel(cover.coverDefinition.getId().getPath(), width, height);
+    }
+
+    public static ModularPanel createPanel(ItemStack stack, int width, int height) {
+        return createPanel(stack.getDescriptionId(), width, height);
+    }
+
+    public static ModularPanel createPanel(String name) {
+        return ModularPanel.defaultPanel(name, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+    }
+
+    public static ModularPanel defaultPanel(MetaMachine machine) {
+        return createPanel(machine.getDefinition().getId().getPath());
+    }
+
+    public static ModularPanel defaultPanel(CoverBehavior cover) {
+        return createPanel(cover.coverDefinition.getId().getPath());
+    }
+
+    public static ModularPanel defaultPanel(ItemStack stack) {
+        return createPanel(stack, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+    }
+
+    public static ModularPanel defaultPanel(Item item) {
+        return createPanel(item.getDescriptionId());
+    }
+
+    public static PopupPanel createPopupPanel(String name, int width, int height) {
+        return defaultPopupPanel(name)
+                .size(width, height);
+    }
+
+    public static PopupPanel createPopupPanel(String name, int width, int height, boolean deleteCachedPanel) {
+        return createPopupPanel(name, width, height)
+                .deleteCachedPanel(deleteCachedPanel);
+    }
+
+    public static PopupPanel defaultPopupPanel(String name) {
+        return new PopupPanel(name)
+                .size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+    }
+
+    public static PopupPanel defaultPopupPanel(String name, boolean disableBelow,
+                                               boolean closeOnOutsideClick, boolean deleteCachedPanel) {
+        return defaultPopupPanel(name)
+                .disablePanelsBelow(disableBelow)
+                .closeOnOutOfBoundsClick(closeOnOutsideClick)
+                .deleteCachedPanel(deleteCachedPanel);
+    }
+
+    public static class PopupPanel extends ModularPanel {
+
+        private boolean disableBelow;
+        private boolean closeOnOutsideClick;
+        private boolean deleteCachedPanel;
+
+        private PopupPanel(@NotNull String name) {
+            super(name);
+            align(Alignment.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 disablePanelsBelow(boolean disableBelow) {
+            this.disableBelow = disableBelow;
+            return this;
+        }
+
+        public PopupPanel closeOnOutOfBoundsClick(boolean closeOnOutsideClick) {
+            this.closeOnOutsideClick = closeOnOutsideClick;
+            return this;
+        }
+
+        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;
+        }
+
+        @Override
+        public boolean disablePanelsBelow() {
+            return disableBelow;
+        }
+
+        @Override
+        public boolean closeOnOutOfBoundsClick() {
+            return closeOnOutsideClick;
+        }
+    }
+}
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..b984182c3cb
--- /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.base.GuiAxis;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.value.IValue;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.BorderDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.DynamicDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.*;
+import com.gregtechceu.gtceu.api.mui.widgets.*;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ModularSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.machines.GTMultiMachines;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+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 net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.item.ItemStack;
+
+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.utils.serialization.network.ByteBufAdapters.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);
+        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(GTGuiTextures.EDIT)
+                            .hoverBackground(GTGuiTextures.EDIT, new BorderDrawable())
+                            .onMousePressed((mouseX, mouseY, button) -> {
+                                panelHandler.openPanel();
+                                return true;
+                            }))
+                    .child(new ButtonWidget<>()
+                            .background(GTGuiTextures.CLOSE)
+                            .hoverBackground(GTGuiTextures.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")
+                .setDraggable(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"))
+                                        .alignX(0))
+                                .child(new ButtonWidget<>()
+                                        .alignX(1)
+                                        .background(GTGuiTextures.MC_BUTTON, GTGuiTextures.ADD)
+                                        .hoverBackground(GTGuiTextures.MC_BUTTON_HOVERED, GTGuiTextures.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 ? GTGuiTextures.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 -> {
+                                            w.validateText();
+                                            return Integer.parseInt(w.getText());
+                                        },
+                                        IKey.lang("gtceu.central_monitor.gui.data_slot")).setDraggable(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() ?
+                                                        GTGuiTextures.MC_BUTTON_DISABLED :
+                                                        GTGuiTextures.MC_BUTTON),
+                                                GTGuiTextures.EDIT)
+                                        .hoverBackground(
+                                                new DynamicDrawable(() -> moduleChanged.getValue() ?
+                                                        GTGuiTextures.MC_BUTTON_DISABLED :
+                                                        GTGuiTextures.MC_BUTTON_HOVERED),
+                                                GTGuiTextures.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).alignX(Alignment.CENTER).size(matrixWidth, matrixHeight)))
+                .child(new ButtonWidget<>()
+                        .align(Alignment.TopRight)
+                        .background(GTGuiTextures.HELP)
+                        .hoverBackground(GTGuiTextures.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(new IDrawable.MultiDrawableWidget(new BorderDrawable(0xFFFF0000, 1),
+                                        GTGuiTextures.MONITOR)
+                                        .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(new IDrawable.MultiDrawableWidget(new BorderDrawable(0xFFFF00FF, 1),
+                                        GTGuiTextures.MONITOR)
+                                        .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(new IDrawable.MultiDrawableWidget(new BorderDrawable(0xFF0000FF, 1),
+                                        GTGuiTextures.DATA_HATCH, IKey.str("7").color(0xFFFFFFFF))
+                                        .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/factory/CoverUIFactory.java b/src/main/java/com/gregtechceu/gtceu/common/mui/factory/CoverUIFactory.java
new file mode 100644
index 00000000000..9dedbd4eeda
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/factory/CoverUIFactory.java
@@ -0,0 +1,84 @@
+package com.gregtechceu.gtceu.common.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 com.gregtechceu.gtceu.api.mui.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.AbstractUIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.api.mui.factory.SidedPosGuiData;
+
+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 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/common/mui/factory/MachineUIFactory.java b/src/main/java/com/gregtechceu/gtceu/common/mui/factory/MachineUIFactory.java
new file mode 100644
index 00000000000..4e024cdcdf4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/factory/MachineUIFactory.java
@@ -0,0 +1,94 @@
+package com.gregtechceu.gtceu.common.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.base.IUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.AbstractUIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.common.data.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 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/common/network/GTNetwork.java b/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java
index e0b547c23e8..018d4701d8a 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java
@@ -9,6 +9,9 @@
 import com.gregtechceu.gtceu.common.network.packets.prospecting.SPacketProspectBedrockFluid;
 import com.gregtechceu.gtceu.common.network.packets.prospecting.SPacketProspectBedrockOre;
 import com.gregtechceu.gtceu.common.network.packets.prospecting.SPacketProspectOre;
+import com.gregtechceu.gtceu.common.network.packets.ui.*;
+import com.gregtechceu.gtceu.common.network.packets.ui.OpenGuiPacket;
+import com.gregtechceu.gtceu.common.network.packets.ui.SyncHandlerPacket;
 
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.resources.ResourceKey;
@@ -98,6 +101,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);
@@ -115,5 +122,14 @@ public static void init() {
         register(SPacketSendWorldID.class, SPacketSendWorldID::new, NetworkDirection.PLAY_TO_CLIENT);
         register(SPacketNotifyCapeChange.class, SPacketNotifyCapeChange::new, NetworkDirection.PLAY_TO_CLIENT);
         register(SCPacketShareProspection.class, SCPacketShareProspection::new, null);
+
+        register(OpenGuiPacket.class, OpenGuiPacket::new, null);
+        register(SyncHandlerPacket.class, SyncHandlerPacket::new, null);
+        register(SContainerSetContent.class, SContainerSetContent::new, NetworkDirection.PLAY_TO_CLIENT);
+        register(SContainerSetData.class, SContainerSetData::new, NetworkDirection.PLAY_TO_CLIENT);
+        register(SContainerSetSlot.class, SContainerSetSlot::new, NetworkDirection.PLAY_TO_CLIENT);
+        register(CloseAllGuiPacket.class, CloseAllGuiPacket::new, null);
+        register(CloseGuiPacket.class, CloseGuiPacket::new, null);
+        register(ReopenGuiPacket.class, ReopenGuiPacket::new, null);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/InWorldContainerSynchronizer.java b/src/main/java/com/gregtechceu/gtceu/common/network/InWorldContainerSynchronizer.java
new file mode 100644
index 00000000000..a56c725bba3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/InWorldContainerSynchronizer.java
@@ -0,0 +1,60 @@
+package com.gregtechceu.gtceu.common.network;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.common.network.packets.ui.SContainerSetContent;
+import com.gregtechceu.gtceu.common.network.packets.ui.SContainerSetData;
+import com.gregtechceu.gtceu.common.network.packets.ui.SContainerSetSlot;
+
+import net.minecraft.core.NonNullList;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.ContainerSynchronizer;
+import net.minecraft.world.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+
+public class InWorldContainerSynchronizer implements ContainerSynchronizer {
+
+    private final ServerPlayer player;
+
+    public InWorldContainerSynchronizer(ServerPlayer player) {
+        this.player = player;
+    }
+
+    @Override
+    public void sendInitialData(@NotNull AbstractContainerMenu container, @NotNull NonNullList<ItemStack> items,
+                                @NotNull ItemStack carriedItem, int @NotNull [] initialData) {
+        GTNetwork.sendToPlayer(player, new SContainerSetContent(getInWorldId(container),
+                container.incrementStateId(), items, carriedItem));
+
+        for (int i = 0; i < initialData.length; ++i) {
+            this.broadcastDataValue(container, i, initialData[i]);
+        }
+    }
+
+    @Override
+    public void sendSlotChange(@NotNull AbstractContainerMenu container, int slot, @NotNull ItemStack itemStack) {
+        GTNetwork.sendToPlayer(player,
+                new SContainerSetSlot(getInWorldId(container), container.incrementStateId(), slot, itemStack));
+    }
+
+    @Override
+    public void sendCarriedChange(@NotNull AbstractContainerMenu containerMenu, @NotNull ItemStack stack) {
+        GTNetwork.sendToPlayer(player,
+                new SContainerSetSlot(getInWorldId(containerMenu), containerMenu.incrementStateId(), -1, stack));
+    }
+
+    @Override
+    public void sendDataChange(@NotNull AbstractContainerMenu container, int id, int value) {
+        this.broadcastDataValue(container, id, value);
+    }
+
+    private void broadcastDataValue(AbstractContainerMenu container, int id, int value) {
+        GTNetwork.sendToPlayer(player, new SContainerSetData(getInWorldId(container), id, value));
+    }
+
+    private int getInWorldId(AbstractContainerMenu container) {
+        if (container instanceof ModularContainerMenu modularContainer) return modularContainer.inWorldID;
+        return -1;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/ModularNetwork.java b/src/main/java/com/gregtechceu/gtceu/common/network/ModularNetwork.java
new file mode 100644
index 00000000000..fa36dfa726a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/ModularNetwork.java
@@ -0,0 +1,107 @@
+package com.gregtechceu.gtceu.common.network;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Experimental
+public abstract class ModularNetwork {
+
+    // You have to make sure you are choosing the logical side you are currently on otherwise you can mess things badly,
+    // since
+    // there is no validation.
+    public static final Client CLIENT = new Client();
+    public static final Server SERVER = new Server();
+
+    public static ModularNetworkSide get(boolean client) {
+        return client ? CLIENT : SERVER;
+    }
+
+    public static ModularNetworkSide get(Side side) {
+        return side.isClient() ? CLIENT : SERVER;
+    }
+
+    public static ModularNetworkSide get(Player player) {
+        return get(NetworkUtils.isClient(player));
+    }
+
+    public static final class Client extends ModularNetworkSide {
+
+        private Client() {
+            super(true);
+        }
+
+        public void activate(int nid, ModularSyncManager msm) {
+            activateInternal(nid, msm);
+        }
+
+        @Override
+        void sendPacket(GTNetwork.INetPacket packet, Player player) {
+            GTNetwork.sendToServer(packet);
+        }
+
+        @Override
+        void closeContainer(Player player) {
+            // mimics EntityPlayerSP.closeScreenAndDropStack() but without closing the screen
+            player.getInventory().setPickedItem(ItemStack.EMPTY);
+            player.containerMenu = player.inventoryMenu;
+        }
+
+        @SideOnly(Side.CLIENT)
+        public void closeContainer(int networkId, boolean dispose, Player player) {
+            closeContainer(networkId, dispose, player, true);
+        }
+
+        @SideOnly(Side.CLIENT)
+        public void closeAll() {
+            closeAll(Minecraft.getInstance().player);
+        }
+
+        @SideOnly(Side.CLIENT)
+        public void reopenSyncerOf(Screen guiScreen) {
+            if (guiScreen instanceof IMuiScreen ms && !ms.getScreen().isClientOnly()) {
+                ModularSyncManager msm = ms.getScreen().getSyncManager();
+                reopen(Minecraft.getInstance().player, msm, true);
+            }
+        }
+    }
+
+    public static final class Server extends ModularNetworkSide {
+
+        private int nextId = -1;
+
+        private Server() {
+            super(false);
+        }
+
+        public int activate(ModularSyncManager msm) {
+            if (++nextId > 100_000) nextId = 0;
+            activateInternal(nextId, msm);
+            return nextId;
+        }
+
+        @Override
+        protected void sendPacket(GTNetwork.INetPacket packet, Player player) {
+            GTNetwork.sendToPlayer((ServerPlayer) player, packet);
+        }
+
+        @Override
+        void closeContainer(Player player) {
+            ((ServerPlayer) player).closeContainer();
+        }
+
+        public void closeContainer(int networkId, boolean dispose, ServerPlayer player) {
+            closeContainer(networkId, dispose, player, true);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/ModularNetworkSide.java b/src/main/java/com/gregtechceu/gtceu/common/network/ModularNetworkSide.java
new file mode 100644
index 00000000000..9e78df64701
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/ModularNetworkSide.java
@@ -0,0 +1,135 @@
+package com.gregtechceu.gtceu.common.network;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.value.sync.ModularSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.common.network.packets.ui.CloseAllGuiPacket;
+import com.gregtechceu.gtceu.common.network.packets.ui.CloseGuiPacket;
+import com.gregtechceu.gtceu.common.network.packets.ui.ReopenGuiPacket;
+import com.gregtechceu.gtceu.common.network.packets.ui.SyncHandlerPacket;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.PlayerContainerEvent;
+
+import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
+import lombok.Getter;
+import org.jetbrains.annotations.ApiStatus;
+
+public abstract class ModularNetworkSide {
+
+    @Getter
+    private final boolean client;
+    private final Int2ReferenceOpenHashMap<ModularSyncManager> activeScreens = new Int2ReferenceOpenHashMap<>();
+    private final Reference2IntOpenHashMap<ModularSyncManager> inverseActiveScreens = new Reference2IntOpenHashMap<>();
+    // TODO: contextual syncer stack: in game containers shouldn't be closed in closeAll
+
+    ModularNetworkSide(boolean client) {
+        this.client = client;
+    }
+
+    abstract void sendPacket(GTNetwork.INetPacket packet, Player player);
+
+    void activateInternal(int networkId, ModularSyncManager manager) {
+        if (activeScreens.containsKey(networkId))
+            throw new IllegalStateException("Network ID " + networkId + " is already active.");
+        activeScreens.put(networkId, manager);
+        inverseActiveScreens.put(manager, networkId);
+    }
+
+    public void closeAll(Player player) {
+        closeAll(player, true);
+    }
+
+    @ApiStatus.Internal
+    public void closeAll(Player player, boolean sync) {
+        if (activeScreens.isEmpty()) return;
+        int currentContainer = -1;
+        if (player.containerMenu instanceof ModularContainerMenu mc && !mc.isClientOnly()) {
+            currentContainer = inverseActiveScreens.getInt(mc.getSyncManager());
+        }
+        var it = activeScreens.int2ReferenceEntrySet().fastIterator();
+        while (it.hasNext()) {
+            var entry = it.next();
+            int nid = entry.getIntKey();
+            ModularSyncManager msm = entry.getValue();
+            if (nid == currentContainer) closeContainer(player);
+            if (!msm.isClosed()) msm.onClose();
+            msm.dispose();
+        }
+        activeScreens.clear();
+        inverseActiveScreens.clear();
+        if (sync) sendPacket(new CloseAllGuiPacket(), player);
+    }
+
+    @ApiStatus.Internal
+    public void receivePacket(SyncHandlerPacket packet) {
+        ModularSyncManager msm = activeScreens.get(packet.networkId);
+        if (msm == null) return; // silently discard packets for inactive screens
+        try {
+            int id = packet.action ? 0 : packet.packet.readVarInt();
+            msm.receiveWidgetUpdate(packet.panel, packet.key, packet.action, id, packet.packet);
+        } catch (IndexOutOfBoundsException e) {
+            GTCEu.LOGGER.error("Failed to read packet for sync handler {} in panel {}", packet.key, packet.panel);
+            GTCEu.LOGGER.catching(e);
+        }
+    }
+
+    @ApiStatus.Internal
+    public void sendSyncHandlerPacket(String panel, SyncHandler syncHandler, FriendlyByteBuf buffer, Player player) {
+        ModularSyncManager msm = syncHandler.getSyncManager().getModularSyncManager();
+        if (!inverseActiveScreens.containsKey(msm)) return;
+        int id = inverseActiveScreens.getInt(msm);
+        sendPacket(new SyncHandlerPacket(msm.getMenu().inWorldID, id, panel, syncHandler.getKey(), false, buffer),
+                player);
+    }
+
+    @ApiStatus.Internal
+    public void sendActionPacket(ModularSyncManager msm, String panel, String key, FriendlyByteBuf buffer,
+                                 Player player) {
+        if (!inverseActiveScreens.containsKey(msm)) return;
+        int id = inverseActiveScreens.getInt(msm);
+        sendPacket(new SyncHandlerPacket(msm.getMenu().inWorldID, id, panel, key, true, buffer), player);
+    }
+
+    @ApiStatus.Internal
+    public void closeContainer(int networkId, boolean dispose, Player player, boolean sync) {
+        closeContainer(player);
+        deactivate(networkId, dispose);
+        if (sync) {
+            sendPacket(new CloseGuiPacket(networkId, dispose), player);
+        }
+    }
+
+    abstract void closeContainer(Player player);
+
+    void deactivate(int networkId, boolean dispose) {
+        ModularSyncManager msm = activeScreens.get(networkId);
+        if (msm == null) return;
+        if (!msm.isClosed()) msm.onClose();
+        if (dispose) {
+            activeScreens.remove(networkId);
+            inverseActiveScreens.removeInt(msm);
+            msm.dispose();
+        }
+    }
+
+    @ApiStatus.Internal
+    public void reopen(Player player, ModularSyncManager msm, boolean sync) {
+        if (player.containerMenu != msm.getMenu()) {
+            closeContainer(player);
+            player.containerMenu = msm.getMenu();
+            msm.onOpen();
+            MinecraftForge.EVENT_BUS.post(new PlayerContainerEvent.Open(player, msm.getMenu()));
+        }
+        if (sync) sendPacket(new ReopenGuiPacket(inverseActiveScreens.getInt(msm)), player);
+    }
+
+    @ApiStatus.Internal
+    public void reopen(Player player, int networkId, boolean sync) {
+        reopen(player, activeScreens.get(networkId), sync);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/CloseAllGuiPacket.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/CloseAllGuiPacket.java
new file mode 100644
index 00000000000..a540fa51986
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/CloseAllGuiPacket.java
@@ -0,0 +1,29 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.network.NetworkDirection;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+public class CloseAllGuiPacket implements GTNetwork.INetPacket {
+
+    public CloseAllGuiPacket(FriendlyByteBuf buffer) {}
+
+    @Override
+    public void encode(FriendlyByteBuf buffer) {}
+
+    @Override
+    public void execute(NetworkEvent.Context handler) {
+        if (handler.getDirection() == NetworkDirection.PLAY_TO_CLIENT) {
+            ModularNetwork.CLIENT.closeAll(MCHelper.getPlayer(), false);
+        } else {
+            ModularNetwork.SERVER.closeAll(handler.getSender(), false);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/CloseGuiPacket.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/CloseGuiPacket.java
new file mode 100644
index 00000000000..a67c5039856
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/CloseGuiPacket.java
@@ -0,0 +1,40 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.network.NetworkDirection;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+@AllArgsConstructor
+public class CloseGuiPacket implements GTNetwork.INetPacket {
+
+    private int networkId;
+    private boolean dispose;
+
+    public CloseGuiPacket(FriendlyByteBuf buffer) {
+        this.networkId = buffer.readVarInt();
+        this.dispose = buffer.readBoolean();
+    }
+
+    @Override
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(this.networkId);
+        buffer.writeBoolean(this.dispose);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context handler) {
+        if (handler.getDirection() == NetworkDirection.PLAY_TO_CLIENT) {
+            ModularNetwork.CLIENT.closeContainer(this.networkId, this.dispose, MCHelper.getPlayer(), false);
+        } else {
+            ModularNetwork.SERVER.closeContainer(this.networkId, this.dispose, handler.getSender(), false);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/OpenGuiPacket.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/OpenGuiPacket.java
new file mode 100644
index 00000000000..5ad0bbb74ce
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/OpenGuiPacket.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.base.UIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.GuiData;
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.network.NetworkDirection;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+@AllArgsConstructor
+public class OpenGuiPacket<T extends GuiData> implements GTNetwork.INetPacket {
+
+    private int windowId;
+    private int networkId;
+    private UIFactory<T> factory;
+    private FriendlyByteBuf data;
+    private boolean inWorldUI;
+
+    public OpenGuiPacket(FriendlyByteBuf buf) {
+        this.windowId = buf.readVarInt();
+        this.inWorldUI = buf.readBoolean();
+        this.networkId = buf.readVarInt();
+        this.factory = (UIFactory<T>) GuiManager.getFactory(buf.readResourceLocation());
+        this.data = NetworkUtils.readFriendlyByteBuf(buf);
+    }
+
+    @Override
+    public void encode(FriendlyByteBuf buf) {
+        buf.writeVarInt(this.windowId);
+        buf.writeBoolean(this.inWorldUI);
+        buf.writeVarInt(this.networkId);
+        buf.writeResourceLocation(this.factory.getFactoryName());
+        NetworkUtils.writeByteBuf(buf, this.data);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context handler) {
+        if (handler.getDirection() == NetworkDirection.PLAY_TO_CLIENT) {
+            GuiManager.openFromClient(this.windowId, this.networkId, this.inWorldUI, this.factory, this.data,
+                    Minecraft.getInstance().player);
+        } else if (handler.getDirection() == NetworkDirection.PLAY_TO_SERVER) {
+            T guiData = this.factory.readGuiData(handler.getSender(), this.data);
+            GuiManager.open(this.factory, this.inWorldUI, guiData, handler.getSender());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/ReopenGuiPacket.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/ReopenGuiPacket.java
new file mode 100644
index 00000000000..d37959a16a7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/ReopenGuiPacket.java
@@ -0,0 +1,37 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.base.MCHelper;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.network.NetworkDirection;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+@AllArgsConstructor
+public class ReopenGuiPacket implements GTNetwork.INetPacket {
+
+    private int networkId;
+
+    public ReopenGuiPacket(FriendlyByteBuf buffer) {
+        this.networkId = buffer.readVarInt();
+    }
+
+    @Override
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(networkId);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context handler) {
+        if (handler.getDirection() == NetworkDirection.PLAY_TO_CLIENT) {
+            ModularNetwork.CLIENT.reopen(MCHelper.getPlayer(), this.networkId, false);
+        } else {
+            ModularNetwork.SERVER.reopen(handler.getSender(), this.networkId, false);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetContent.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetContent.java
new file mode 100644
index 00000000000..03ad0d5ebd1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetContent.java
@@ -0,0 +1,45 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+
+import java.util.List;
+
+@AllArgsConstructor
+public class SContainerSetContent implements GTNetwork.INetPacket {
+
+    private int inWorldId;
+    private int stateId;
+    private List<ItemStack> items;
+    private ItemStack carriedItem;
+
+    public SContainerSetContent(FriendlyByteBuf buf) {
+        this.inWorldId = buf.readVarInt();
+        this.stateId = buf.readVarInt();
+        this.items = buf.readList(FriendlyByteBuf::readItem);
+        this.carriedItem = buf.readItem();
+    }
+
+    @Override
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(this.inWorldId);
+        buffer.writeVarInt(this.stateId);
+        buffer.writeCollection(this.items, FriendlyByteBuf::writeItem);
+        buffer.writeItem(carriedItem);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context context) {
+        ModularContainerMenu menu = GuiManager.getClientInWorldMenu(this.inWorldId);
+        if (menu != null) {
+            menu.initializeContents(this.stateId, this.items, this.carriedItem);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetData.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetData.java
new file mode 100644
index 00000000000..cf0e83a69a0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetData.java
@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public class SContainerSetData implements GTNetwork.INetPacket {
+
+    private int inWorldId;
+    private int id;
+    private int value;
+
+    public SContainerSetData(FriendlyByteBuf buf) {
+        inWorldId = buf.readVarInt();
+        id = buf.readVarInt();
+        value = buf.readVarInt();
+    }
+
+    @Override
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(inWorldId);
+        buffer.writeVarInt(id);
+        buffer.writeVarInt(value);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context context) {
+        ModularContainerMenu menu = GuiManager.getClientInWorldMenu(inWorldId);
+        if (menu != null) {
+            menu.setData(id, value);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetSlot.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetSlot.java
new file mode 100644
index 00000000000..4f67988ced5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SContainerSetSlot.java
@@ -0,0 +1,45 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.api.mui.factory.GuiManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public class SContainerSetSlot implements GTNetwork.INetPacket {
+
+    private int inWorldId;
+    private int stateId;
+    private int slot;
+    private ItemStack stack;
+
+    public SContainerSetSlot(FriendlyByteBuf buf) {
+        inWorldId = buf.readVarInt();
+        stateId = buf.readVarInt();
+        slot = buf.readVarInt();
+        stack = buf.readItem();
+    }
+
+    @Override
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(inWorldId);
+        buffer.writeVarInt(stateId);
+        buffer.writeVarInt(slot);
+        buffer.writeItem(stack);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context context) {
+        ModularContainerMenu menu = GuiManager.getClientInWorldMenu(inWorldId);
+        if (menu != null) {
+            if (slot == -1) {
+                menu.setCarried(stack);
+            } else menu.setItem(slot, stateId, stack);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SyncHandlerPacket.java b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SyncHandlerPacket.java
new file mode 100644
index 00000000000..8a5f6ec03f3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/packets/ui/SyncHandlerPacket.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.common.network.packets.ui;
+
+import com.gregtechceu.gtceu.common.network.GTNetwork;
+import com.gregtechceu.gtceu.common.network.ModularNetwork;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.network.NetworkDirection;
+import net.minecraftforge.network.NetworkEvent;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import org.jetbrains.annotations.ApiStatus;
+
+@NoArgsConstructor
+@AllArgsConstructor
+@ApiStatus.Internal
+public class SyncHandlerPacket implements GTNetwork.INetPacket {
+
+    public int inWorldID;
+    public int networkId;
+    public String panel;
+    public String key;
+    public boolean action;
+    public FriendlyByteBuf packet;
+
+    @Override
+    public void encode(FriendlyByteBuf buf) {
+        buf.writeVarInt(this.inWorldID);
+        buf.writeVarInt(this.networkId);
+        NetworkUtils.writeStringSafe(buf, this.panel, 256, true);
+        NetworkUtils.writeStringSafe(buf, this.key, 256, true);
+        buf.writeBoolean(this.action);
+        NetworkUtils.writeByteBuf(buf, this.packet);
+    }
+
+    public SyncHandlerPacket(FriendlyByteBuf buf) {
+        this.inWorldID = buf.readVarInt();
+        this.networkId = buf.readVarInt();
+        this.panel = NetworkUtils.readStringSafe(buf);
+        this.key = NetworkUtils.readStringSafe(buf);
+        this.action = buf.readBoolean();
+        this.packet = NetworkUtils.readFriendlyByteBuf(buf);
+    }
+
+    @Override
+    public void execute(NetworkEvent.Context handler) {
+        if (handler.getDirection() == NetworkDirection.PLAY_TO_CLIENT) {
+            ModularNetwork.CLIENT.receivePacket(this);
+        } else {
+            ModularNetwork.SERVER.receivePacket(this);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/pipelike/cable/EnergyNetWalker.java b/src/main/java/com/gregtechceu/gtceu/common/pipelike/cable/EnergyNetWalker.java
index c4404a0f6d7..12922071459 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/pipelike/cable/EnergyNetWalker.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/pipelike/cable/EnergyNetWalker.java
@@ -1,8 +1,8 @@
 package com.gregtechceu.gtceu.common.pipelike.cable;
 
 import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IEnergyContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.WireProperties;
 import com.gregtechceu.gtceu.api.pipenet.PipeNetWalker;
 import com.gregtechceu.gtceu.common.blockentity.CableBlockEntity;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetHandler.java b/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetHandler.java
index 913860aab60..754537f5165 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetHandler.java
@@ -4,7 +4,8 @@
 import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.HazardProperty;
 import com.gregtechceu.gtceu.api.data.medicalcondition.MedicalCondition;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardCleaner;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardCleanerTrait;
 import com.gregtechceu.gtceu.common.blockentity.DuctPipeBlockEntity;
 import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
 
@@ -65,9 +66,12 @@ public float changeHazard(MedicalCondition condition, float differenceAmount) {
                     IHazardParticleContainer handler = path.getHandler(net.getLevel());
                     if (handler == null && path.getTargetPipe().isConnected(path.getTargetFacing())) {
                         if (net.getLevel().getBlockEntity(path.getTargetPipePos()
-                                .relative(path.getTargetFacing())) instanceof IEnvironmentalHazardCleaner cleaner) {
-                            cleaner.cleanHazard(condition, differenceAmount);
-                            break;
+                                .relative(path.getTargetFacing())) instanceof MetaMachine machine) {
+                            var cleanerTrait = machine.getTraitHolder().getTrait(EnvironmentalHazardCleanerTrait.TYPE);
+                            if (cleanerTrait != null) {
+                                cleanerTrait.cleanHazard(condition, differenceAmount);
+                                break;
+                            }
                         }
 
                         var savedData = EnvironmentalHazardSavedData.getOrCreate(net.getLevel());
diff --git a/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetWalker.java b/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetWalker.java
index 46878c50127..62c136bfb3c 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetWalker.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/pipelike/duct/DuctNetWalker.java
@@ -1,8 +1,8 @@
 package com.gregtechceu.gtceu.common.pipelike.duct;
 
 import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.pipenet.PipeNetWalker;
 import com.gregtechceu.gtceu.common.blockentity.DuctPipeBlockEntity;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/pipelike/laser/LaserNetWalker.java b/src/main/java/com/gregtechceu/gtceu/common/pipelike/laser/LaserNetWalker.java
index 1dc939e15e0..bf3bed65d68 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/pipelike/laser/LaserNetWalker.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/pipelike/laser/LaserNetWalker.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.common.pipelike.laser;
 
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.ILaserContainer;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.pipenet.PipeNetWalker;
 import com.gregtechceu.gtceu.common.blockentity.LaserPipeBlockEntity;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalNetWalker.java b/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalNetWalker.java
index 16711b1e8a3..dbf79210f4d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalNetWalker.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalNetWalker.java
@@ -1,6 +1,6 @@
 package com.gregtechceu.gtceu.common.pipelike.optical;
 
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.pipenet.PipeNetWalker;
 import com.gregtechceu.gtceu.common.blockentity.OpticalPipeBlockEntity;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalRoutePath.java b/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalRoutePath.java
index a05cc0d1718..9f9b63f5dbb 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalRoutePath.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/pipelike/optical/OpticalRoutePath.java
@@ -1,10 +1,10 @@
 package com.gregtechceu.gtceu.common.pipelike.optical;
 
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IDataAccessHatch;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider;
 import com.gregtechceu.gtceu.api.capability.IOpticalDataAccessHatch;
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
 import com.gregtechceu.gtceu.api.pipenet.IRoutePath;
 import com.gregtechceu.gtceu.common.blockentity.OpticalPipeBlockEntity;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentBlockCondition.java b/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentBlockCondition.java
index 14bb3a39623..af779321ea4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentBlockCondition.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentBlockCondition.java
@@ -1,12 +1,12 @@
 package com.gregtechceu.gtceu.common.recipe.condition;
 
-import com.gregtechceu.gtceu.api.codec.GTCodecUtils;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.RecipeCondition;
 import com.gregtechceu.gtceu.api.recipe.condition.RecipeConditionType;
 import com.gregtechceu.gtceu.common.data.GTRecipeConditions;
 import com.gregtechceu.gtceu.utils.GTUtil;
+import com.gregtechceu.gtceu.utils.codec.GTCodecUtils;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.HolderSet;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentFluidCondition.java b/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentFluidCondition.java
index 8efbde197a2..34268e3ed9b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentFluidCondition.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/AdjacentFluidCondition.java
@@ -1,12 +1,12 @@
 package com.gregtechceu.gtceu.common.recipe.condition;
 
-import com.gregtechceu.gtceu.api.codec.GTCodecUtils;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.RecipeCondition;
 import com.gregtechceu.gtceu.api.recipe.condition.RecipeConditionType;
 import com.gregtechceu.gtceu.common.data.GTRecipeConditions;
 import com.gregtechceu.gtceu.utils.GTUtil;
+import com.gregtechceu.gtceu.utils.codec.GTCodecUtils;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.HolderSet;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/VentCondition.java b/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/VentCondition.java
index b0b1aed1b27..29c155831e6 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/VentCondition.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/recipe/condition/VentCondition.java
@@ -1,6 +1,6 @@
 package com.gregtechceu.gtceu.common.recipe.condition;
 
-import com.gregtechceu.gtceu.api.machine.feature.IExhaustVentMachine;
+import com.gregtechceu.gtceu.api.machine.trait.ExhaustVentMachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.RecipeCondition;
@@ -35,8 +35,9 @@ public Component getTooltips() {
 
     @Override
     public boolean testCondition(@NotNull GTRecipe recipe, @NotNull RecipeLogic recipeLogic) {
-        if (recipeLogic.getProgress() % 10 == 0 && recipeLogic.machine instanceof IExhaustVentMachine ventMachine) {
-            return !(ventMachine.isNeedsVenting() && ventMachine.isVentingBlocked());
+        var ventTrait = recipeLogic.machine.self().getTraitHolder().getTrait(ExhaustVentMachineTrait.TYPE);
+        if (recipeLogic.getProgress() % 10 == 0 && ventTrait != null) {
+            return !(ventTrait.isNeedsVenting() && ventTrait.isVentingBlocked());
         }
         return true;
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java b/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java
index 3248f0c11be..93791ddd643 100644
--- a/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java
+++ b/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java
@@ -2,6 +2,7 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTCEuAPI;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
 
 import net.minecraft.commands.Commands;
 
@@ -24,6 +25,7 @@ public static void init() {
         }
     }
 
+    @Configurable.ValueUpdateCallback(method = "myMethod")
     @Configurable
     public RecipeConfigs recipes = new RecipeConfigs();
     @Configurable
@@ -769,13 +771,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 +779,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 +809,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 +901,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 +920,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/RecipeManagerMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/RecipeManagerMixin.java
index 4e7f22021a1..13c17314a74 100644
--- a/src/main/java/com/gregtechceu/gtceu/core/mixins/RecipeManagerMixin.java
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/RecipeManagerMixin.java
@@ -40,7 +40,7 @@ public abstract class RecipeManagerMixin {
             if (!(recipeType instanceof GTRecipeType gtRecipeType)) {
                 continue;
             }
-            gtRecipeType.getAdditionHandler().beginStaging();
+            gtRecipeType.beginStagingRecipes();
             gtRecipeType.getProxyRecipes().forEach((type, list) -> {
                 var recipesByID = recipes.get(type);
                 if (recipesByID == null) {
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/AbstractContainerMenuAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerMenuAccessor.java
new file mode 100644
index 00000000000..39b23514288
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerMenuAccessor.java
@@ -0,0 +1,23 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.world.Container;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.item.ItemStack;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(AbstractContainerMenu.class)
+public interface AbstractContainerMenuAccessor {
+
+    @Accessor
+    int getQuickcraftType();
+
+    @Invoker
+    boolean invokeMoveItemStackTo(ItemStack stack, int startIndex, int endIndex, boolean reverseDirection);
+
+    @Invoker
+    void invokeClearContainer(Player playerIn, Container inventoryIn);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerScreenAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerScreenAccessor.java
new file mode 100644
index 00000000000..5d85d97aad6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerScreenAccessor.java
@@ -0,0 +1,82 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import java.util.Set;
+
+@Mixin(AbstractContainerScreen.class)
+public interface AbstractContainerScreenAccessor {
+
+    @Accessor
+    void setImageWidth(int v);
+
+    @Accessor
+    void setImageHeight(int v);
+
+    @Accessor
+    void setLeftPos(int v);
+
+    @Accessor
+    void setTopPos(int v);
+
+    @Accessor
+    void setHoveredSlot(Slot slot);
+
+    @Accessor
+    Slot getHoveredSlot();
+
+    @Accessor
+    Slot getClickedSlot();
+
+    @Accessor
+    ItemStack getDraggingItem();
+
+    @Accessor
+    boolean getIsSplittingStack();
+
+    @Accessor
+    boolean getIsQuickCrafting();
+
+    @Accessor
+    Set<Slot> getQuickCraftSlots();
+
+    @Accessor
+    int getQuickCraftingType();
+
+    @Invoker
+    void invokeRecalculateQuickCraftRemaining();
+
+    @Accessor
+    int getQuickCraftingRemainder();
+
+    @Accessor
+    ItemStack getSnapbackItem();
+
+    @Accessor
+    void setSnapbackItem(ItemStack stack);
+
+    @Accessor
+    Slot getSnapbackEnd();
+
+    @Accessor
+    int getSnapbackStartX();
+
+    @Accessor
+    int getSnapbackStartY();
+
+    @Accessor
+    long getSnapbackTime();
+
+    @Invoker
+    void invokeRenderLabels(GuiGraphics guiGraphics, int mouseX, int mouseY);
+
+    @Invoker
+    void invokeRenderBg(GuiGraphics guiGraphics, float partialTicks, int mouseX, int mouseY);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerScreenMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerScreenMixin.java
new file mode 100644
index 00000000000..295a21528a6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractContainerScreenMixin.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.client.mui.screen.IClickableContainerScreen;
+
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.world.inventory.Slot;
+
+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(AbstractContainerScreen.class)
+public class AbstractContainerScreenMixin implements IClickableContainerScreen {
+
+    @Shadow
+    protected Slot hoveredSlot;
+
+    @Unique
+    private Slot gtceu$clickedSlot;
+
+    /**
+     * Mixin into ModularUI screen wrapper to return the true hovered slot.
+     * The method is private and only the mouse pos is ever passed to this method.
+     * That's why we can just return the current hovered slot.
+     */
+    @Inject(method = "findSlot", at = @At("HEAD"), cancellable = true)
+    public void getSlot(double mouseX, double mouseY, CallbackInfoReturnable<Slot> cir) {
+        if (this.gtceu$clickedSlot != null) {
+            cir.setReturnValue(this.gtceu$clickedSlot);
+        } else if (IMuiScreen.class.isAssignableFrom(this.getClass())) {
+            cir.setReturnValue(this.hoveredSlot);
+        }
+    }
+
+    @Override
+    public void gtceu$setClickedSlot(Slot slot) {
+        this.gtceu$clickedSlot = slot;
+    }
+
+    @Override
+    public Slot gtceu$getClickedSlot() {
+        return gtceu$clickedSlot;
+    }
+}
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..8cb6a9aa683
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractWidgetMixin.java
@@ -0,0 +1,33 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import com.gregtechceu.gtceu.api.mui.overlay.OverlayStack;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+
+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..ead2e535596
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GameRendererMixin.java
@@ -0,0 +1,57 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import com.gregtechceu.gtceu.api.mui.InWorldMUIRenderEvent;
+import com.gregtechceu.gtceu.core.IGameRenderer;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraftforge.common.MinecraftForge;
+
+import com.mojang.blaze3d.platform.Window;
+import com.mojang.blaze3d.vertex.PoseStack;
+import org.joml.Matrix4f;
+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;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+@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);
+
+    @Inject(method = "render",
+            at = @At(value = "INVOKE_STRING",
+                     target = "Lnet/minecraft/util/profiling/ProfilerFiller;push(Ljava/lang/String;)V",
+                     args = "ldc=toasts"),
+            locals = LocalCapture.CAPTURE_FAILSOFT)
+    private void onScreenRender(float partialTicks, long nanoTime, boolean renderLevel, CallbackInfo ci, int i, int j,
+                                Window window, Matrix4f matrix4f, PoseStack posestack, GuiGraphics guigraphics) {
+        MinecraftForge.EVENT_BUS.post(new InWorldMUIRenderEvent(guigraphics, this.minecraft.getDeltaFrameTime()));
+    }
+
+    @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..6164df442a3 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.api.mui.drawable.text.FontRenderHelper;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
 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 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/client/MinecraftMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/MinecraftMixin.java
new file mode 100644
index 00000000000..c8ee2288d26
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/MinecraftMixin.java
@@ -0,0 +1,43 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import com.gregtechceu.gtceu.client.ClientProxy;
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+
+import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+
+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;
+
+import javax.annotation.Nullable;
+
+@Mixin(Minecraft.class)
+public class MinecraftMixin {
+
+    @Shadow
+    @Nullable
+    public Screen screen;
+
+    @Inject(method = "runTick",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Timer;advanceTime(J)I", shift = At.Shift.AFTER))
+    public void timer(CallbackInfo ci) {
+        ClientProxy.getTimer60Fps().advanceTime(Util.getMillis());
+        for (int j = 0; j < Math.min(20, ClientProxy.getTimer60Fps().tickDelta); ++j) {
+            ClientScreenHandler.onFrameUpdate();
+        }
+    }
+
+    @Inject(method = "setScreen",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/screens/Screen;removed()V"))
+    public void setScreen(Screen guiScreen, CallbackInfo ci) {
+        if (guiScreen == null) {
+            // the ScreenEvent.Closing is also closed when the screen is transitioning to another screen,
+            // but we only want to know when the next screen null is, so that all screens close.
+            ClientScreenHandler.onCloseScreens(this.screen);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/ScreenAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/ScreenAccessor.java
new file mode 100644
index 00000000000..17277839372
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/ScreenAccessor.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.screens.Screen;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.List;
+
+@Mixin(Screen.class)
+public interface ScreenAccessor {
+
+    @Accessor
+    Font getFont();
+
+    @Mutable
+    @Accessor
+    void setChildren(List<? extends GuiEventListener> children);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/SlotAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/SlotAccessor.java
new file mode 100644
index 00000000000..e11194c85f0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/SlotAccessor.java
@@ -0,0 +1,22 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.world.inventory.Slot;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+/**
+ * Accessor interface for accessing protected methods from {@link Slot}.
+ */
+@Mixin(Slot.class)
+public interface SlotAccessor {
+
+    @Accessor("x")
+    @Mutable
+    void gtceu$setX(int x);
+
+    @Accessor("x")
+    @Mutable
+    void gtceu$setY(int y);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/StringSplitterAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/StringSplitterAccessor.java
new file mode 100644
index 00000000000..111c9835f37
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/StringSplitterAccessor.java
@@ -0,0 +1,13 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.client.StringSplitter;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(StringSplitter.class)
+public interface StringSplitterAccessor {
+
+    @Accessor
+    StringSplitter.WidthProvider getWidthProvider();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/jei/IngredientListOverlayAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/jei/IngredientListOverlayAccessor.java
new file mode 100644
index 00000000000..09d5ada84fa
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/jei/IngredientListOverlayAccessor.java
@@ -0,0 +1,13 @@
+package com.gregtechceu.gtceu.core.mixins.jei;
+
+import mezz.jei.gui.input.GuiTextFieldFilter;
+import mezz.jei.gui.overlay.IngredientListOverlay;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(value = IngredientListOverlay.class, remap = false)
+public interface IngredientListOverlayAccessor {
+
+    @Accessor
+    GuiTextFieldFilter getSearchField();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/data/forge/DataGenerators.java b/src/main/java/com/gregtechceu/gtceu/data/DataGenerators.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/data/forge/DataGenerators.java
rename to src/main/java/com/gregtechceu/gtceu/data/DataGenerators.java
index c88ef6d0daf..7ff6a458418 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/forge/DataGenerators.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/DataGenerators.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.data.forge;
+package com.gregtechceu.gtceu.data;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.registry.registrate.SoundEntryBuilder;
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 f36f4b91036..3a9a0699809 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/lang/LangHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/lang/LangHandler.java
@@ -473,6 +473,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");
@@ -483,20 +484,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");
 
@@ -868,6 +872,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: ");
@@ -1351,6 +1356,7 @@ 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:");
@@ -1361,6 +1367,16 @@ 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:");
+
+        provider.add("gtceu.gui.item_auto_output", "Item Output: %s");
+        provider.add("gtceu.gui.item_input_from_output", "Item Input from Output: %s");
+        provider.add("gtceu.gui.fluid_auto_output", "Fluid Output: %s");
+        provider.add("gtceu.gui.fluid_input_from_output", "Fluid Input from Output: %s");
 
         // Decor Stuff
         replace(provider, "block.gtceu.yellow_stripes_block.a", "Yellow Stripes Block");
@@ -1711,7 +1727,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!");
@@ -1729,9 +1798,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.");;
@@ -1741,6 +1812,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");
@@ -1756,6 +1831,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/recipe/builder/GTRecipeBuilder.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/GTRecipeBuilder.java
index eb97eff4d6d..0cc2e4328c3 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/GTRecipeBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/GTRecipeBuilder.java
@@ -23,7 +23,7 @@
 import com.gregtechceu.gtceu.api.recipe.ingredient.nbtpredicate.NBTPredicate;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.common.recipe.condition.*;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.GTUtil;
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..b7329277676 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
@@ -3,7 +3,6 @@
 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 net.minecraft.core.registries.BuiltInRegistries;
@@ -22,17 +21,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 +44,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 +122,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 +145,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..eb2251f7b55 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
@@ -3,7 +3,6 @@
 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 net.minecraft.core.registries.BuiltInRegistries;
@@ -22,16 +21,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 +43,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 +75,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 +117,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 +140,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/generated/PartsRecipeHandler.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/generated/PartsRecipeHandler.java
index d29bb429d81..c7305d941f5 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/generated/PartsRecipeHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/generated/PartsRecipeHandler.java
@@ -8,7 +8,7 @@
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.common.data.GTRecipeCategories;
-import com.gregtechceu.gtceu.common.item.TurbineRotorBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.TurbineRotorBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.VanillaRecipeHelper;
 import com.gregtechceu.gtceu.data.recipe.builder.GTRecipeBuilder;
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CustomToolRecipes.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CustomToolRecipes.java
index a5510ac10c5..e654851a7cd 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CustomToolRecipes.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CustomToolRecipes.java
@@ -13,7 +13,7 @@
 import com.gregtechceu.gtceu.api.recipe.ToolHeadReplaceRecipe;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.common.item.ItemMagnetBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.ItemMagnetBehavior;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 import com.gregtechceu.gtceu.data.recipe.VanillaRecipeHelper;
 import com.gregtechceu.gtceu.utils.ToolItemHelper;
diff --git a/src/main/java/com/gregtechceu/gtceu/forge/AlloyBlastPropertyAddition.java b/src/main/java/com/gregtechceu/gtceu/forge/AlloyBlastPropertyAddition.java
deleted file mode 100644
index 8876472dc78..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/forge/AlloyBlastPropertyAddition.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package com.gregtechceu.gtceu.forge;
-
-import com.gregtechceu.gtceu.api.GTCEuAPI;
-import com.gregtechceu.gtceu.api.data.chemical.material.Material;
-import com.gregtechceu.gtceu.api.data.chemical.material.event.PostMaterialEvent;
-import com.gregtechceu.gtceu.api.data.chemical.material.info.MaterialFlags;
-import com.gregtechceu.gtceu.api.data.chemical.material.properties.AlloyBlastProperty;
-import com.gregtechceu.gtceu.api.data.chemical.material.properties.BlastProperty;
-import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
-import com.gregtechceu.gtceu.api.data.chemical.material.stack.MaterialStack;
-import com.gregtechceu.gtceu.api.fluids.FluidBuilder;
-import com.gregtechceu.gtceu.api.fluids.FluidState;
-import com.gregtechceu.gtceu.api.fluids.store.FluidStorageKeys;
-import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.data.recipe.misc.alloyblast.CustomAlloyBlastRecipeProducer;
-
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-/**
- * Listen to PostMaterialEvent instead of doing this directly because it's a lot cleaner this way.
- */
-// @Mod.EventBusSubscriber(modid = GTCEu.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
-public class AlloyBlastPropertyAddition {
-
-    @SubscribeEvent
-    public static void addAlloyBlastProperties(PostMaterialEvent event) {
-        for (Material material : GTCEuAPI.materialManager.getRegisteredMaterials()) {
-            if (!material.hasFlag(MaterialFlags.DISABLE_ALLOY_PROPERTY)) {
-                addAlloyBlastProperty(material);
-            }
-        }
-        // Alloy Blast Overriding
-        GTMaterials.NiobiumNitride.getProperty(PropertyKey.ALLOY_BLAST)
-                .setRecipeProducer(new CustomAlloyBlastRecipeProducer(1, 11, -1));
-
-        GTMaterials.IndiumTinBariumTitaniumCuprate.getProperty(PropertyKey.ALLOY_BLAST)
-                .setRecipeProducer(new CustomAlloyBlastRecipeProducer(-1, -1, 16));
-    }
-
-    public static void addAlloyBlastProperty(@NotNull Material material) {
-        final List<MaterialStack> components = material.getMaterialComponents();
-        // ignore materials which are not alloys
-        if (components.size() < 2) return;
-
-        BlastProperty blastProperty = material.getProperty(PropertyKey.BLAST);
-        if (blastProperty == null) return;
-
-        if (!material.hasProperty(PropertyKey.FLUID)) return;
-
-        // if there are more than 2 fluid-only components in the material, do not generate a hot fluid
-        if (components.stream().filter(AlloyBlastPropertyAddition::isMaterialStackFluidOnly).limit(3).count() > 2) {
-            return;
-        }
-
-        material.setProperty(PropertyKey.ALLOY_BLAST, new AlloyBlastProperty(material.getBlastTemperature()));
-        material.getProperty(PropertyKey.FLUID).getStorage().enqueueRegistration(FluidStorageKeys.MOLTEN,
-                new FluidBuilder().state(FluidState.LIQUID));
-    }
-
-    private static boolean isMaterialStackFluidOnly(@NotNull MaterialStack ms) {
-        return !ms.material().hasProperty(PropertyKey.DUST) && ms.material().hasProperty(PropertyKey.FLUID);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEConfigSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEConfigSyncHandler.java
new file mode 100644
index 00000000000..28118d95929
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEConfigSyncHandler.java
@@ -0,0 +1,115 @@
+package com.gregtechceu.gtceu.integration.ae2.gui.widget.mui;
+
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandler;
+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;
+
+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/widget/mui/AEConfigWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEConfigWidget.java
new file mode 100644
index 00000000000..b81702351de
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEConfigWidget.java
@@ -0,0 +1,421 @@
+package com.gregtechceu.gtceu.integration.ae2.gui.widget.mui;
+
+import com.gregtechceu.gtceu.api.gui.GuiTextures;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.base.widget.Interactable;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.value.StringValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Row;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.SecondaryPanel;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+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 com.gregtechceu.gtceu.integration.emi.EmiStackConverter;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+
+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 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)
+                .alignX(0.5f).alignY(0.35f)
+                .background(GTGuiTextures.BACKGROUND)
+                .child(ButtonWidget.panelCloseButton())
+                .child(IKey.str("Amount").asWidget().pos(4, 4))
+                .child(new 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/widget/mui/AEGuiHelper.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEGuiHelper.java
new file mode 100644
index 00000000000..75c15d4f07d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEGuiHelper.java
@@ -0,0 +1,158 @@
+package com.gregtechceu.gtceu.integration.ae2.gui.widget.mui;
+
+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/widget/mui/AEKeyStorageSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEKeyStorageSyncHandler.java
new file mode 100644
index 00000000000..f595f939ebe
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEKeyStorageSyncHandler.java
@@ -0,0 +1,156 @@
+package com.gregtechceu.gtceu.integration.ae2.gui.widget.mui;
+
+import com.gregtechceu.gtceu.api.mui.value.sync.ValueSyncHandler;
+import com.gregtechceu.gtceu.integration.ae2.utils.KeyStorage;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+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.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/widget/mui/AEStackDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEStackDisplayWidget.java
new file mode 100644
index 00000000000..cf40210ed5e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/AEStackDisplayWidget.java
@@ -0,0 +1,78 @@
+package com.gregtechceu.gtceu.integration.ae2.gui.widget.mui;
+
+import com.gregtechceu.gtceu.api.gui.GuiTextures;
+import com.gregtechceu.gtceu.api.mui.base.ITheme;
+import com.gregtechceu.gtceu.api.mui.theme.WidgetThemeEntry;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.ModularGuiContext;
+
+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 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/widget/mui/ScrollPreservingGrid.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/ScrollPreservingGrid.java
new file mode 100644
index 00000000000..1f1e7cbe19b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/mui/ScrollPreservingGrid.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.integration.ae2.gui.widget.mui;
+
+import com.gregtechceu.gtceu.api.mui.widget.scroll.ScrollData;
+import com.gregtechceu.gtceu.api.mui.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/machine/MEInputBusPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputBusPartMachine.java
index fb72184cb79..0374bf3c540 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
@@ -5,25 +5,41 @@
 import com.gregtechceu.gtceu.api.machine.feature.IDataStickInteractable;
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.AEItemConfigWidget;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.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.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.Style;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
 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;
 
@@ -118,17 +134,122 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 192);
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 176));
+
+        BooleanSyncValue isOnlineValue = SyncHandlers.bool(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        panel.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget()
+                .top(14)
+                .left(7));
 
-        // Config slots
-        group.addWidget(new AEItemConfigWidget(3, 10, this.aeItemHandler));
+        registerConfigActions(syncManager);
+
+        panel.child(new AEConfigWidget(aeItemHandler, CONFIG_SIZE, false)
+                .syncManager(syncManager)
+                .size(8 * 18, 2 * (18 * 2 + 2))
+                .top(26)
+                .alignX(0.5f));
+
+        var theme = this.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
 
-        return group;
+        panel.child(createButtonColumn(panel, syncManager, backgroundTexture));
+
+        panel.child(SlotGroupWidget.playerInventory(true).bottom(7));
+
+        return panel;
+    }
+
+    protected Flow createButtonColumn(ModularPanel panel, PanelSyncManager syncManager,
+                                      UITexture backgroundTexture) {
+        return new Column()
+                .coverChildren()
+                .rightRel(1.0f)
+                .reverseLayout(true)
+                .bottom(16)
+                .padding(5, 2, 4, 4)
+                .childPadding(2)
+                .background(backgroundTexture.getSubArea(0.0f, 0f, 0.75f, 1.0f))
+                .child(GTMuiWidgets.createCircuitSlotPanel(this, panel, syncManager))
+                .child(new ToggleButton()
+                        .value(new BoolValue.Dynamic(this::isDistinct, this::setDistinct))
+                        .stateOverlay(GTGuiTextures.BUTTON_DISTINCT)
+                        .tooltipAutoUpdate(true)
+                        .tooltipBuilder(r -> r
+                                .add(Component.translatable("gtceu.multiblock.universal.distinct")
+                                        .setStyle(Style.EMPTY.withColor(ChatFormatting.YELLOW))
+                                        .append(Component.translatable(
+                                                "gtceu.multiblock.universal.distinct" +
+                                                        (isDistinct() ? ".yes" : ".no"))))));
+    }
+
+    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);
+        });
+
+        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));
+            }
+        });
+
+        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 1de078d911c..62d22b5a112 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
@@ -5,23 +5,37 @@
 import com.gregtechceu.gtceu.api.machine.feature.IDataStickInteractable;
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.AEFluidConfigWidget;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.theme.ThemeAPI;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.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;
@@ -119,17 +133,94 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 192);
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 176));
+
+        BooleanSyncValue isOnlineValue = SyncHandlers.bool(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        panel.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget()
+                .top(14)
+                .left(7));
+
+        registerConfigActions(syncManager);
+
+        panel.child(new AEConfigWidget(aeFluidHandler, CONFIG_SIZE, true)
+                .syncManager(syncManager)
+                .size(8 * 18, 2 * (18 * 2 + 2))
+                .top(26)
+                .alignX(0.5f));
+
+        var theme = this.getDefinition().getThemeId();
+        var backgroundTexture = (UITexture) ThemeAPI.INSTANCE.getTheme(theme).getPanelTheme().getTheme()
+                .getBackground();
+        if (backgroundTexture == null) {
+            backgroundTexture = GTGuiTextures.BACKGROUND;
+        }
+
+        panel.child(createButtonColumn(panel, syncManager, backgroundTexture));
+
+        panel.child(SlotGroupWidget.playerInventory(true).bottom(7));
 
-        // Config slots
-        group.addWidget(new AEFluidConfigWidget(3, 10, this.aeFluidHandler));
+        return panel;
+    }
+
+    protected Flow createButtonColumn(ModularPanel panel, PanelSyncManager syncManager,
+                                      UITexture backgroundTexture) {
+        return new Column()
+                .coverChildren()
+                .rightRel(1.0f)
+                .reverseLayout(true)
+                .bottom(16)
+                .padding(5, 2, 4, 4)
+                .childPadding(2)
+                .background(backgroundTexture.getSubArea(0.0f, 0f, 0.75f, 1.0f))
+                .child(GTMuiWidgets.createCircuitSlotPanel(this, panel, syncManager));
+    }
+
+    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));
+            });
+        });
+
+        syncManager.registerServerSyncedAction("ae_config_clear", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            aeFluidHandler.getInventory()[index].setConfig(null);
+        });
 
-        return group;
+        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 8c7a45b516b..2df604de832 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
@@ -4,16 +4,29 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.DynamicLinkedSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+import com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.AEKeyStorageSyncHandler;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.AEStackDisplayWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.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;
@@ -87,17 +100,47 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 229);
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 176));
+
+        BooleanSyncValue isOnlineValue = SyncHandlers.bool(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        panel.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget()
+                .top(14)
+                .left(7));
+
+        panel.child(new TextWidget<>(IKey.lang("gtceu.gui.waiting_list"))
+                .top(24)
+                .left(7));
+
+        var storageSyncHandler = new AEKeyStorageSyncHandler(internalBuffer);
+        syncManager.syncValue("ae_output_display", storageSyncHandler);
+
+        int[] savedScroll = { 0 };
+        var dynamicHandler = new DynamicLinkedSyncHandler<>(storageSyncHandler)
+                .widgetProvider((sm, value) -> {
+                    var list = value.getValue();
+                    if (list.isEmpty()) return new TextWidget<>(IKey.lang("gtceu.gui.me_network.empty"));
+                    return new ScrollPreservingGrid(savedScroll)
+                            .size(167, 108)
+                            .scrollable(new VerticalScrollData())
+                            .mapTo(9, list, (index, stack) -> new AEStackDisplayWidget(list, index));
+                });
+
+        panel.child(new DynamicSyncedWidget<>()
+                .syncHandler(dynamicHandler)
+                .size(167, 108)
+                .top(34)
+                .alignX(0.5f));
+
+        panel.child(SlotGroupWidget.playerInventory(true).bottom(7));
+
+        return panel;
     }
 
     private class InaccessibleInfiniteHandler extends NotifiableItemStackHandler {
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 268dbdf0831..a292f24dba2 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
@@ -4,19 +4,32 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.DynamicLinkedSyncHandler;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widget.scroll.VerticalScrollData;
+import com.gregtechceu.gtceu.api.mui.widgets.DynamicSyncedWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.TextWidget;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.AEKeyStorageSyncHandler;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.AEStackDisplayWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.widget.mui.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;
@@ -88,17 +101,47 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 229);
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 176));
+
+        BooleanSyncValue isOnlineValue = SyncHandlers.bool(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        panel.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget()
+                .top(14)
+                .left(7));
+
+        panel.child(new TextWidget<>(IKey.lang("gtceu.gui.waiting_list"))
+                .top(24)
+                .left(7));
+
+        var storageSyncHandler = new AEKeyStorageSyncHandler(internalBuffer);
+        syncManager.syncValue("ae_output_display", storageSyncHandler);
+
+        int[] savedScroll = { 0 };
+        var dynamicHandler = new DynamicLinkedSyncHandler<>(storageSyncHandler)
+                .widgetProvider((sm, value) -> {
+                    var list = value.getValue();
+                    if (list.isEmpty()) return new TextWidget<>(IKey.lang("gtceu.gui.me_network.empty"));
+                    return new ScrollPreservingGrid(savedScroll)
+                            .size(167, 108)
+                            .scrollable(new VerticalScrollData())
+                            .mapTo(9, list, (index, stack) -> new AEStackDisplayWidget(list, index));
+                });
+
+        panel.child(new DynamicSyncedWidget<>()
+                .syncHandler(dynamicHandler)
+                .size(167, 108)
+                .top(34)
+                .alignX(0.5f));
+
+        panel.child(SlotGroupWidget.playerInventory(true).bottom(7));
+
+        return panel;
     }
 
     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 47cef66a016..fe557b90f49 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,39 +2,48 @@
 
 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.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableStack;
+import com.gregtechceu.gtceu.api.mui.drawable.DynamicDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.BooleanSyncValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.SlotGroupWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Grid;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.SlotGroup;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.recipe.ingredient.FluidIngredient;
 import com.gregtechceu.gtceu.api.recipe.ingredient.SizedIngredient;
 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.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.machines.GTAEMachines;
-import com.gregtechceu.gtceu.common.item.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.data.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 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 +53,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;
@@ -64,6 +74,7 @@
 import appeng.helpers.patternprovider.PatternContainer;
 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,11 +82,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.Objects;
-import java.util.Set;
+import java.util.*;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -183,7 +190,7 @@ public boolean isWorkingEnabled() {
     public void setCustomName(String newName) {
         customName = newName;
         syncDataHolder.markClientSyncFieldDirty("customName");
-        markAsDirty();
+        markAsChanged();
     }
 
     @Override
@@ -242,11 +249,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();
         }
     }
 
@@ -270,63 +275,160 @@ 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"))));
-    }
 
     @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;
-                                }
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 168);
+
+        panel.child(GTMuiWidgets.createTitleBar(getDefinition(), 176));
+
+        SlotGroup patternSlotGroup = new SlotGroup("pattern_slots", 9, 0, true);
+
+        panel.child(new Grid()
+                .top(25)
+                .height(18 * (MAX_PATTERN_COUNT / 9))
+                .minElementMargin(0, 0)
+                .minColWidth(18).minRowHeight(18)
+                .alignX(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)));
+
+        BooleanSyncValue isOnlineValue = SyncHandlers.bool(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        panel.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget()
+                .top(10)
+                .margin(2)
+                .left(9));
+
+        IPanelHandler renamingPanelHandler = syncManager.syncedPanel("renaming", true,
+                ((syncManager1, syncHandler) -> GTGuis.createPopupPanel("renaming_panel", 110, 40)
+                        .child(new Column()
+                                .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 GTGuis.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)
+                                    .alignX(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) -> GTGuis.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)
+                                .alignX(0.5f)));
+
+        BooleanSyncValue canRefundValue = SyncHandlers.bool(this::canRefund, b -> {});
+        syncManager.syncValue("can_refund", canRefundValue);
+
+        syncManager.registerServerSyncedAction("refundButtonPressed", packet -> refundAll());
+
+        panel.child(new Column()
+                .coverChildren()
+                .leftRel(1.0f)
+                .reverseLayout(true)
+                .bottom(14)
+                .padding(8, 0, 4, 4)
+                .childPadding(2)
+                .background(GTGuiTextures.BACKGROUND.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                .child(GTMuiWidgets.createCircuitSlotPanel(this, panel, syncManager))
+                .child(new ButtonWidget<>() // Shared items subpanel
+                        .size(18)
+                        .onMousePressed((x, y, b) -> {
+                            if (b == InputConstants.MOUSE_BUTTON_LEFT) {
+                                sharedItemsPanelHandler.openPanel();
+                                return true;
                             }
-                            return stack;
+                            return false;
                         })
-                        .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;
+                        .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")))));
+
+        panel.child(SlotGroupWidget.playerInventory(true).bottom(7));
+
+        return panel;
+    }
+
+    public boolean canRefund() {
+        return Arrays.stream(internalInventory).anyMatch(slot -> !slot.isEmpty());
     }
 
     @Override
@@ -463,6 +565,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..23e793db96c 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
@@ -7,12 +7,14 @@
 import com.gregtechceu.gtceu.api.machine.feature.IDataStickInteractable;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredIOPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
+import com.gregtechceu.gtceu.api.mui.factory.PosGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 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;
@@ -88,9 +90,9 @@ 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 ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        assert getBuffer() != null;
+        return getBuffer().buildUI(data, 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 eeefbcfb52f..aca45bf8812 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,16 +1,30 @@
 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.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.integration.ae2.machine.feature.multiblock.IMEStockingPart;
 import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEItemList;
@@ -130,10 +144,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() {
@@ -260,10 +276,40 @@ private void refreshList() {
     ///////////////////////////////
 
     @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IMEStockingPart.super.attachConfigurators(configuratorPanel);
-        super.attachConfigurators(configuratorPanel);
-        configuratorPanel.attachConfigurators(new AutoStockingFancyConfigurator(this));
+    protected Flow createButtonColumn(ModularPanel panel, PanelSyncManager syncManager,
+                                      UITexture backgroundTexture) {
+        IPanelHandler settingsPanelHandler = syncManager.syncedPanel("stocking_settings", true,
+                (sm, sh) -> GTGuis.createPopupPanel("stocking_settings_panel", 140, 70)
+                        .child(new Column()
+                                .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 super.createButtonColumn(panel, syncManager, backgroundTexture)
+                .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"))));
     }
 
     @Override
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 8828557d361..5e1ee801a17 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,16 +1,30 @@
 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;
+import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
+import com.gregtechceu.gtceu.api.mui.base.drawable.IKey;
+import com.gregtechceu.gtceu.api.mui.drawable.ItemDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.UITexture;
+import com.gregtechceu.gtceu.api.mui.value.BoolValue;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.api.mui.value.sync.SyncHandlers;
+import com.gregtechceu.gtceu.api.mui.widgets.ButtonWidget;
+import com.gregtechceu.gtceu.api.mui.widgets.ToggleButton;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Column;
+import com.gregtechceu.gtceu.api.mui.widgets.layout.Flow;
+import com.gregtechceu.gtceu.api.mui.widgets.textfield.TextFieldWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.RichTooltip;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuis;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.integration.ae2.machine.feature.multiblock.IMEStockingPart;
 import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidList;
@@ -132,10 +146,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() {
@@ -243,10 +259,40 @@ private void refreshList() {
     ///////////////////////////////
 
     @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IMEStockingPart.super.attachConfigurators(configuratorPanel);
-        super.attachConfigurators(configuratorPanel);
-        configuratorPanel.attachConfigurators(new AutoStockingFancyConfigurator(this));
+    protected Flow createButtonColumn(ModularPanel panel, PanelSyncManager syncManager,
+                                      UITexture backgroundTexture) {
+        IPanelHandler settingsPanelHandler = syncManager.syncedPanel("stocking_settings", true,
+                (sm, sh) -> GTGuis.createPopupPanel("stocking_settings_panel", 140, 70)
+                        .child(new Column()
+                                .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 super.createButtonColumn(panel, syncManager, backgroundTexture)
+                .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/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/cctweaked/CCTweakedPlugin.java b/src/main/java/com/gregtechceu/gtceu/integration/cctweaked/CCTweakedPlugin.java
index 69329403884..2a258b53c2a 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/cctweaked/CCTweakedPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/cctweaked/CCTweakedPlugin.java
@@ -1,6 +1,6 @@
 package com.gregtechceu.gtceu.integration.cctweaked;
 
-import com.gregtechceu.gtceu.api.capability.forge.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
 import com.gregtechceu.gtceu.api.placeholder.*;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.NotSupportedException;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.PlaceholderException;
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/EmiStackConverter.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/EmiStackConverter.java
new file mode 100644
index 00000000000..79c5effc913
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/EmiStackConverter.java
@@ -0,0 +1,134 @@
+package com.gregtechceu.gtceu.integration.emi;
+
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+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.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.utils.GTMath;
+
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.level.material.Fluids;
+import net.minecraftforge.fluids.FluidStack;
+
+import dev.emi.emi.api.forge.ForgeEmiStack;
+import dev.emi.emi.api.stack.EmiIngredient;
+import dev.emi.emi.api.stack.EmiStack;
+import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Custom EmiStack -> vanilla/forge/mod stack converters
+ */
+public class EmiStackConverter {
+
+    public static final Map<Class<?>, Converter<?>> CONVERTERS = new Reference2ReferenceOpenHashMap<>();
+
+    public static final Converter<ItemStack> ITEM = register(ItemStack.class, new Converter<>() {
+
+        @Override
+        public @Nullable ItemStack convertFrom(EmiStack stack) {
+            Item key = stack.getKeyOfType(Item.class);
+            if (key == null || key == Items.AIR) {
+                return null;
+            }
+            ItemStack itemStack = new ItemStack(key, GTMath.saturatedCast(stack.getAmount()));
+            itemStack.setTag(stack.getNbt());
+            return itemStack;
+        }
+
+        private static EmiIngredient toEMIIngredient(Stream<ItemStack> stream) {
+            return EmiIngredient.of(stream.map(EmiStack::of).toList());
+        }
+
+        @Override
+        public @NotNull EmiIngredient convertTo(EntryList<ItemStack> stack, float chance,
+                                                UnaryOperator<ItemStack> mapper) {
+            if (stack == null || stack.isEmpty()) {
+                return EmiStack.EMPTY;
+            }
+            if (stack instanceof ItemStackList stackList) {
+                return toEMIIngredient(stackList.stream()).setChance(chance);
+            } else if (stack instanceof ItemTagList tagList) {
+                return EmiIngredient.of(tagList.getEntries().stream()
+                        .map(ItemTagList.ItemTagEntry::stacks)
+                        .map(stream -> toEMIIngredient(stream))
+                        .collect(Collectors.toList()), tagList.getEntries().get(0).amount()).setChance(chance);
+            }
+            return EmiStack.EMPTY;
+        }
+    });
+    public static final Converter<FluidStack> FLUID = register(FluidStack.class, new Converter<>() {
+
+        @Override
+        public @Nullable FluidStack convertFrom(EmiStack stack) {
+            Fluid key = stack.getKeyOfType(Fluid.class);
+            if (key == null || key == Fluids.EMPTY) {
+                return null;
+            }
+            return new FluidStack(key, GTMath.saturatedCast(stack.getAmount()), stack.getNbt());
+        }
+
+        private static EmiIngredient toEMIIngredient(Stream<FluidStack> stream) {
+            return EmiIngredient.of(stream.map(ForgeEmiStack::of).toList());
+        }
+
+        @Override
+        public @NotNull EmiIngredient convertTo(EntryList<FluidStack> stack, float chance,
+                                                UnaryOperator<FluidStack> mapper) {
+            if (stack == null || stack.isEmpty()) {
+                return EmiStack.EMPTY;
+            }
+            if (stack instanceof FluidStackList stackList) {
+                return toEMIIngredient(stackList.stream().map(mapper)).setChance(chance);
+            } else if (stack instanceof FluidTagList tagList) {
+                return EmiIngredient.of(tagList.getEntries().stream()
+                        .map(FluidTagList.FluidTagEntry::stacks)
+                        .map(stream -> toEMIIngredient(stream))
+                        .collect(Collectors.toList()), tagList.getEntries().get(0).amount()).setChance(chance);
+            }
+            return EmiStack.EMPTY;
+        }
+    });
+
+    public static <T> Converter<T> register(Class<T> clazz, Converter<T> converter) {
+        CONVERTERS.put(clazz, converter);
+        return converter;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Nullable
+    public static <T> Converter<T> getForNullable(Class<T> clazz) {
+        return (Converter<T>) CONVERTERS.get(clazz);
+    }
+
+    @NotNull
+    public static <T> Optional<Converter<T>> getFor(Class<T> clazz) {
+        return Optional.ofNullable(getForNullable(clazz));
+    }
+
+    public interface Converter<T> {
+
+        @Nullable
+        T convertFrom(EmiStack stack);
+
+        @NotNull
+        EmiIngredient convertTo(EntryList<T> stack, float chance, UnaryOperator<T> mapper);
+
+        @NotNull
+        default EmiIngredient convertTo(IngredientProvider<T> slot) {
+            return this.convertTo(slot.getIngredients(), slot.chance(), slot.renderMappingFunction());
+        }
+    }
+}
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 187e873feac..634a831cc3e 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/GTEMIPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/GTEMIPlugin.java
@@ -4,15 +4,18 @@
 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.client.mui.screen.ContainerScreenWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.ScreenWrapper;
 import com.gregtechceu.gtceu.common.data.GTFluids;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
 import com.gregtechceu.gtceu.common.data.machines.GTMultiMachines;
 import com.gregtechceu.gtceu.common.fluid.potion.PotionFluid;
 import com.gregtechceu.gtceu.common.fluid.potion.PotionFluidHelper;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.integration.emi.circuit.GTProgrammedCircuitCategory;
+import com.gregtechceu.gtceu.integration.emi.handler.EmiScreenHandler;
 import com.gregtechceu.gtceu.integration.emi.multipage.MultiblockInfoEmiCategory;
 import com.gregtechceu.gtceu.integration.emi.oreprocessing.GTOreProcessingEmiCategory;
 import com.gregtechceu.gtceu.integration.emi.orevein.GTBedrockFluidEmiCategory;
@@ -42,6 +45,9 @@ public class GTEMIPlugin implements EmiPlugin {
 
     @Override
     public void register(EmiRegistry registry) {
+        EmiScreenHandler.register(ScreenWrapper.class, registry);
+        EmiScreenHandler.register(ContainerScreenWrapper.class, registry);
+
         // Categories
         registry.addCategory(MultiblockInfoEmiCategory.CATEGORY);
         if (!ConfigHolder.INSTANCE.compat.hideOreProcessingDiagrams)
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 8a56d47c0fe..b15f374402c 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
@@ -2,8 +2,8 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTProgrammedCircuitWidget;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+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/handler/EmiScreenHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/handler/EmiScreenHandler.java
new file mode 100644
index 00000000000..d979606e673
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/handler/EmiScreenHandler.java
@@ -0,0 +1,143 @@
+package com.gregtechceu.gtceu.integration.emi.handler;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.integration.emi.EmiStackConverter;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeViewerHandler;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.material.Fluid;
+
+import dev.emi.emi.api.EmiDragDropHandler;
+import dev.emi.emi.api.EmiExclusionArea;
+import dev.emi.emi.api.EmiRegistry;
+import dev.emi.emi.api.EmiStackProvider;
+import dev.emi.emi.api.stack.EmiIngredient;
+import dev.emi.emi.api.stack.EmiStack;
+import dev.emi.emi.api.stack.EmiStackInteraction;
+import dev.emi.emi.api.widget.Bounds;
+import dev.emi.emi.screen.EmiScreenManager;
+import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+
+public class EmiScreenHandler<T extends Screen & IMuiScreen> extends RecipeViewerHandler
+                             implements EmiExclusionArea<T>, EmiDragDropHandler<T>, EmiStackProvider<T> {
+
+    private static final Map<Class<?>, EmiScreenHandler<?>> CACHE = new Reference2ReferenceOpenHashMap<>();
+
+    @SuppressWarnings("unchecked")
+    public static <T extends Screen & IMuiScreen> EmiScreenHandler<T> of(Class<T> cls) {
+        return (EmiScreenHandler<T>) CACHE.computeIfAbsent(cls, c -> new EmiScreenHandler<T>((Class<T>) c));
+    }
+
+    protected final Class<T> clazz;
+
+    private EmiScreenHandler(Class<T> clazz) {
+        this.clazz = clazz;
+    }
+
+    public void register(EmiRegistry registry) {
+        registry.addExclusionArea(this.clazz, this);
+        registry.addDragDropHandler(this.clazz, this);
+        registry.addStackProvider(this.clazz, this);
+    }
+
+    public static <T extends Screen & IMuiScreen> void register(Class<T> clazz, EmiRegistry registry) {
+        of(clazz).register(registry);
+    }
+
+    @Override
+    public boolean dropStack(T screen, EmiIngredient stack, int x, int y) {
+        List<GhostIngredientSlot<?>> ghostSlots = screen.getScreen().getContext()
+                .getRecipeViewerSettings().getGhostIngredientSlots();
+
+        var stacks = stack.getEmiStacks();
+        if (stacks.isEmpty()) return false;
+        for (EmiStack emiStack : stacks) {
+            for (GhostIngredientSlot<?> slot : ghostSlots) {
+                if (!slot.isEnabled() || !slot.getArea().contains(x, y)) {
+                    continue;
+                }
+                if (slot.ingredientHandlingOverride(emiStack)) {
+                    return true;
+                }
+                EmiStackConverter.Converter<?> converter = EmiStackConverter
+                        .getForNullable(slot.ingredientClass());
+                if (converter == null) {
+                    continue;
+                }
+                var converted = converter.convertFrom(emiStack);
+                if (converted != null) {
+                    // noinspection unchecked,rawtypes
+                    ((GhostIngredientSlot) slot).setGhostIngredient(converted);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void addExclusionArea(T screen, Consumer<Bounds> consumer) {
+        screen.getScreen().getContext()
+                .getRecipeViewerSettings().getAllExclusionAreas()
+                .stream()
+                .map(rect -> new Bounds(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()))
+                .forEach(consumer);
+    }
+
+    @Override
+    public EmiStackInteraction getStackAt(T screen, int x, int y) {
+        IWidget hovered = screen.getScreen().getContext().getTopHovered();
+        if (hovered instanceof IngredientProvider<?> provider) {
+            var override = provider.ingredientOverride();
+            if (override != null) {
+                currentIngredient = (EmiIngredient) override;
+                return new EmiStackInteraction(currentIngredient);
+            }
+
+            EmiStackConverter.Converter<?> converter = EmiStackConverter.getForNullable(provider.ingredientClass());
+            if (converter == null) {
+                return EmiStackInteraction.EMPTY;
+            }
+            @SuppressWarnings({ "rawtypes", "unchecked" })
+            var converted = ((EmiStackConverter.Converter) converter).convertTo(provider);
+            return new EmiStackInteraction(converted, null, false);
+        }
+        return EmiStackInteraction.EMPTY;
+    }
+
+    static EmiIngredient currentIngredient = null;
+
+    @Override
+    public void setSearchFocused(boolean focused) {
+        EmiScreenManager.search.setFocused(focused);
+    }
+
+    @Override
+    public @Nullable Object getCurrentlyDragged() {
+        if (currentIngredient == null || currentIngredient.isEmpty()) return null;
+
+        List<Object> dragged = new ArrayList<>();
+        for (EmiStack stack : currentIngredient.getEmiStacks()) {
+            if (stack.isEmpty()) {
+                continue;
+            }
+            if (stack.getKeyOfType(Item.class) != null) {
+                dragged.add(EmiStackConverter.ITEM.convertFrom(stack));
+            }
+            if (stack.getKeyOfType(Fluid.class) != null) {
+                dragged.add(EmiStackConverter.FLUID.convertFrom(stack));
+            }
+        }
+        return dragged;
+    }
+}
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 ff3eac37e13..fedffb74b58 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..7200b2a9509
--- /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.api.mui.base.widget.ITooltip;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.text.RichText;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.FluidSlot;
+import com.gregtechceu.gtceu.api.mui.widgets.slot.ItemSlot;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.integration.emi.EmiStackConverter;
+import com.gregtechceu.gtceu.integration.recipeviewer.RecipeSlotRole;
+import com.gregtechceu.gtceu.integration.recipeviewer.RecipeViewerScreenWrapper;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid.EmptyFluidTank;
+import com.gregtechceu.gtceu.integration.recipeviewer.util.RecipeScreenRenderingUtil;
+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 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/jade/provider/ExhaustVentBlockProvider.java b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/ExhaustVentBlockProvider.java
index 6c9004ece1d..27742384dc9 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/ExhaustVentBlockProvider.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/ExhaustVentBlockProvider.java
@@ -1,50 +1,31 @@
 package com.gregtechceu.gtceu.integration.jade.provider;
 
 import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IExhaustVentMachine;
+import com.gregtechceu.gtceu.api.machine.trait.ExhaustVentMachineTrait;
 
 import net.minecraft.ChatFormatting;
-import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 
 import org.apache.commons.lang3.StringUtils;
-import org.jetbrains.annotations.Nullable;
 import snownee.jade.api.BlockAccessor;
 import snownee.jade.api.ITooltip;
 import snownee.jade.api.config.IPluginConfig;
 
-public class ExhaustVentBlockProvider extends BlockInfoProvider<IExhaustVentMachine> {
+public class ExhaustVentBlockProvider extends MachineTraitProvider<ExhaustVentMachineTrait> {
 
     public ExhaustVentBlockProvider() {
-        super(GTCEu.id("exhaust_vent_info"));
+        super(GTCEu.id("exhaust_vent_info"), ExhaustVentMachineTrait.TYPE);
     }
 
-    @Nullable
     @Override
-    protected IExhaustVentMachine getCapability(Level level, BlockPos blockPos) {
-        if (MetaMachine.getMachine(level, blockPos) instanceof IExhaustVentMachine exhaustVentMachine) {
-            return exhaustVentMachine;
-        }
-        return null;
-    }
-
-    @Override
-    protected boolean allowDisplaying(IExhaustVentMachine capability) {
-        return super.allowDisplaying(capability);
-    }
-
-    @Override
-    protected void write(CompoundTag compoundTag, IExhaustVentMachine iExhaustVentMachine,
-                         BlockAccessor blockAccessor) {
-        var direction = iExhaustVentMachine.getVentingDirection();
+    protected void write(CompoundTag compoundTag, BlockAccessor blockAccessor, ExhaustVentMachineTrait trait) {
+        var direction = trait.getVentingDirection();
         compoundTag.putString("ventDirection", direction.getName());
         var level = blockAccessor.getLevel();
         var pos = blockAccessor.getPosition().relative(direction);
@@ -52,8 +33,8 @@ protected void write(CompoundTag compoundTag, IExhaustVentMachine iExhaustVentMa
             var key = BuiltInRegistries.BLOCK.getKey(level.getBlockState(pos).getBlock());
             compoundTag.putString("ventBlock", key.toString());
         }
-        compoundTag.putBoolean("ventBlocked", iExhaustVentMachine.isVentingBlocked());
-        compoundTag.putBoolean("needsVenting", iExhaustVentMachine.isNeedsVenting());
+        compoundTag.putBoolean("ventBlocked", trait.isVentingBlocked());
+        compoundTag.putBoolean("needsVenting", trait.isNeedsVenting());
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/HazardCleanerBlockProvider.java b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/HazardCleanerBlockProvider.java
index d0d02160ae4..769f2d95c0b 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/HazardCleanerBlockProvider.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/HazardCleanerBlockProvider.java
@@ -1,34 +1,25 @@
 package com.gregtechceu.gtceu.integration.jade.provider;
 
 import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.machine.feature.IEnvironmentalHazardCleaner;
+import com.gregtechceu.gtceu.api.machine.trait.hazard.EnvironmentalHazardCleanerTrait;
 
-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.entity.player.Player;
-import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 
-import org.jetbrains.annotations.Nullable;
 import snownee.jade.api.BlockAccessor;
 import snownee.jade.api.ITooltip;
 import snownee.jade.api.config.IPluginConfig;
 
-public class HazardCleanerBlockProvider extends CapabilityBlockProvider<IEnvironmentalHazardCleaner> {
+public class HazardCleanerBlockProvider extends MachineTraitProvider<EnvironmentalHazardCleanerTrait> {
 
     public HazardCleanerBlockProvider() {
-        super(GTCEu.id("hazard_cleaner_provider"));
+        super(GTCEu.id("hazard_cleaner_provider"), EnvironmentalHazardCleanerTrait.TYPE);
     }
 
     @Override
-    protected @Nullable IEnvironmentalHazardCleaner getCapability(Level level, BlockPos pos, @Nullable Direction side) {
-        return level.getBlockEntity(pos) instanceof IEnvironmentalHazardCleaner cleaner ? cleaner : null;
-    }
-
-    @Override
-    protected void write(CompoundTag data, IEnvironmentalHazardCleaner capability) {
+    protected void write(CompoundTag data, BlockAccessor block, EnvironmentalHazardCleanerTrait capability) {
         data.putFloat("Cleaned", capability.getRemovedLastSecond());
     }
 
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 43e6a704253..3038c26045a 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJEIPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJEIPlugin.java
@@ -3,14 +3,19 @@
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.recipe.category.GTRecipeCategory;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.client.mui.screen.ContainerScreenWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.client.mui.screen.ScreenWrapper;
 import com.gregtechceu.gtceu.common.data.GTFluids;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
 import com.gregtechceu.gtceu.common.data.machines.GTMultiMachines;
 import com.gregtechceu.gtceu.common.fluid.potion.PotionFluid;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.integration.jei.circuit.GTProgrammedCircuitCategory;
+import com.gregtechceu.gtceu.integration.jei.handler.JeiContainerHandler;
+import com.gregtechceu.gtceu.integration.jei.handler.JeiScreenHandler;
 import com.gregtechceu.gtceu.integration.jei.multipage.MultiblockInfoCategory;
 import com.gregtechceu.gtceu.integration.jei.oreprocessing.GTOreProcessingInfoCategory;
 import com.gregtechceu.gtceu.integration.jei.orevein.GTBedrockFluidInfoCategory;
@@ -25,12 +30,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 +51,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 +78,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 +123,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 +131,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 +140,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);
@@ -130,4 +148,19 @@ public void registerExtraIngredients(IExtraIngredientRegistration registration)
         }
         registration.addExtraIngredients(ForgeTypes.FLUID_STACK, potionFluids);
     }
+
+    @Override
+    public void registerGuiHandlers(IGuiHandlerRegistration registration) {
+        if (GTCEu.Mods.isREILoaded() || GTCEu.Mods.isEMILoaded()) return;
+
+        JeiScreenHandler.register(ScreenWrapper.class, registration);
+        JeiScreenHandler.register(ContainerScreenWrapper.class, registration);
+    }
+
+    @Override
+    public void registerRecipeTransferHandlers(IRecipeTransferRegistration registration) {
+        if (GTCEu.Mods.isREILoaded() || GTCEu.Mods.isEMILoaded()) return;
+
+        JeiContainerHandler.register(ModularContainerMenu.class, registration);
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJeiProperties.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJeiProperties.java
new file mode 100644
index 00000000000..c3e89a1cbb9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJeiProperties.java
@@ -0,0 +1,73 @@
+package com.gregtechceu.gtceu.integration.jei;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
+
+import net.minecraft.client.gui.screens.Screen;
+
+import lombok.Getter;
+import mezz.jei.api.gui.handlers.IGuiProperties;
+import org.apache.commons.lang3.builder.ToStringBuilder;
+
+import java.util.Objects;
+
+/**
+ * This needs to be an immutable class.
+ */
+public class GTJeiProperties implements IGuiProperties {
+
+    @Getter
+    private final Class<? extends Screen> screenClass;
+    @Getter
+    private final int guiLeft;
+    @Getter
+    private final int guiTop;
+    @Getter
+    private final int guiXSize;
+    @Getter
+    private final int guiYSize;
+    @Getter
+    private final int screenWidth;
+    @Getter
+    private final int screenHeight;
+
+    public GTJeiProperties(IMuiScreen screen) {
+        Area mainArea = screen.getScreen().getMainPanel().getArea();
+        Area screenArea = screen.getScreen().getScreenArea();
+        this.screenClass = screen.getWrappedScreen().getClass();
+        this.guiLeft = mainArea.x;
+        this.guiTop = mainArea.y;
+        this.guiXSize = mainArea.width;
+        this.guiYSize = mainArea.height;
+        this.screenWidth = screenArea.width;
+        this.screenHeight = screenArea.height;
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("x", getGuiLeft())
+                .append("y", getGuiTop())
+                .append("width", getGuiXSize())
+                .append("height", getGuiYSize())
+                .append("screenWidth", getScreenWidth())
+                .append("screenHeight", getScreenHeight())
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        GTJeiProperties that = (GTJeiProperties) o;
+        return guiLeft == that.guiLeft && guiTop == that.guiTop && guiXSize == that.guiXSize &&
+                guiYSize == that.guiYSize &&
+                screenWidth == that.screenWidth && screenHeight == that.screenHeight &&
+                Objects.equals(screenClass, that.screenClass);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(screenClass, guiLeft, guiTop, guiXSize, guiYSize, screenWidth, screenHeight);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/GhostIngredientTarget.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/GhostIngredientTarget.java
new file mode 100644
index 00000000000..a8bf9f95eb3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/GhostIngredientTarget.java
@@ -0,0 +1,34 @@
+package com.gregtechceu.gtceu.integration.jei;
+
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+
+import net.minecraft.client.renderer.Rect2i;
+
+import mezz.jei.api.gui.handlers.IGhostIngredientHandler;
+import org.jetbrains.annotations.NotNull;
+
+public class GhostIngredientTarget<I> implements IGhostIngredientHandler.Target<I> {
+
+    private final GhostIngredientSlot<I> ghostSlot;
+
+    public GhostIngredientTarget(GhostIngredientSlot<I> ghostSlot) {
+        this.ghostSlot = ghostSlot;
+    }
+
+    @Override
+    public @NotNull Rect2i getArea() {
+        return this.ghostSlot.getArea().asRect2i();
+    }
+
+    @Override
+    public void accept(@NotNull I ingredient) {
+        if (this.ghostSlot.ingredientHandlingOverride(ingredient)) {
+            return;
+        }
+        ingredient = this.ghostSlot.castGhostIngredientIfValid(ingredient);
+        if (ingredient == null) {
+            throw new IllegalStateException("Ghost slot did accept ingredient before, but now it doesn't.");
+        }
+        this.ghostSlot.setGhostIngredient(ingredient);
+    }
+}
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/handler/JeiContainerHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/handler/JeiContainerHandler.java
new file mode 100644
index 00000000000..21f676a4c06
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/handler/JeiContainerHandler.java
@@ -0,0 +1,106 @@
+package com.gregtechceu.gtceu.integration.jei.handler;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularContainerMenu;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeTransferError;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeTransferHandler;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.MenuType;
+
+import mezz.jei.api.gui.builder.ITooltipBuilder;
+import mezz.jei.api.gui.ingredient.IRecipeSlotsView;
+import mezz.jei.api.recipe.transfer.IRecipeTransferError;
+import mezz.jei.api.recipe.transfer.IRecipeTransferHandlerHelper;
+import mezz.jei.api.recipe.transfer.IUniversalRecipeTransferHandler;
+import mezz.jei.api.registration.IRecipeTransferRegistration;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.Optional;
+
+public class JeiContainerHandler<T extends ModularContainerMenu> implements IUniversalRecipeTransferHandler<T> {
+
+    public static <T extends ModularContainerMenu> void register(Class<T> clz,
+                                                                 IRecipeTransferRegistration registration) {
+        new JeiContainerHandler<>(clz, registration.getTransferHelper()).register(registration);
+    }
+
+    private final Class<T> clazz;
+    private final IRecipeTransferHandlerHelper handlerHelper;
+
+    private JeiContainerHandler(Class<T> clazz, IRecipeTransferHandlerHelper handlerHelper) {
+        this.clazz = clazz;
+        this.handlerHelper = handlerHelper;
+    }
+
+    private void register(IRecipeTransferRegistration registration) {
+        registration.addUniversalRecipeTransferHandler(this);
+    }
+
+    @Override
+    public Class<T> getContainerClass() {
+        return clazz;
+    }
+
+    @Override
+    public Optional<MenuType<T>> getMenuType() {
+        return Optional.empty();
+    }
+
+    @Override
+    public @Nullable IRecipeTransferError transferRecipe(T container, Object recipe, IRecipeSlotsView recipeSlots,
+                                                         Player player, boolean maxTransfer, boolean doTransfer) {
+        ModularScreen screen = container.getScreen();
+        if (screen instanceof RecipeTransferHandler<?> transferHandler &&
+                Objects.equals(recipe.getClass(), transferHandler.getRecipeClass())) {
+            RecipeTransferError muiError = transferHandler.transferRecipeSafe(recipe, maxTransfer, !doTransfer);
+            if (muiError != null) {
+                return new CosmeticJeiTransferError(muiError);
+            }
+        }
+        return null;
+    }
+
+    public record CosmeticJeiTransferError(RecipeTransferError muiError) implements IRecipeTransferError {
+
+        @Override
+        public Type getType() {
+            if (muiError instanceof RecipeTransferError.Internal) {
+                return Type.INTERNAL;
+            } else if (muiError instanceof RecipeTransferError.UserFacing) {
+                return Type.USER_FACING;
+            } else if (muiError instanceof RecipeTransferError.Cosmetic) {
+                return Type.COSMETIC;
+            } else {
+                throw new IllegalStateException(
+                        "Recipe transfer error %s is not an internal, user facing or cosmetic error"
+                                .formatted(muiError));
+            }
+        }
+
+        @Override
+        public int getButtonHighlightColor() {
+            return muiError.getButtonHighlightColor();
+        }
+
+        @Override
+        public void getTooltip(ITooltipBuilder tooltip) {
+            if (this.muiError instanceof RecipeTransferError.UserFacing) {
+                tooltip.add(Component.translatable("jei.tooltip.transfer"));
+                for (Component component : muiError.getTooltip()) {
+                    tooltip.add(component.copy().withStyle(ChatFormatting.RED));
+                }
+            } else {
+                tooltip.addAll(muiError.getTooltip());
+            }
+        }
+
+        @Override
+        public int getMissingCountHint() {
+            return muiError.getMissingCountHint();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/handler/JeiScreenHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/handler/JeiScreenHandler.java
new file mode 100644
index 00000000000..ede283437c2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/handler/JeiScreenHandler.java
@@ -0,0 +1,177 @@
+package com.gregtechceu.gtceu.integration.jei.handler;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.core.mixins.jei.IngredientListOverlayAccessor;
+import com.gregtechceu.gtceu.integration.jei.GTJEIPlugin;
+import com.gregtechceu.gtceu.integration.jei.GTJeiProperties;
+import com.gregtechceu.gtceu.integration.jei.GhostIngredientTarget;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeViewerHandler;
+
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.client.renderer.Rect2i;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+
+import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+import mezz.jei.api.gui.handlers.IGhostIngredientHandler;
+import mezz.jei.api.gui.handlers.IGuiContainerHandler;
+import mezz.jei.api.gui.handlers.IGuiProperties;
+import mezz.jei.api.gui.handlers.IScreenHandler;
+import mezz.jei.api.ingredients.ITypedIngredient;
+import mezz.jei.api.registration.IGuiHandlerRegistration;
+import mezz.jei.api.runtime.IClickableIngredient;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class JeiScreenHandler<T extends Screen & IMuiScreen> extends RecipeViewerHandler
+                             implements IGhostIngredientHandler<T>, IScreenHandler<T> {
+
+    private static final Map<Class<?>, JeiScreenHandler<?>> CACHE = new Reference2ReferenceOpenHashMap<>();
+
+    @SuppressWarnings("unchecked")
+    public static <T extends Screen & IMuiScreen> JeiScreenHandler<T> of(Class<T> clazz) {
+        return (JeiScreenHandler<T>) CACHE.computeIfAbsent(clazz, clz -> new JeiScreenHandler<>((Class<T>) clz));
+    }
+
+    protected final Class<T> clazz;
+
+    private JeiScreenHandler(Class<T> clazz) {
+        this.clazz = clazz;
+    }
+
+    public static <T extends Screen & IMuiScreen, M extends AbstractContainerMenu,
+            T2 extends AbstractContainerScreen<M> & IMuiScreen> void register(Class<T> clazz,
+                                                                              IGuiHandlerRegistration registration) {
+        if (AbstractContainerScreen.class.isAssignableFrom(clazz)) {
+            // noinspection unchecked
+            ContainerScreen.ofContainer((Class<T2>) clazz).register(registration);
+        } else {
+            of(clazz).register(registration);
+        }
+    }
+
+    public void register(IGuiHandlerRegistration registration) {
+        registration.addGhostIngredientHandler(this.clazz, this);
+        registration.addGuiScreenHandler(this.clazz, this);
+    }
+
+    @Override
+    public <I> List<Target<I>> getTargetsTyped(T screen, ITypedIngredient<I> ingredient, boolean doStart) {
+        currentIngredient = ingredient;
+
+        List<GhostIngredientSlot<?>> ghostSlots = screen.getScreen().getContext()
+                .getRecipeViewerSettings().getGhostIngredientSlots();
+        List<Target<I>> ghostHandlerTargets = new ArrayList<>();
+        for (var slot : ghostSlots) {
+            if (slot.isEnabled() && slot.castGhostIngredientIfValid(ingredient.getIngredient()) != null) {
+                @SuppressWarnings("unchecked")
+                GhostIngredientSlot<I> slotWithType = (GhostIngredientSlot<I>) slot;
+                ghostHandlerTargets.add(new GhostIngredientTarget<>(slotWithType));
+            }
+        }
+        return ghostHandlerTargets;
+    }
+
+    @Override
+    public boolean shouldHighlightTargets() {
+        return false;
+    }
+
+    @Override
+    public @Nullable IGuiProperties apply(T guiScreen) {
+        return guiScreen.getScreen().getContext().getRecipeViewerSettings().isEnabled(guiScreen.getScreen()) ?
+                new GTJeiProperties(guiScreen) : null;
+    }
+
+    @Override
+    public void onComplete() {
+        currentIngredient = null;
+    }
+
+    // this is an actual ItemStack/FluidStack instance, **not** an ITypedIngredient or such
+    private static Object currentIngredient = null;
+
+    @Override
+    public void setSearchFocused(boolean focused) {
+        // only set the search field state if it's JEI's actual search field and not JEMI
+        if (GTJEIPlugin.getRuntime().getIngredientListOverlay() instanceof IngredientListOverlayAccessor accessor) {
+            accessor.getSearchField().setFocused(focused);
+        }
+    }
+
+    @Override
+    public @Nullable Object getCurrentlyDragged() {
+        if (currentIngredient == null) return null;
+        return currentIngredient;
+    }
+
+    public static class ContainerScreen<T extends AbstractContainerMenu,
+            T1 extends AbstractContainerScreen<T> & IMuiScreen>
+                                       extends JeiScreenHandler<T1>
+                                       implements IGuiContainerHandler<T1> {
+
+        @SuppressWarnings("unchecked")
+        public static <M extends AbstractContainerMenu,
+                T extends AbstractContainerScreen<M> & IMuiScreen> ContainerScreen<M, T> ofContainer(Class<T> clazz) {
+            return (ContainerScreen<M, T>) CACHE.computeIfAbsent(clazz, clz -> new ContainerScreen<>((Class<T>) clz));
+        }
+
+        private ContainerScreen(Class<T1> clazz) {
+            super(clazz);
+        }
+
+        @Override
+        public void register(IGuiHandlerRegistration registry) {
+            super.register(registry);
+            registry.addGuiContainerHandler(this.clazz, this);
+        }
+
+        @Override
+        public List<Rect2i> getGuiExtraAreas(T1 screen) {
+            return screen.getScreen().getContext()
+                    .getRecipeViewerSettings().getAllExclusionAreas()
+                    .stream().map(Rectangle::asRect2i)
+                    .toList();
+        }
+
+        @Override
+        public Optional<IClickableIngredient<?>> getClickableIngredientUnderMouse(T1 screen, double mouseX,
+                                                                                  double mouseY) {
+            IWidget hovered = screen.getScreen().getContext().getTopHovered();
+            if (hovered instanceof IngredientProvider<?> provider) {
+                var override = provider.ingredientOverride();
+                if (override instanceof IClickableIngredient<?> clickableIngredient) {
+                    JeiScreenHandler.currentIngredient = clickableIngredient.getIngredient();
+                    return Optional.of(clickableIngredient);
+                }
+                if (provider.getIngredients().isEmpty()) return Optional.empty();
+
+                Optional<? extends IClickableIngredient<?>> ingredient = this
+                        .createClickableIngredient(mapFirstIngredient(provider), hovered.getArea());
+
+                JeiScreenHandler.currentIngredient = ingredient.map(IClickableIngredient::getIngredient).orElse(null);
+                // noinspection unchecked
+                return (Optional<IClickableIngredient<?>>) ingredient;
+            }
+            return Optional.empty();
+        }
+
+        private <I> I mapFirstIngredient(IngredientProvider<I> provider) {
+            return provider.renderMappingFunction().apply(provider.getIngredients().getStacks().get(0));
+        }
+
+        private <I> Optional<IClickableIngredient<I>> createClickableIngredient(I ingredient, Rectangle area) {
+            return GTJEIPlugin.getRuntime()
+                    .getIngredientManager()
+                    .createClickableIngredient(ingredient, area.asRect2i(), false);
+        }
+    }
+}
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..616dc0a2fbc 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
@@ -2,56 +2,107 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.widget.WidgetTree;
+import com.gregtechceu.gtceu.api.mui.widget.sizer.Area;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.category.GTRecipeCategory;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
-
-import com.lowdragmc.lowdraglib.jei.IGui2IDrawable;
-import com.lowdragmc.lowdraglib.jei.ModularUIRecipeCategory;
+import com.gregtechceu.gtceu.integration.jei.GTJEIPlugin;
+import com.gregtechceu.gtceu.integration.recipeviewer.RecipeSlotRole;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.integration.recipeviewer.util.RecipeScreenRenderingUtil;
 
 import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.navigation.ScreenPosition;
+import net.minecraft.client.gui.navigation.ScreenRectangle;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.item.crafting.Recipe;
 
-import lombok.Getter;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
 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.gui.builder.IRecipeLayoutBuilder;
+import mezz.jei.api.gui.builder.IRecipeSlotBuilder;
+import mezz.jei.api.gui.builder.ITooltipBuilder;
+import mezz.jei.api.gui.ingredient.IRecipeSlotsView;
+import mezz.jei.api.gui.inputs.IJeiGuiEventListener;
+import mezz.jei.api.gui.widgets.IRecipeExtrasBuilder;
+import mezz.jei.api.gui.widgets.IRecipeWidget;
+import mezz.jei.api.ingredients.IIngredientRenderer;
+import mezz.jei.api.recipe.IFocusGroup;
+import mezz.jei.api.recipe.RecipeIngredientRole;
 import mezz.jei.api.recipe.RecipeType;
+import mezz.jei.api.recipe.category.IRecipeCategory;
 import mezz.jei.api.registration.IRecipeCatalystRegistration;
 import mezz.jei.api.registration.IRecipeRegistration;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.apache.commons.lang3.mutable.MutableInt;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
-public class GTRecipeJEICategory extends ModularUIRecipeCategory<GTRecipe> {
+public abstract class GTRecipeJEICategory<T extends Recipe<?>, W extends IWidget> implements IRecipeCategory<T> {
 
     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;
-
-    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);
+    private final LoadingCache<T, ModularScreen> modularScreenCache;
+
+    /*
+     * private final GTRecipeCategory category;
+     * 
+     * @Getter
+     * private final IDrawable background;
+     * 
+     * @Getter
+     * private final IDrawable icon;
+     */
+
+    protected GTRecipeJEICategory(Function<T, W> wrapperFunction, Function<T, ResourceLocation> recipeIdGetter) {
+        this.modularScreenCache = CacheBuilder.newBuilder()
+                .expireAfterAccess(10, TimeUnit.SECONDS)
+                .maximumSize(10)
+                .build(new CacheLoader<>() {
+
+                    @Override
+                    public ModularScreen load(T recipe) {
+                        W widget = wrapperFunction.apply(recipe);
+                        ResourceLocation recipeId = recipeIdGetter.apply(recipe);
+
+                        ModularPanel panel = ModularPanel.defaultPanel(recipeId.toString(),
+                                widget.getArea().width, widget.getArea().height);
+                        panel.child(widget);
+                        return new ModularScreen(recipeId.getNamespace(), panel);
+                    }
+                });
     }
 
+    /*
+     * 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
@@ -92,20 +143,174 @@ public static RecipeType<?> machineType(GTRecipeCategory category) {
         return TYPES.apply(category);
     }
 
+    private ModularScreen getModularScreen(T recipe) {
+        return this.modularScreenCache.getUnchecked(recipe);
+    }
+
+    private static <T> void addJEISlot(IRecipeLayoutBuilder builder, IngredientProvider<T> widget,
+                                       RecipeIngredientRole role, int index) {
+        var type = GTJEIPlugin.getRuntime().getIngredientManager()
+                .getIngredientTypeChecked(widget.ingredientClass());
+        if (type.isEmpty()) {
+            return;
+        }
+
+        Area widgetArea = widget.getArea();
+        IRecipeSlotBuilder slotBuilder = builder.addSlot(role, widgetArea.x, widgetArea.y);
+
+        slotBuilder.addIngredients(type.get(), widget.getIngredients().getStacks());
+        slotBuilder.setCustomRenderer(type.get(), new IIngredientRenderer<>() {
+
+            @Override
+            public void render(GuiGraphics guiGraphics, T ingredient) {}
+
+            @SuppressWarnings("removal")
+            @Override
+            public List<Component> getTooltip(T ingredient, TooltipFlag tooltipFlag) {
+                return Collections.emptyList();
+            }
+
+            @Override
+            public int getWidth() {
+                return widgetArea.width;
+            }
+
+            @Override
+            public int getHeight() {
+                return widgetArea.height;
+            }
+        });
+        // set slot name
+        slotBuilder.setSlotName("slot_" + index);
+    }
+
     @Override
-    @NotNull
-    public RecipeType<GTRecipe> getRecipeType() {
-        return TYPES.apply(category);
+    public void setRecipe(IRecipeLayoutBuilder builder, T recipe, IFocusGroup focuses) {
+        ModularScreen screen = getModularScreen(recipe);
+
+        MutableInt i = new MutableInt(0);
+        WidgetTree.foreachChildBFS(screen.getMainPanel(), widget -> {
+            if (!(widget instanceof IngredientProvider<?> provider)) {
+                return true;
+            }
+            RecipeIngredientRole role = mapToRole(provider.recipeRole());
+            addJEISlot(builder, provider, role, i.getAndIncrement());
+            return true;
+        }, true);
     }
 
     @Override
-    @NotNull
-    public Component getTitle() {
-        return Component.translatable(category.getLanguageKey());
+    public void createRecipeExtras(IRecipeExtrasBuilder builder, T recipe, IFocusGroup focuses) {
+        builder.addGuiEventListener(new ModularUIGuiEventListener(recipe));
+        builder.addWidget(new UIForegroundRenderWidget(recipe));
     }
 
     @Override
-    public @Nullable ResourceLocation getRegistryName(@NotNull GTRecipe recipe) {
-        return recipe.id;
+    public void draw(T recipe, IRecipeSlotsView recipeSlotsView, GuiGraphics guiGraphics, double mouseX,
+                     double mouseY) {
+        ModularScreen screen = getModularScreen(recipe);
+
+        RecipeScreenRenderingUtil.drawScreenBackground(guiGraphics, screen, (int) mouseX, (int) mouseY,
+                Minecraft.getInstance().getPartialTick());
+    }
+
+    @Override
+    public void getTooltip(ITooltipBuilder tooltip, T recipe, IRecipeSlotsView recipeSlotsView, double mouseX,
+                           double mouseY) {
+        // tooltip.clear();
+    }
+
+    public static RecipeIngredientRole mapToRole(RecipeSlotRole slotRole) {
+        return switch (slotRole) {
+            case INPUT -> RecipeIngredientRole.INPUT;
+            case OUTPUT -> RecipeIngredientRole.OUTPUT;
+            case CATALYST -> RecipeIngredientRole.CATALYST;
+            case RENDER_ONLY -> RecipeIngredientRole.RENDER_ONLY;
+        };
     }
+
+    public class ModularUIGuiEventListener implements IJeiGuiEventListener {
+
+        private final T recipe;
+
+        public ModularUIGuiEventListener(T recipe) {
+            this.recipe = recipe;
+        }
+
+        public ScreenRectangle getArea() {
+            return getModularScreen(this.recipe).getRectangle();
+        }
+
+        @Override
+        public void mouseMoved(double mouseX, double mouseY) {
+            getModularScreen(this.recipe).mouseMoved(mouseX, mouseY);
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            return getModularScreen(this.recipe).mouseClicked(mouseX, mouseY, button);
+        }
+
+        @Override
+        public boolean mouseReleased(double mouseX, double mouseY, int button) {
+            return getModularScreen(this.recipe).mouseReleased(mouseX, mouseY, button);
+        }
+
+        @Override
+        public boolean mouseDragged(double mouseX, double mouseY, int button, double dragX, double dragY) {
+            return getModularScreen(this.recipe).mouseDragged(mouseX, mouseY, button, dragX, dragY);
+        }
+
+        @Override
+        public boolean mouseScrolled(double mouseX, double mouseY, double scrollDelta) {
+            return getModularScreen(this.recipe).mouseScrolled(mouseX, mouseY, scrollDelta);
+        }
+
+        @Override
+        public boolean keyPressed(double mouseX, double mouseY, int keyCode, int scanCode, int modifiers) {
+            return getModularScreen(this.recipe).keyPressed(keyCode, scanCode, modifiers);
+        }
+    }
+
+    public class UIForegroundRenderWidget implements IRecipeWidget {
+
+        private final T recipe;
+
+        public UIForegroundRenderWidget(T recipe) {
+            this.recipe = recipe;
+        }
+
+        @Override
+        public ScreenPosition getPosition() {
+            return new ScreenPosition(0, 0);
+        }
+
+        @Override
+        public void drawWidget(GuiGraphics guiGraphics, double mouseX, double mouseY) {
+            ModularScreen screen = getModularScreen(this.recipe);
+            RecipeScreenRenderingUtil.drawScreenForeground(guiGraphics, screen, (int) mouseX, (int) mouseY,
+                    Minecraft.getInstance().getPartialTick());
+        }
+    }
+
+    /*
+     * @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 282112a3928..dc85215b01c 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/kjs/GregTechKubeJSPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/kjs/GregTechKubeJSPlugin.java
@@ -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,
@@ -515,7 +513,7 @@ public void injectRuntimeRecipes(RecipesEventJS event, RecipeManager manager,
             if (!(recipeType instanceof GTRecipeType gtRecipeType)) {
                 continue;
             }
-            gtRecipeType.getAdditionHandler().beginStaging();
+            gtRecipeType.beginStagingRecipes();
             gtRecipeType.getProxyRecipes().forEach((type, list) -> {
                 RecipeManagerHandler.addProxyRecipesToLookup(recipesByName, gtRecipeType, type, list);
             });
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/kjs/recipe/GTRecipeSchema.java b/src/main/java/com/gregtechceu/gtceu/integration/kjs/recipe/GTRecipeSchema.java
index 280c5d5aba5..7704d092f7b 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/kjs/recipe/GTRecipeSchema.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/kjs/recipe/GTRecipeSchema.java
@@ -21,7 +21,7 @@
 import com.gregtechceu.gtceu.api.recipe.ingredient.*;
 import com.gregtechceu.gtceu.api.recipe.ingredient.nbtpredicate.NBTPredicate;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.common.recipe.condition.*;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.builder.GTRecipeBuilder;
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/RecipeSlotRole.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeSlotRole.java
new file mode 100644
index 00000000000..936798237b5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeSlotRole.java
@@ -0,0 +1,26 @@
+package com.gregtechceu.gtceu.integration.recipeviewer;
+
+/**
+ * The relationship between an ingredient and a recipe.
+ */
+public enum RecipeSlotRole {
+    /**
+     * Input ingredients are consumed when a recipe is crafted.
+     */
+    INPUT,
+    /**
+     * Output ingredients are the result of a crafted recipe.
+     */
+    OUTPUT,
+    /**
+     * Catalysts are ingredients that are necessary for crafting, but are not consumed.
+     * These are treated similarly to {@link #INPUT}.
+     * Examples may be a crafting table, a furnace, or an ingredient that sits in the crafting grid but is not used up.
+     */
+    CATALYST,
+    /**
+     * Render-only ingredients should be drawn, and can be navigated on,
+     * but are ignored when looking up the recipe.
+     */
+    RENDER_ONLY
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeViewerScreenWrapper.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeViewerScreenWrapper.java
new file mode 100644
index 00000000000..94061b7eec6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeViewerScreenWrapper.java
@@ -0,0 +1,28 @@
+package com.gregtechceu.gtceu.integration.recipeviewer;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+
+import org.jetbrains.annotations.NotNull;
+
+public record RecipeViewerScreenWrapper(ModularScreen screen) implements IMuiScreen {
+
+    @Override
+    public Screen getWrappedScreen() {
+        return Minecraft.getInstance().screen;
+    }
+
+    @Override
+    public @NotNull ModularScreen getScreen() {
+        return screen;
+    }
+
+    @Override
+    public void updateGuiArea(Rectangle area) {
+        // overlay should not modify screen
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeViewerState.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeViewerState.java
new file mode 100644
index 00000000000..37ef796b5f8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/RecipeViewerState.java
@@ -0,0 +1,30 @@
+package com.gregtechceu.gtceu.integration.recipeviewer;
+
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+import java.util.function.Predicate;
+
+public enum RecipeViewerState implements Predicate<ModularScreen> {
+
+    ENABLED {
+
+        @Override
+        public boolean test(ModularScreen screen) {
+            return true;
+        }
+    },
+    DISABLED {
+
+        @Override
+        public boolean test(ModularScreen screen) {
+            return false;
+        }
+    },
+    DEFAULT {
+
+        @Override
+        public boolean test(ModularScreen screen) {
+            return !screen.isClientOnly();
+        }
+    }
+}
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/recipeviewer/handlers/GhostIngredientSlot.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/GhostIngredientSlot.java
new file mode 100644
index 00000000000..6299cf1c3e7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/GhostIngredientSlot.java
@@ -0,0 +1,61 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers;
+
+import com.gregtechceu.gtceu.api.mui.base.RecipeViewerSettings;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.drawable.GuiDraw;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.api.mui.widget.Widget;
+import com.gregtechceu.gtceu.client.mui.screen.viewport.GuiContext;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * An interface for compat with recipe viewers' ghost slots.
+ * Implement this on any {@link IWidget}.
+ * This slot must then be manually registered in something like {@link Widget#onInit()}
+ * with {@link RecipeViewerSettings#addGhostIngredientSlot(IWidget)}
+ *
+ * @param <I> type of the ingredient
+ */
+public interface GhostIngredientSlot<I> extends IWidget {
+
+    /**
+     * Puts the ingredient in this ghost slot.
+     * Was cast with {@link #castGhostIngredientIfValid(Object)}.
+     *
+     * @param ingredient ingredient to put
+     */
+    void setGhostIngredient(@NotNull I ingredient);
+
+    /**
+     * Tries to cast an ingredient to the type of this slot.
+     * Returns null if the ingredient can't be cast.
+     * Must be consistent.
+     *
+     * @param ingredient ingredient to cast
+     * @return cast ingredient or null
+     */
+    @Nullable
+    I castGhostIngredientIfValid(@NotNull Object ingredient);
+
+    /**
+     * @return the class of the ingredient this slot expects
+     */
+    Class<I> ingredientClass();
+
+    /**
+     * A way to handle recipeviewer-specific ingredient instances.
+     *
+     * @return {@code true} if handling the ingredient yourself.
+     */
+    default boolean ingredientHandlingOverride(Object ingredient) {
+        return false;
+    }
+
+    default void drawHighlight(GuiContext context, Rectangle area, boolean hovering) {
+        int color = hovering ? Color.argb(76, 201, 25, 128) : Color.argb(19, 201, 10, 64);
+        GuiDraw.drawRect(context.getGraphics(), 0, 0, area.width, area.height, color);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/IngredientProvider.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/IngredientProvider.java
new file mode 100644
index 00000000000..65fa348e505
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/IngredientProvider.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers;
+
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.RecipeSlotRole;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.UnaryOperator;
+
+/**
+ * An interface for recipe viewers to get the ingredient from a widget to show recipes for example.
+ * Implement this on {@link com.gregtechceu.gtceu.api.mui.base.widget.IWidget}.
+ * No further registration needed.
+ *
+ * @param <I> type of the ingredient
+ */
+public interface IngredientProvider<I> extends IWidget {
+
+    EntryList<I> getIngredients();
+
+    default UnaryOperator<I> renderMappingFunction() {
+        return UnaryOperator.identity();
+    }
+
+    default float chance() {
+        return 1.0f;
+    }
+
+    /**
+     * @return the class of the ingredient this slot contains
+     */
+    @NotNull
+    Class<I> ingredientClass();
+
+    /**
+     * @return a recipeviewer-specific ingredient instance, or {@code null} if defaulting to the class-based logic.
+     */
+    @Nullable
+    default Object ingredientOverride() {
+        return null;
+    }
+
+    @NotNull
+    default RecipeSlotRole recipeRole() {
+        return RecipeSlotRole.RENDER_ONLY;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeTransferError.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeTransferError.java
new file mode 100644
index 00000000000..50f045bfbb2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeTransferError.java
@@ -0,0 +1,119 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers;
+
+import net.minecraft.network.chat.Component;
+
+import lombok.Getter;
+import mezz.jei.api.recipe.transfer.IRecipeTransferHandlerHelper;
+
+import java.util.List;
+
+/**
+ * A reason that a recipe transfer couldn't happen.
+ * <p>
+ * Recipe transfer errors can be created with {@link IRecipeTransferHandlerHelper} or you can implement your own.
+ * These errors are returned from {@link RecipeTransferHandler#transferRecipe(Object, boolean, boolean)}.
+ * </p>
+ */
+public abstract sealed class RecipeTransferError permits RecipeTransferError.Internal, RecipeTransferError.UserFacing,
+                                                 RecipeTransferError.Cosmetic {
+
+    public abstract boolean allowsTransfer();
+
+    /**
+     * Return the ARGB color of the additional button highlight for {@link Cosmetic}.
+     * For example, return 0 to disable the colored highlight. Default color is orange.
+     */
+    public int getButtonHighlightColor() {
+        return 0x80FFA500;
+    }
+
+    /**
+     * Called on {@link UserFacing} and {@link Cosmetic} errors.
+     */
+    public List<Component> getTooltip() {
+        return List.of();
+    }
+
+    /**
+     * Get the estimated number of inputs of the recipe that cannot be found in the container.
+     *
+     * This is used to help sort recipes with more matches first, so that if a player
+     * has many (or all) of the items required for a recipe in their inventory, it is shown first.
+     *
+     * @return the number of input recipes slots are missing ingredient's in the player's inventory.
+     *         Return -1 by default to avoid sorting
+     *
+     * @since 19.2.0
+     */
+    public int getMissingCountHint() {
+        return -1;
+    }
+
+    /**
+     * Errors where the Transfer handler is broken or does not work.
+     * These errors will hide the recipe transfer button, and do not display anything to the user.
+     */
+    public static final class Internal extends RecipeTransferError {
+
+        public static final Internal INSTANCE = new Internal();
+
+        private Internal() {}
+
+        @Override
+        public boolean allowsTransfer() {
+            return false;
+        }
+    }
+
+    /**
+     * Errors that the player can fix. Missing items, inventory full, etc.
+     * Something informative will be shown to the player.
+     */
+    public static non-sealed class UserFacing extends RecipeTransferError {
+
+        public UserFacing() {}
+
+        @Override
+        public boolean allowsTransfer() {
+            return false;
+        }
+
+        /**
+         * An error that shows a tooltip.
+         */
+        public static class Tooltip extends UserFacing {
+
+            @Getter
+            private final List<Component> message;
+
+            public Tooltip(Component message) {
+                this(List.of(message));
+            }
+
+            public Tooltip(List<Component> message) {
+                this.message = message;
+            }
+
+            @Override
+            public List<Component> getTooltip() {
+                return message;
+            }
+        }
+    }
+
+    /**
+     * Errors that still allow the usage of the recipe transfer button.
+     * Hovering over the button will display the error, however the button is active and can be used.
+     *
+     * @since 6.0.2
+     */
+    public static non-sealed class Cosmetic extends RecipeTransferError {
+
+        public Cosmetic() {}
+
+        @Override
+        public boolean allowsTransfer() {
+            return true;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeTransferHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeTransferHandler.java
new file mode 100644
index 00000000000..528aec852e4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeTransferHandler.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * An interface to handle recipe transfers.
+ * Implement this on {@link com.gregtechceu.gtceu.client.mui.screen.ModularScreen}.
+ * No further registration needed.
+ */
+@ApiStatus.Experimental
+public interface RecipeTransferHandler<T> {
+
+    @SuppressWarnings("unchecked")
+    @ApiStatus.NonExtendable
+    @ApiStatus.Internal
+    default RecipeTransferError transferRecipeSafe(Object recipe, boolean maxTransfer, boolean simulate) {
+        return this.transferRecipe((T) recipe, maxTransfer, simulate);
+    }
+
+    /**
+     * Transfers a recipe viewer recipe.
+     *
+     * @param recipe      the recipe
+     * @param maxTransfer true if shift is being held
+     * @param simulate    if the transfer is simulated
+     * @return a transfer error or null if successful
+     */
+    RecipeTransferError transferRecipe(T recipe, boolean maxTransfer, boolean simulate);
+
+    Class<T> getRecipeClass();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeViewerHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeViewerHandler.java
new file mode 100644
index 00000000000..fa0e7a51e93
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/RecipeViewerHandler.java
@@ -0,0 +1,68 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.client.mui.screen.ScreenWrapper;
+import com.gregtechceu.gtceu.integration.emi.handler.EmiScreenHandler;
+import com.gregtechceu.gtceu.integration.jei.handler.JeiScreenHandler;
+import com.gregtechceu.gtceu.integration.rei.handler.REIScreenHandler;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public abstract class RecipeViewerHandler {
+
+    private static RecipeViewerHandler current = null;
+
+    @NotNull
+    public static RecipeViewerHandler getCurrent() {
+        if (current == null) {
+            Supplier<Function<Class<ScreenWrapper>, ? extends RecipeViewerHandler>> supplier;
+            if (GTCEu.isModLoaded(GTValues.MODID_EMI)) {
+                supplier = () -> EmiScreenHandler::of;
+            } else if (GTCEu.isModLoaded(GTValues.MODID_REI)) {
+                supplier = () -> REIScreenHandler::of;
+            } else if (GTCEu.isModLoaded(GTValues.MODID_JEI)) {
+                supplier = () -> JeiScreenHandler::of;
+            } else {
+                supplier = () -> cls -> DUMMY;
+            }
+            current = supplier.get().apply(ScreenWrapper.class);
+        }
+        return current;
+    }
+
+    public abstract void setSearchFocused(boolean focused);
+
+    public abstract @Nullable Object getCurrentlyDragged();
+
+    public boolean isHoveringOver(GhostIngredientSlot<?> slot) {
+        Object currentlyDragged = getCurrentlyDragged();
+        if (currentlyDragged == null) {
+            return false;
+        } else if (currentlyDragged instanceof Iterable<?> iterable) {
+            for (Object dragged : iterable) {
+                if (slot.castGhostIngredientIfValid(dragged) != null) {
+                    return true;
+                }
+            }
+            return false;
+        } else {
+            return slot.castGhostIngredientIfValid(currentlyDragged) != null;
+        }
+    }
+
+    private static final RecipeViewerHandler DUMMY = new RecipeViewerHandler() {
+
+        @Override
+        public void setSearchFocused(boolean focused) {}
+
+        @Override
+        public @Nullable Object getCurrentlyDragged() {
+            return null;
+        }
+    };
+}
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/util/RecipeScreenRenderingUtil.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/util/RecipeScreenRenderingUtil.java
new file mode 100644
index 00000000000..ee6582f2641
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/util/RecipeScreenRenderingUtil.java
@@ -0,0 +1,67 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.util;
+
+import com.gregtechceu.gtceu.api.mui.utils.Stencil;
+import com.gregtechceu.gtceu.client.mui.screen.ClientScreenHandler;
+import com.gregtechceu.gtceu.client.mui.screen.ModularScreen;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraftforge.items.IItemHandlerModifiable;
+import net.minecraftforge.items.wrapper.EmptyHandler;
+
+import com.mojang.blaze3d.platform.Lighting;
+import com.mojang.blaze3d.systems.RenderSystem;
+import org.jetbrains.annotations.ApiStatus;
+
+public class RecipeScreenRenderingUtil {
+
+    public static final IItemHandlerModifiable EMPTY_ITEM_HANDLER = new EmptyHandler();
+
+    @ApiStatus.Internal
+    public static void drawScreenBackground(GuiGraphics guiGraphics, ModularScreen screen,
+                                            int mouseX, int mouseY, float partialTick) {
+        screen.getContext().setGraphics(guiGraphics);
+        screen.getContext().updateState(mouseX, mouseY, partialTick);
+        screen.getContext().graphicsPose().pushPose();
+
+        // copied from ClientScreenHandler#drawScreenInternal to
+        // let us draw foreground elements separately after everything else.
+        Stencil.reset();
+        screen.getContext().getStencil().push(screen.getScreenArea());
+
+        screen.render(guiGraphics, mouseX, mouseY, partialTick);
+
+        RenderSystem.disableDepthTest();
+
+        ClientScreenHandler.drawVanillaElements(guiGraphics, screen.getScreenWrapper().getWrappedScreen(),
+                mouseX, mouseY, partialTick);
+
+        RenderSystem.enableDepthTest();
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+
+        screen.getContext().getStencil().pop();
+        screen.getContext().graphicsPose().popPose();
+    }
+
+    @ApiStatus.Internal
+    public static void drawScreenForeground(GuiGraphics guiGraphics, ModularScreen screen,
+                                            int mouseX, int mouseY, float partialTick) {
+        screen.getContext().setGraphics(guiGraphics);
+        screen.getContext().updateState(mouseX, mouseY, partialTick);
+        screen.getContext().graphicsPose().pushPose();
+
+        // copied from ClientScreenHandler#drawScreenInternal to
+        // let us draw foreground elements separately after everything else.
+        screen.getContext().getStencil().push(screen.getScreenArea());
+        RenderSystem.disableDepthTest();
+        Lighting.setupForFlatItems();
+
+        screen.drawForeground(guiGraphics, partialTick);
+
+        RenderSystem.enableDepthTest();
+        Lighting.setupFor3DItems();
+        RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f);
+
+        screen.getContext().getStencil().pop();
+        screen.getContext().graphicsPose().popPose();
+    }
+}
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..f39359efe27
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTMuiRecipeWidget.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
+
+import com.gregtechceu.gtceu.api.mui.widget.ParentWidget;
+import com.gregtechceu.gtceu.api.recipe.GTRecipe;
+
+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 89%
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 3846d3c0635..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,9 +1,9 @@
-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;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
-import com.gregtechceu.gtceu.common.item.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 
 import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
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/GTREIPlugin.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/GTREIPlugin.java
index 6d3db3661eb..de23acf9949 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/GTREIPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/GTREIPlugin.java
@@ -5,12 +5,15 @@
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.recipe.category.GTRecipeCategory;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.client.mui.screen.ContainerScreenWrapper;
+import com.gregtechceu.gtceu.client.mui.screen.ScreenWrapper;
 import com.gregtechceu.gtceu.common.data.*;
 import com.gregtechceu.gtceu.common.data.machines.GTMultiMachines;
 import com.gregtechceu.gtceu.common.fluid.potion.PotionFluid;
 import com.gregtechceu.gtceu.common.fluid.potion.PotionFluidHelper;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.integration.rei.circuit.GTProgrammedCircuitCategory;
+import com.gregtechceu.gtceu.integration.rei.handler.REIScreenHandler;
 import com.gregtechceu.gtceu.integration.rei.multipage.MultiblockInfoDisplayCategory;
 import com.gregtechceu.gtceu.integration.rei.oreprocessing.GTOreProcessingDisplayCategory;
 import com.gregtechceu.gtceu.integration.rei.orevein.GTBedrockFluidDisplayCategory;
@@ -29,6 +32,8 @@
 import me.shedaniel.rei.api.client.registry.display.DisplayRegistry;
 import me.shedaniel.rei.api.client.registry.entry.CollapsibleEntryRegistry;
 import me.shedaniel.rei.api.client.registry.entry.EntryRegistry;
+import me.shedaniel.rei.api.client.registry.screen.ExclusionZones;
+import me.shedaniel.rei.api.client.registry.screen.ScreenRegistry;
 import me.shedaniel.rei.api.common.entry.EntryStack;
 import me.shedaniel.rei.api.common.entry.comparison.FluidComparatorRegistry;
 import me.shedaniel.rei.api.common.entry.comparison.ItemComparatorRegistry;
@@ -85,6 +90,18 @@ public void registerDisplays(DisplayRegistry registry) {
         registry.add(new GTProgrammedCircuitCategory.GTProgrammedCircuitDisplay());
     }
 
+    @Override
+    public void registerExclusionZones(ExclusionZones zones) {
+        zones.register(ScreenWrapper.class, REIScreenHandler.of(ScreenWrapper.class));
+        zones.register(ContainerScreenWrapper.class, REIScreenHandler.of(ContainerScreenWrapper.class));
+    }
+
+    @Override
+    public void registerScreens(ScreenRegistry registry) {
+        registry.registerDraggableStackProvider(REIScreenHandler.of(ScreenWrapper.class));
+        registry.registerDraggableStackVisitor(REIScreenHandler.of(ScreenWrapper.class).getDraggableVisitor());
+    }
+
     @Override
     @SuppressWarnings("UnstableApiUsage")
     public void registerCollapsibleEntries(CollapsibleEntryRegistry registry) {
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/handler/REIScreenHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/handler/REIScreenHandler.java
new file mode 100644
index 00000000000..43b05694c52
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/handler/REIScreenHandler.java
@@ -0,0 +1,166 @@
+package com.gregtechceu.gtceu.integration.rei.handler;
+
+import com.gregtechceu.gtceu.api.mui.base.IMuiScreen;
+import com.gregtechceu.gtceu.api.mui.base.widget.IWidget;
+import com.gregtechceu.gtceu.api.mui.utils.Rectangle;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.GhostIngredientSlot;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.RecipeViewerHandler;
+
+import net.minecraft.client.gui.screens.Screen;
+
+import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+import lombok.Getter;
+import me.shedaniel.rei.api.client.REIRuntime;
+import me.shedaniel.rei.api.client.gui.drag.*;
+import me.shedaniel.rei.api.client.gui.widgets.TextField;
+import me.shedaniel.rei.api.client.registry.screen.ExclusionZonesProvider;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+public class REIScreenHandler<T extends Screen & IMuiScreen> extends RecipeViewerHandler
+                             implements DraggableStackProvider<T>, ExclusionZonesProvider<T> {
+
+    private static final Map<Class<?>, REIScreenHandler<?>> CACHE = new Reference2ReferenceOpenHashMap<>();
+
+    @SuppressWarnings("unchecked")
+    public static <T extends Screen & IMuiScreen> REIScreenHandler<T> of(Class<T> cls) {
+        return (REIScreenHandler<T>) CACHE.computeIfAbsent(cls, c -> new REIScreenHandler<T>());
+    }
+
+    // I have to do this mess because of conflicting comparable impls.
+    @Getter
+    private final DraggableStackVisitor<T> draggableVisitor = new DraggableStackVisitor<T>() {
+
+        @Override
+        public <R extends Screen> boolean isHandingScreen(R screen) {
+            return REIScreenHandler.this.isHandingScreen(screen);
+        }
+
+        @Override
+        public Stream<BoundsProvider> getDraggableAcceptingBounds(DraggingContext<T> context,
+                                                                  DraggableStack stack) {
+            currentIngredient = stack;
+            return context.getScreen().getScreen().getContext()
+                    .getRecipeViewerSettings().getGhostIngredientSlots().stream()
+                    .map(target -> BoundsProvider.ofRectangle(asREIRect(target.getArea())));
+        }
+
+        @Override
+        public DraggedAcceptorResult acceptDraggedStack(DraggingContext<T> context,
+                                                        DraggableStack stack) {
+            List<GhostIngredientSlot<?>> ghostSlots = context.getScreen().getScreen().getContext()
+                    .getRecipeViewerSettings().getGhostIngredientSlots();
+            for (var slot : ghostSlots) {
+                if (!slot.isEnabled()) {
+                    continue;
+                }
+                var entryStack = stack.getStack();
+
+                if (slot.ingredientHandlingOverride(entryStack)) {
+                    currentIngredient = null;
+                    return DraggedAcceptorResult.ACCEPTED;
+                }
+                REIStackConverter.Converter<?> converter = REIStackConverter.getForNullable(slot.ingredientClass());
+                if (converter == null) {
+                    continue;
+                }
+                var converted = converter.convertFrom(entryStack);
+                if (converted != null) {
+                    // noinspection unchecked,rawtypes
+                    ((GhostIngredientSlot) slot).setGhostIngredient(converted);
+                    currentIngredient = null;
+                    return DraggedAcceptorResult.ACCEPTED;
+                }
+            }
+            currentIngredient = null;
+            return DraggedAcceptorResult.PASS;
+        }
+    };
+
+    private REIScreenHandler() {}
+
+    @Override
+    public @Nullable DraggableStack getHoveredStack(DraggingContext<T> context, double mouseX, double mouseY) {
+        IWidget hovered = context.getScreen().getScreen().getContext().getTopHovered();
+        if (hovered instanceof IngredientProvider<?> provider) {
+            var override = provider.ingredientOverride();
+            if (override != null) {
+                currentIngredient = (DraggableStack) override;
+                return currentIngredient;
+            }
+
+            REIStackConverter.Converter<?> converter = REIStackConverter.getForNullable(provider.ingredientClass());
+            if (converter == null) {
+                return null;
+            }
+            @SuppressWarnings({ "rawtypes", "unchecked" })
+            var converted = ((REIStackConverter.Converter) converter).convertTo(provider);
+            return new DraggableStack() {
+
+                @Override
+                public EntryStack<?> getStack() {
+                    if (converted.isEmpty()) return EntryStack.empty();
+                    return converted.get(0);
+                }
+
+                @Override
+                public void drag() {
+                    currentIngredient = this;
+                }
+
+                @Override
+                public void release(DraggedAcceptorResult result) {
+                    currentIngredient = null;
+                }
+            };
+        }
+        return null;
+    }
+
+    @Override
+    public <R extends Screen> boolean isHandingScreen(R screen) {
+        return screen instanceof IMuiScreen;
+    }
+
+    @Override
+    public DraggingContext<T> getContext() {
+        return DraggableStackProvider.super.getContext();
+    }
+
+    @Override
+    public double getPriority() {
+        return DraggableStackProvider.super.getPriority();
+    }
+
+    @Override
+    public Collection<me.shedaniel.math.Rectangle> provide(T screen) {
+        return screen.getScreen().getContext()
+                .getRecipeViewerSettings().getAllExclusionAreas().stream()
+                .map(REIScreenHandler::asREIRect)
+                .toList();
+    }
+
+    private static me.shedaniel.math.Rectangle asREIRect(Rectangle rect) {
+        return new me.shedaniel.math.Rectangle(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
+    }
+
+    static DraggableStack currentIngredient = null;
+
+    @Override
+    public void setSearchFocused(boolean focused) {
+        TextField searchField = REIRuntime.getInstance().getSearchTextField();
+        if (searchField != null) searchField.setFocused(focused);
+    }
+
+    @Override
+    public @Nullable Object getCurrentlyDragged() {
+        if (currentIngredient == null) return null;
+        return currentIngredient.get().getValue();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/handler/REIStackConverter.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/handler/REIStackConverter.java
new file mode 100644
index 00000000000..9eeac1add41
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/handler/REIStackConverter.java
@@ -0,0 +1,141 @@
+package com.gregtechceu.gtceu.integration.rei.handler;
+
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+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.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.IngredientProvider;
+import com.gregtechceu.gtceu.utils.GTMath;
+
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+import me.shedaniel.rei.api.common.entry.EntryIngredient;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import me.shedaniel.rei.api.common.entry.type.EntryType;
+import me.shedaniel.rei.api.common.entry.type.VanillaEntryTypes;
+import me.shedaniel.rei.api.common.util.EntryStacks;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Custom EntryStack -> vanilla/forge/mod stack converters
+ */
+public class REIStackConverter {
+
+    public static final Map<Class<?>, Converter<?>> CONVERTERS = new Reference2ReferenceOpenHashMap<>();
+
+    public static final Converter<ItemStack> ITEM = register(ItemStack.class, new Converter<>() {
+
+        @Override
+        public @Nullable ItemStack convertFrom(EntryStack<?> stack) {
+            EntryType<?> type = stack.getType();
+            if (type != VanillaEntryTypes.ITEM) {
+                return null;
+            }
+            return stack.castValue();
+        }
+
+        private static EntryIngredient toREIIngredient(Stream<ItemStack> stream) {
+            return EntryIngredient.of(stream
+                    .map(EntryStacks::of)
+                    .toList());
+        }
+
+        @Override
+        public @NotNull EntryIngredient convertTo(EntryList<ItemStack> stack, float chance,
+                                                  UnaryOperator<ItemStack> mapper) {
+            if (stack == null || stack.isEmpty()) {
+                return EntryIngredient.empty();
+            }
+            if (stack instanceof ItemStackList stackList) {
+                return toREIIngredient(stackList.stream().map(mapper));
+            } else if (stack instanceof ItemTagList entryList) {
+                return EntryIngredient.of(entryList.getEntries().stream()
+                        .map(ItemTagList.ItemTagEntry::stacks)
+                        .flatMap(stream -> toREIIngredient(stream.map(mapper)).stream())
+                        .collect(Collectors.toList()));
+            }
+            return EntryIngredient.empty();
+        }
+    });
+    public static final Converter<FluidStack> FLUID = register(FluidStack.class, new Converter<>() {
+
+        @Override
+        public @Nullable FluidStack convertFrom(EntryStack<?> stack) {
+            EntryType<?> type = stack.getType();
+            if (type != VanillaEntryTypes.FLUID) {
+                return null;
+            }
+            dev.architectury.fluid.FluidStack fluidStack = stack.castValue();
+            return new FluidStack(fluidStack.getFluid(), GTMath.saturatedCast(fluidStack.getAmount()),
+                    fluidStack.getTag());
+        }
+
+        private static dev.architectury.fluid.FluidStack toREIStack(FluidStack stack) {
+            return dev.architectury.fluid.FluidStack.create(stack.getFluid(), stack.getAmount(), stack.getTag());
+        }
+
+        private static EntryIngredient toREIIngredient(Stream<FluidStack> stream) {
+            return EntryIngredient.of(stream
+                    .map(stack -> toREIStack(stack))
+                    .map(EntryStacks::of)
+                    .toList());
+        }
+
+        @Override
+        public @NotNull EntryIngredient convertTo(EntryList<FluidStack> stack, float chance,
+                                                  UnaryOperator<FluidStack> mapper) {
+            if (stack == null || stack.isEmpty()) {
+                return EntryIngredient.empty();
+            }
+            if (stack instanceof FluidStackList stackList) {
+                return toREIIngredient(stackList.stream().map(mapper));
+            } else if (stack instanceof FluidTagList tagList) {
+                return EntryIngredient.of(tagList.getEntries().stream()
+                        .map(FluidTagList.FluidTagEntry::stacks)
+                        .flatMap(val -> toREIIngredient(val.map(mapper)).stream())
+                        .collect(Collectors.toList()));
+            }
+            return EntryIngredient.empty();
+        }
+    });
+
+    public static <T> Converter<T> register(Class<T> clazz, Converter<T> converter) {
+        CONVERTERS.put(clazz, converter);
+        return converter;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Nullable
+    public static <T> Converter<T> getForNullable(Class<T> clazz) {
+        return (Converter<T>) CONVERTERS.get(clazz);
+    }
+
+    @NotNull
+    public static <T> Optional<Converter<T>> getFor(Class<T> clazz) {
+        return Optional.ofNullable(getForNullable(clazz));
+    }
+
+    public interface Converter<T> {
+
+        @Nullable
+        T convertFrom(EntryStack<?> stack);
+
+        @NotNull
+        EntryIngredient convertTo(EntryList<T> stack, float chance, UnaryOperator<T> mapper);
+
+        @NotNull
+        default EntryIngredient convertTo(IngredientProvider<T> slot) {
+            return this.convertTo(slot.getIngredients(), slot.chance(), slot.renderMappingFunction());
+        }
+    }
+}
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/EqualityTest.java b/src/main/java/com/gregtechceu/gtceu/utils/EqualityTest.java
new file mode 100644
index 00000000000..040d00eaf10
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/EqualityTest.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.utils;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * A custom function that tests objects for equality.
+ *
+ * @param <T> object type
+ */
+public interface EqualityTest<T> {
+
+    /**
+     * Tests two objects for equality. Parameters are not null.
+     *
+     * @param t1 first object
+     * @param t2 second object
+     * @return true if objects are equal
+     */
+    boolean areEqual(@NotNull T t1, @NotNull T t2);
+
+    /**
+     * Wraps a {@link EqualityTest} function to accept nullable parameters.
+     *
+     * @param equals equals function
+     * @param <T>    object type
+     * @return null safe equals function
+     */
+    @SuppressWarnings("ConstantValue")
+    static <T> EqualityTest<T> wrapNullSafe(EqualityTest<T> equals) {
+        return (t1, t2) -> {
+            if (t1 == null || t2 == null) return t1 == t2;
+            return equals.areEqual(t1, t2);
+        };
+    }
+
+    static <T> EqualityTest<T> defaultTester() {
+        return Objects::equals;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/FloatConsumer.java b/src/main/java/com/gregtechceu/gtceu/utils/FloatConsumer.java
new file mode 100644
index 00000000000..d499dd77561
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/FloatConsumer.java
@@ -0,0 +1,13 @@
+package com.gregtechceu.gtceu.utils;
+
+import java.util.function.DoubleConsumer;
+
+@FunctionalInterface
+public interface FloatConsumer extends DoubleConsumer {
+
+    void accept(float value);
+
+    default void accept(double value) {
+        accept((float) value);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/FloatSupplier.java b/src/main/java/com/gregtechceu/gtceu/utils/FloatSupplier.java
new file mode 100644
index 00000000000..692e442ba92
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/FloatSupplier.java
@@ -0,0 +1,14 @@
+package com.gregtechceu.gtceu.utils;
+
+import java.util.function.DoubleSupplier;
+
+@FunctionalInterface
+public interface FloatSupplier extends DoubleSupplier {
+
+    float getAsFloat();
+
+    @Override
+    default double getAsDouble() {
+        return getAsFloat();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/FormattingUtil.java b/src/main/java/com/gregtechceu/gtceu/utils/FormattingUtil.java
index 493f7798fb9..eef8d94e753 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;
 
@@ -102,15 +101,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..7462aac69f7 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,35 @@ 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 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 +192,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 +220,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 +266,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..b8d2aa2b903 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/GTStringUtils.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/GTStringUtils.java
@@ -15,6 +15,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 public class GTStringUtils {
@@ -57,82 +58,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 +147,26 @@ 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));
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java b/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java
index 04a9f1fefae..d0b3b6b4940 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java
@@ -41,6 +41,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 +58,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;
@@ -694,4 +698,46 @@ 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);
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/ICopy.java b/src/main/java/com/gregtechceu/gtceu/utils/ICopy.java
new file mode 100644
index 00000000000..c94c3303e6b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/ICopy.java
@@ -0,0 +1,34 @@
+package com.gregtechceu.gtceu.utils;
+
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufAdapter;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufDeserializer;
+import com.gregtechceu.gtceu.utils.serialization.network.IByteBufSerializer;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import io.netty.buffer.Unpooled;
+
+public interface ICopy<T> {
+
+    static <T> ICopy<T> immutable() {
+        return t -> t;
+    }
+
+    static <T> ICopy<T> ofSerializer(IByteBufSerializer<T> serializer, IByteBufDeserializer<T> deserializer) {
+        return t -> {
+            FriendlyByteBuf buf = new FriendlyByteBuf(Unpooled.buffer());
+            serializer.serialize(buf, t);
+            return deserializer.deserialize(buf);
+        };
+    }
+
+    static <T> ICopy<T> ofSerializer(IByteBufAdapter<T> adapter) {
+        return ofSerializer(adapter, adapter);
+    }
+
+    T createDeepCopy(T t);
+
+    static <T> ICopy<T> wrapNullSafe(ICopy<T> copy) {
+        return t -> t == null ? null : copy.createDeepCopy(t);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/IMultiFluidTankHandler.java b/src/main/java/com/gregtechceu/gtceu/utils/IMultiFluidTankHandler.java
new file mode 100644
index 00000000000..eff979b6edb
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/IMultiFluidTankHandler.java
@@ -0,0 +1,9 @@
+package com.gregtechceu.gtceu.utils;
+
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+
+public interface IMultiFluidTankHandler extends IFluidHandler {
+
+    IFluidTank getFluidTank(int index);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/MultiFluidTankHandler.java b/src/main/java/com/gregtechceu/gtceu/utils/MultiFluidTankHandler.java
new file mode 100644
index 00000000000..a1239ceb94a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/MultiFluidTankHandler.java
@@ -0,0 +1,3 @@
+package com.gregtechceu.gtceu.utils;
+
+public class MultiFluidTankHandler {}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/NetworkUtils.java b/src/main/java/com/gregtechceu/gtceu/utils/NetworkUtils.java
new file mode 100644
index 00000000000..32acec14f17
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/NetworkUtils.java
@@ -0,0 +1,93 @@
+package com.gregtechceu.gtceu.utils;
+
+import com.gregtechceu.gtceu.GTCEu;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.jetbrains.annotations.Nullable;
+
+import java.nio.charset.StandardCharsets;
+import java.util.function.Consumer;
+
+public class NetworkUtils {
+
+    public static final Consumer<FriendlyByteBuf> EMPTY_PACKET = buffer -> {};
+
+    public static boolean isClient(Player player) {
+        if (player == null) return GTCEu.isClientThread();
+        return player.level().isClientSide;
+    }
+
+    public static void writeByteBuf(FriendlyByteBuf writeTo, ByteBuf writeFrom) {
+        writeTo.writeVarInt(writeFrom.readableBytes());
+        writeTo.writeBytes(writeFrom.slice());
+    }
+
+    public static ByteBuf readByteBuf(FriendlyByteBuf buf) {
+        ByteBuf directSliceBuffer = buf.readBytes(buf.readVarInt());
+        return Unpooled.copiedBuffer(directSliceBuffer);
+    }
+
+    public static FriendlyByteBuf readFriendlyByteBuf(FriendlyByteBuf buf) {
+        return new FriendlyByteBuf(readByteBuf(buf));
+    }
+
+    public static void writeStringSafe(FriendlyByteBuf buffer, String string) {
+        writeStringSafe(buffer, string, Short.MAX_VALUE, false);
+    }
+
+    public static void writeStringSafe(FriendlyByteBuf buffer, @Nullable String string, boolean crash) {
+        writeStringSafe(buffer, string, Short.MAX_VALUE, crash);
+    }
+
+    public static void writeStringSafe(FriendlyByteBuf buffer, @Nullable String string, int maxBytes) {
+        writeStringSafe(buffer, string, maxBytes, false);
+    }
+
+    private static final int MAX_ENCODED = getMaxEncodedUtfLength(Short.MAX_VALUE);
+
+    public static void writeStringSafe(FriendlyByteBuf buffer, @Nullable String string, int maxBytes, boolean crash) {
+        if (string == null) {
+            buffer.writeVarInt(MAX_ENCODED + 1);
+            return;
+        }
+        if (string.isEmpty()) {
+            buffer.writeVarInt(0);
+            return;
+        }
+        maxBytes = Math.min(maxBytes, Short.MAX_VALUE);
+        byte[] bytesTest = string.getBytes(StandardCharsets.UTF_8);
+        byte[] bytes;
+
+        int maxEncoded = getMaxEncodedUtfLength(maxBytes);
+        if (bytesTest.length > maxEncoded) {
+            if (crash) {
+                throw new IllegalArgumentException("Max String size is " + maxEncoded + ", but found " +
+                        bytesTest.length + " bytes for '" + string + "'!");
+            }
+            bytes = new byte[maxEncoded];
+            System.arraycopy(bytesTest, 0, bytes, 0, maxEncoded);
+            GTCEu.LOGGER.warn("Warning! Synced string exceeds max length!");
+        } else {
+            bytes = bytesTest;
+        }
+        buffer.writeVarInt(bytes.length);
+        buffer.writeBytes(bytes);
+    }
+
+    public static String readStringSafe(FriendlyByteBuf buffer) {
+        int length = buffer.readVarInt();
+        if (length > MAX_ENCODED) return null;
+        if (length == 0) return "";
+        String s = buffer.toString(buffer.readerIndex(), length, StandardCharsets.UTF_8);
+        buffer.readerIndex(buffer.readerIndex() + length);
+        return s;
+    }
+
+    private static int getMaxEncodedUtfLength(int maxLength) {
+        return maxLength * 3;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/ReverseIterable.java b/src/main/java/com/gregtechceu/gtceu/utils/ReverseIterable.java
new file mode 100644
index 00000000000..edb9881d7da
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/ReverseIterable.java
@@ -0,0 +1,73 @@
+package com.gregtechceu.gtceu.utils;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+/**
+ * An iterable to iterate in reverse order over a list.
+ * Shorter than using the list iterator of the list.
+ */
+public class ReverseIterable<T> implements Iterable<T> {
+
+    private final List<T> list;
+
+    public ReverseIterable(List<T> list) {
+        this.list = list;
+    }
+
+    @NotNull
+    @Override
+    public Iterator<T> iterator() {
+        ListIterator<T> iterator = this.list.listIterator(this.list.size());
+        return new ListIterator<>() {
+
+            @Override
+            public boolean hasNext() {
+                return iterator.hasPrevious();
+            }
+
+            @Override
+            public T next() {
+                return iterator.previous();
+            }
+
+            @Override
+            public boolean hasPrevious() {
+                return iterator.hasNext();
+            }
+
+            @Override
+            public T previous() {
+                return iterator.next();
+            }
+
+            @Override
+            public int nextIndex() {
+                return iterator.previousIndex();
+            }
+
+            @Override
+            public int previousIndex() {
+                return iterator.nextIndex();
+            }
+
+            @Override
+            public void remove() {
+                iterator.remove();
+            }
+
+            @Override
+            public void set(T t) {
+                iterator.set(t);
+            }
+
+            @Override
+            public void add(T t) {
+                iterator.add(t);
+            }
+        };
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/ReversedList.java b/src/main/java/com/gregtechceu/gtceu/utils/ReversedList.java
new file mode 100644
index 00000000000..f9267881b5f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/ReversedList.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.utils;
+
+import java.util.AbstractList;
+import java.util.Collection;
+import java.util.List;
+
+public class ReversedList<T> extends AbstractList<T> {
+
+    private final List<T> delegate;
+
+    public ReversedList(List<T> delegate) {
+        this.delegate = delegate;
+    }
+
+    public int inverseIndex(int i) {
+        return size() - 1 - i;
+    }
+
+    @Override
+    public T get(int index) {
+        return this.delegate.get(inverseIndex(index));
+    }
+
+    @Override
+    public int size() {
+        return this.delegate.size();
+    }
+
+    @Override
+    public T set(int index, T element) {
+        return this.delegate.set(inverseIndex(index), element);
+    }
+
+    @Override
+    public T remove(int index) {
+        return this.delegate.remove(inverseIndex(index));
+    }
+
+    @Override
+    public void add(int index, T element) {
+        this.delegate.add(inverseIndex(index), element);
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends T> c) {
+        return this.delegate.addAll(inverseIndex(index), c);
+    }
+}
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/VectorUtil.java b/src/main/java/com/gregtechceu/gtceu/utils/VectorUtil.java
new file mode 100644
index 00000000000..656a0869023
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/VectorUtil.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.utils;
+
+import net.minecraft.core.Vec3i;
+import net.minecraft.world.phys.Vec3;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
+
+public class VectorUtil {
+
+    public static Vector3f set(@Nullable Vector3f target, float x, float y, float z) {
+        if (target == null) target = new Vector3f();
+        return target.set(x, y, z);
+    }
+
+    @NotNull
+    public static Vector3f set(@Nullable Vector3f target, Vec3 vec) {
+        return set(target, (float) vec.x, (float) vec.y, (float) vec.z);
+    }
+
+    @NotNull
+    public static Vector3f set(@Nullable Vector3f target, Vec3i vec) {
+        return set(target, vec.getX(), vec.getY(), vec.getZ());
+    }
+
+    public static Vector3f vec3f(Vec3 Vec3) {
+        return set(null, Vec3);
+    }
+
+    public static Vector3f vec3f(Vec3i vec3i) {
+        return set(null, vec3i);
+    }
+
+    public static Vector3f vec3fAdd(@Nullable Vector3f source, @Nullable Vector3f target, float x, float y, float z) {
+        if (target == null) target = new Vector3f();
+        if (source == null) return set(target, x, y, z);
+        if (target != source) target.set(source);
+        return target.add(x, y, z);
+    }
+
+    @NotNull
+    public static Vector3f vec3fAdd(@Nullable Vector3f source, @Nullable Vector3f target, Vec3i vec) {
+        return vec3fAdd(source, target, vec.getX(), vec.getY(), vec.getZ());
+    }
+
+    @NotNull
+    public static Vector3f vec3fAdd(@Nullable Vector3f source, @Nullable Vector3f target, Vec3 vec) {
+        return vec3fAdd(source, target, (float) vec.x, (float) vec.y, (float) vec.z);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/codec/DispatchedMapCodec.java b/src/main/java/com/gregtechceu/gtceu/utils/codec/DispatchedMapCodec.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/api/codec/DispatchedMapCodec.java
rename to src/main/java/com/gregtechceu/gtceu/utils/codec/DispatchedMapCodec.java
index 7d8abeda932..cc65a071539 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/codec/DispatchedMapCodec.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/codec/DispatchedMapCodec.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.api.codec;
+package com.gregtechceu.gtceu.utils.codec;
 
 import com.gregtechceu.gtceu.GTCEu;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/codec/GTCodecUtils.java b/src/main/java/com/gregtechceu/gtceu/utils/codec/GTCodecUtils.java
similarity index 98%
rename from src/main/java/com/gregtechceu/gtceu/api/codec/GTCodecUtils.java
rename to src/main/java/com/gregtechceu/gtceu/utils/codec/GTCodecUtils.java
index 36577fdd3bc..b5c488489bf 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/codec/GTCodecUtils.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/codec/GTCodecUtils.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.api.codec;
+package com.gregtechceu.gtceu.utils.codec;
 
 import com.gregtechceu.gtceu.utils.memoization.GTMemoizer;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/DummyChunk.java b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/DummyChunk.java
new file mode 100644
index 00000000000..94c8a1bb3ab
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/DummyChunk.java
@@ -0,0 +1,37 @@
+package com.gregtechceu.gtceu.utils.fakelevel;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.FullChunkStatus;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class DummyChunk extends LevelChunk {
+
+    public DummyChunk(SchemaLevel level, ChunkPos pos) {
+        super(level, pos);
+    }
+
+    private SchemaLevel getGuidebookLevel() {
+        return (SchemaLevel) getLevel();
+    }
+
+    public @Nullable BlockState setBlockState(@NotNull BlockPos pos, @NotNull BlockState state, boolean isMoving) {
+        getGuidebookLevel().prepareLighting(pos);
+
+        var result = super.setBlockState(pos, state, isMoving);
+        if (!state.isAir()) {
+            getGuidebookLevel().addFilledBlock(pos);
+        } else {
+            getGuidebookLevel().removeFilledBlock(pos);
+        }
+        return result;
+    }
+
+    public @NotNull FullChunkStatus getFullStatus() {
+        return FullChunkStatus.FULL;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/DummyChunkSource.java b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/DummyChunkSource.java
new file mode 100644
index 00000000000..7f992a8d675
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/DummyChunkSource.java
@@ -0,0 +1,57 @@
+package com.gregtechceu.gtceu.utils.fakelevel;
+
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkSource;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BooleanSupplier;
+
+public class DummyChunkSource extends ChunkSource {
+
+    @Getter
+    private final SchemaLevel level;
+    private final Long2ObjectMap<DummyChunk> chunks = new Long2ObjectOpenHashMap<>();
+    @Getter
+    private final LevelLightEngine lightEngine;
+
+    public DummyChunkSource(SchemaLevel level) {
+        this.level = level;
+        this.lightEngine = new LevelLightEngine(this, true, true);
+    }
+
+    @Override
+    public @Nullable ChunkAccess getChunk(int chunkX, int chunkZ, @NotNull ChunkStatus requiredStatus, boolean load) {
+        ChunkPos pos = new ChunkPos(chunkX, chunkZ);
+        return chunks.computeIfAbsent(pos.toLong(), posLong1 -> {
+            DummyChunk newChunk = new DummyChunk(level, pos);
+            newChunk.setLoaded(true);
+            return newChunk;
+        });
+    }
+
+    @Override
+    public boolean hasChunk(int chunkX, int chunkZ) {
+        return true;
+    }
+
+    @Override
+    public void tick(@NotNull BooleanSupplier hasTimeLeft, boolean tickChunks) {}
+
+    @Override
+    public @NotNull String gatherStats() {
+        return "Dummy";
+    }
+
+    @Override
+    public int getLoadedChunksCount() {
+        return chunks.size();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/MapSchema.java b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/MapSchema.java
new file mode 100644
index 00000000000..5932cab9128
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/MapSchema.java
@@ -0,0 +1,165 @@
+package com.gregtechceu.gtceu.utils.fakelevel;
+
+import com.gregtechceu.gtceu.api.mui.schema.ISchema;
+import com.gregtechceu.gtceu.utils.BlockPosUtil;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+
+import com.google.common.collect.AbstractIterator;
+import it.unimi.dsi.fastutil.longs.Long2ReferenceMap;
+import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectIterator;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+
+public class MapSchema implements ISchema {
+
+    @Getter
+    private final Level level;
+    private final Long2ReferenceOpenHashMap<BlockState> blocks = new Long2ReferenceOpenHashMap<>();
+    @Getter
+    @Setter
+    private BiPredicate<BlockPos, BlockState> renderFilter = (pos, state) -> true;
+    // this isn't final because of constructor semantics but should be used as if it is
+    @Getter
+    private BlockPos origin;
+    // this isn't final because of constructor semantics but should be used as if it is
+    private Vector3f center;
+
+    public MapSchema(Map<BlockPos, BlockState> blocks) {
+        this(blocks, null);
+    }
+
+    // awful. oh well
+    public MapSchema(Map<BlockPos, BlockState> blocks, BiPredicate<BlockPos, BlockState> renderFilter) {
+        this(renderFilter);
+
+        BlockPos.MutableBlockPos min = BlockPosUtil.MAX.mutable();
+        BlockPos.MutableBlockPos max = BlockPosUtil.MIN.mutable();
+        if (!blocks.isEmpty()) {
+            for (var entry : blocks.entrySet()) {
+                if (!entry.getValue().isAir()) {
+                    BlockPos pos = entry.getKey();
+                    this.blocks.put(pos.asLong(), entry.getValue());
+                    this.level.setBlockAndUpdate(pos, entry.getValue());
+                    BlockPosUtil.setMin(min, pos);
+                    BlockPosUtil.setMax(max, pos);
+                }
+            }
+        } else {
+            min.set(0, 0, 0);
+            max.set(0, 0, 0);
+        }
+        this.origin = min.immutable();
+        this.center = BlockPosUtil.getCenterF(min, max);
+    }
+
+    public MapSchema(Long2ReferenceMap<BlockState> blocks) {
+        this(blocks, null);
+    }
+
+    public MapSchema(Long2ReferenceMap<BlockState> blocks, BiPredicate<BlockPos, BlockState> renderFilter) {
+        this(renderFilter);
+
+        BlockPos.MutableBlockPos min = BlockPosUtil.MAX.mutable();
+        BlockPos.MutableBlockPos max = BlockPosUtil.MIN.mutable();
+        if (!blocks.isEmpty()) {
+            for (var entry : blocks.long2ReferenceEntrySet()) {
+                if (!entry.getValue().isAir()) {
+                    BlockPos pos = BlockPos.of(entry.getLongKey());
+
+                    this.blocks.put(entry.getLongKey(), entry.getValue());
+                    this.level.setBlockAndUpdate(pos, entry.getValue());
+                    BlockPosUtil.setMin(min, pos);
+                    BlockPosUtil.setMax(max, pos);
+                }
+            }
+        } else {
+            min.set(0, 0, 0);
+            max.set(0, 0, 0);
+        }
+        this.origin = min.immutable();
+        this.center = BlockPosUtil.getCenterF(min, max);
+    }
+
+    protected MapSchema(BiPredicate<BlockPos, BlockState> renderFilter) {
+        this.level = new SchemaLevel();
+        if (renderFilter != null) {
+            this.renderFilter = renderFilter;
+        }
+    }
+
+    @Override
+    public Vector3fc getFocus() {
+        return center;
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Map.Entry<BlockPos, BlockState>> iterator() {
+        return new AbstractIterator<>() {
+
+            private final ObjectIterator<Long2ReferenceMap.Entry<BlockState>> it = blocks
+                    .long2ReferenceEntrySet().fastIterator();
+
+            @Override
+            protected Map.Entry<BlockPos, BlockState> computeNext() {
+                while (true) {
+                    if (it.hasNext()) {
+                        Long2ReferenceMap.Entry<BlockState> entry = it.next();
+                        BlockPos key = BlockPos.of(entry.getLongKey());
+                        if (renderFilter.test(key, entry.getValue())) {
+                            return Map.entry(key, entry.getValue());
+                        }
+                        continue;
+                    }
+                    return endOfData();
+                }
+            }
+        };
+    }
+
+    @Accessors(chain = true)
+    public static class Builder {
+
+        private final Long2ReferenceMap<BlockState> blocks = new Long2ReferenceOpenHashMap<>();
+        @Setter
+        private BiPredicate<BlockPos, BlockState> renderFilter;
+
+        public Builder add(BlockPos pos, BlockState state) {
+            if (state.isAir()) return this;
+            this.blocks.put(pos.asLong(), state);
+            return this;
+        }
+
+        public Builder add(Iterable<BlockPos> posList, Function<BlockPos, BlockState> function) {
+            for (BlockPos pos : posList) {
+                add(pos, function.apply(pos));
+            }
+            return this;
+        }
+
+        public Builder add(Map<BlockPos, BlockState> blocks) {
+            blocks.forEach((pos, state) -> this.blocks.put(pos.asLong(), state));
+            return this;
+        }
+
+        public MapSchema build() {
+            if (renderFilter == null) {
+                return new MapSchema(this.blocks);
+            }
+            return new MapSchema(this.blocks, renderFilter);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/SchemaLevel.java b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/SchemaLevel.java
new file mode 100644
index 00000000000..0aa91e5a8f7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/fakelevel/SchemaLevel.java
@@ -0,0 +1,345 @@
+package com.gregtechceu.gtceu.utils.fakelevel;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.schema.ISchema;
+import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.utils.BlockPosUtil;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.core.*;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.util.profiling.InactiveProfiler;
+import net.minecraft.world.Difficulty;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.flag.FeatureFlagSet;
+import net.minecraft.world.flag.FeatureFlags;
+import net.minecraft.world.item.crafting.RecipeManager;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.Biomes;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkSource;
+import net.minecraft.world.level.chunk.DataLayer;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
+import net.minecraft.world.level.entity.LevelCallback;
+import net.minecraft.world.level.entity.LevelEntityGetter;
+import net.minecraft.world.level.entity.TransientEntitySectionManager;
+import net.minecraft.world.level.gameevent.GameEvent;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.lighting.LightEngine;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.level.saveddata.maps.MapItemSavedData;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.scores.Scoreboard;
+import net.minecraft.world.ticks.BlackholeTickAccess;
+import net.minecraft.world.ticks.LevelTickAccess;
+
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3fc;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiPredicate;
+import java.util.stream.Stream;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class SchemaLevel extends Level implements ISchema {
+
+    private static final ResourceKey<Level> LEVEL_ID = ResourceKey.create(Registries.DIMENSION,
+            GTCEu.id("fake_level"));
+
+    private final TransientEntitySectionManager<Entity> entityStorage = new TransientEntitySectionManager<>(
+            Entity.class, new EntityCallbacks());
+
+    private final LongSet filledBlocks = new LongOpenHashSet();
+    @Getter
+    @Setter
+    private BiPredicate<BlockPos, BlockState> renderFilter = (pos, state) -> true;
+    /**
+     * Sections for which we prepared lighting.
+     */
+    private final LongSet litSections = new LongOpenHashSet();
+    private final BlockPos.MutableBlockPos min = new BlockPos.MutableBlockPos();
+    private final BlockPos.MutableBlockPos max = new BlockPos.MutableBlockPos();
+
+    @Getter
+    private final Scoreboard scoreboard = new Scoreboard();
+    @Getter
+    private final ChunkSource chunkSource = new DummyChunkSource(this);
+    private final Holder<Biome> biome;
+    private final DataLayer defaultDataLayer;
+
+    public static final SchemaLevel INSTANCE = new SchemaLevel();
+
+    public SchemaLevel() {
+        this(GTRegistries.builtinRegistry());
+    }
+
+    public SchemaLevel(RegistryAccess registryAccess) {
+        super(
+                createLevelData(),
+                LEVEL_ID,
+                registryAccess,
+                registryAccess.registryOrThrow(Registries.DIMENSION_TYPE)
+                        .getHolderOrThrow(BuiltinDimensionTypes.OVERWORLD),
+                () -> InactiveProfiler.INSTANCE,
+                true,
+                false,
+                0,
+                1000000);
+        this.biome = registryAccess.registryOrThrow(Registries.BIOME).getHolderOrThrow(Biomes.PLAINS);
+
+        // the argument named "size" is actually the default value.
+        // We want all blocks to have max light, so we create a pre-filled light data layer
+        defaultDataLayer = new DataLayer(LightEngine.MAX_LEVEL);
+    }
+
+    private static ClientLevel.ClientLevelData createLevelData() {
+        var levelData = new ClientLevel.ClientLevelData(Difficulty.NORMAL, false, false);
+        // set time of day to noon (from TimeCommand noon)
+        levelData.setDayTime(6000);
+        return levelData;
+    }
+
+    /**
+     * Ensures lighting is set to skylight level 15 in the entire chunk and adjacent chunks whenever a block is first
+     * changed in that chunk.
+     */
+    protected void prepareLighting(BlockPos pos) {
+        ChunkPos minChunk = new ChunkPos(pos.offset(-1, -1, -1));
+        ChunkPos maxChunk = new ChunkPos(pos.offset(1, 1, 1));
+        ChunkPos.rangeClosed(minChunk, maxChunk).forEach(chunkPos -> {
+            if (litSections.add(chunkPos.toLong())) {
+                LevelLightEngine lightEngine = getLightEngine();
+                for (int i = 0; i < getSectionsCount(); ++i) {
+                    int y = getSectionYFromSectionIndex(i);
+                    SectionPos sectionPos = SectionPos.of(chunkPos, y);
+                    lightEngine.updateSectionStatus(sectionPos, false);
+                    lightEngine.queueSectionData(LightLayer.BLOCK, sectionPos, defaultDataLayer);
+                    lightEngine.queueSectionData(LightLayer.SKY, sectionPos, defaultDataLayer);
+                }
+
+                lightEngine.setLightEnabled(chunkPos, true);
+                lightEngine.propagateLightSources(chunkPos);
+                lightEngine.retainData(chunkPos, false);
+            }
+        });
+    }
+
+    public boolean hasFilledBlocks() {
+        return !filledBlocks.isEmpty();
+    }
+
+    public boolean isFilledBlock(BlockPos blockPos) {
+        return filledBlocks.contains(blockPos.asLong());
+    }
+
+    /**
+     * Do NOT store/cache the returned stream's elements for later! They're all a <strong>single</strong>
+     * {@link BlockPos.MutableBlockPos MutableBlockPos} instance that WILL change every iteration.
+     * 
+     * @return stream of all non-air blocks in this {@link SchemaLevel} instance
+     */
+    public Stream<BlockPos> getFilledBlocks() {
+        var mutablePos = new BlockPos.MutableBlockPos();
+        return filledBlocks.longStream()
+                .sequential()
+                .mapToObj(pos -> {
+                    mutablePos.set(pos);
+                    return mutablePos;
+                });
+    }
+
+    @Override
+    public @NotNull Iterator<Map.Entry<BlockPos, BlockState>> iterator() {
+        return getFilledBlocks()
+                .map(pos -> Map.entry(pos, this.getBlockState(pos)))
+                .iterator();
+    }
+
+    protected void removeFilledBlock(BlockPos pos) {
+        filledBlocks.remove(pos.asLong());
+    }
+
+    protected void addFilledBlock(BlockPos pos) {
+        filledBlocks.add(pos.asLong());
+    }
+
+    @Override
+    public Level getLevel() {
+        return this;
+    }
+
+    @Override
+    public Vector3fc getFocus() {
+        return BlockPosUtil.getCenterF(this.min, this.max);
+    }
+
+    @Override
+    public BlockPos getOrigin() {
+        return min;
+    }
+
+    @Override
+    public boolean isLoaded(BlockPos pos) {
+        int chunkX = SectionPos.blockToSectionCoord(pos.getX());
+        int chunkZ = SectionPos.blockToSectionCoord(pos.getZ());
+        return chunkSource.hasChunk(chunkX, chunkZ);
+    }
+
+    @Override
+    public @Nullable Entity getEntity(int id) {
+        return getEntities().get(id);
+    }
+
+    @Override
+    protected LevelEntityGetter<Entity> getEntities() {
+        return entityStorage.getEntityGetter();
+    }
+
+    @Override
+    public void playSeededSound(@Nullable Player player, double x, double y, double z, Holder<SoundEvent> sound,
+                                SoundSource source, float volume, float pitch, long seed) {}
+
+    @Override
+    public void playSeededSound(@Nullable Player player, Entity entity, Holder<SoundEvent> sound, SoundSource category,
+                                float volume, float pitch, long seed) {}
+
+    @Override
+    public void sendBlockUpdated(BlockPos pos, BlockState oldState, BlockState newState, int flags) {}
+
+    @Override
+    public void updateNeighborsAt(BlockPos pos, Block block) {}
+
+    @Override
+    public void updateNeighbourForOutputSignal(BlockPos pos, Block block) {}
+
+    @Override
+    public void markAndNotifyBlock(BlockPos pos, @Nullable LevelChunk chunk, BlockState setState,
+                                   BlockState newState, int flags, int recursionLeft) {}
+
+    @Override
+    public String gatherChunkSourceStats() {
+        return "";
+    }
+
+    @Override
+    public @Nullable MapItemSavedData getMapData(String mapName) {
+        return null;
+    }
+
+    @Override
+    public void setMapData(String mapName, MapItemSavedData data) {}
+
+    @Override
+    public int getFreeMapId() {
+        return 0;
+    }
+
+    @Override
+    public void destroyBlockProgress(int breakerId, BlockPos pos, int progress) {}
+
+    @Override
+    public RecipeManager getRecipeManager() {
+        if (GTCEu.isClientThread()) {
+            return ClientCallWrapper.getClientRecipeManager();
+        } else {
+            return GTCEu.getMinecraftServer().getRecipeManager();
+        }
+    }
+
+    @Override
+    public LevelTickAccess<Block> getBlockTicks() {
+        return BlackholeTickAccess.emptyLevelList();
+    }
+
+    @Override
+    public LevelTickAccess<Fluid> getFluidTicks() {
+        return BlackholeTickAccess.emptyLevelList();
+    }
+
+    @Override
+    public void levelEvent(@Nullable Player player, int type, BlockPos pos, int data) {}
+
+    @Override
+    public void gameEvent(GameEvent event, Vec3 position, GameEvent.Context context) {}
+
+    @Override
+    public float getShade(@NotNull Direction direction, boolean shade) {
+        if (!shade) {
+            return 1.0f;
+        } else {
+            return switch (direction) {
+                case DOWN -> 0.5f;
+                case UP -> 1.0f;
+                case NORTH, SOUTH -> 0.8f;
+                case WEST, EAST -> 0.6f;
+            };
+        }
+    }
+
+    @Override
+    public List<? extends Player> players() {
+        return List.of();
+    }
+
+    @Override
+    public Holder<Biome> getUncachedNoiseBiome(int x, int y, int z) {
+        return biome;
+    }
+
+    @Override
+    public FeatureFlagSet enabledFeatures() {
+        return FeatureFlags.VANILLA_SET;
+    }
+
+    private static class ClientCallWrapper {
+
+        private static RecipeManager getClientRecipeManager() {
+            return Minecraft.getInstance().level.getRecipeManager();
+        }
+    }
+
+    private static class EntityCallbacks implements LevelCallback<Entity> {
+
+        @Override
+        public void onCreated(Entity entity) {}
+
+        @Override
+        public void onDestroyed(Entity entity) {}
+
+        @Override
+        public void onTickingStart(Entity entity) {}
+
+        @Override
+        public void onTickingEnd(Entity entity) {}
+
+        @Override
+        public void onTrackingStart(Entity entity) {}
+
+        @Override
+        public void onTrackingEnd(Entity entity) {}
+
+        @Override
+        public void onSectionChange(Entity object) {}
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/math/NumberFormat.java b/src/main/java/com/gregtechceu/gtceu/utils/math/NumberFormat.java
new file mode 100644
index 00000000000..61f356dff9b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/math/NumberFormat.java
@@ -0,0 +1,332 @@
+package com.gregtechceu.gtceu.utils.math;
+
+import com.gregtechceu.gtceu.utils.GTMath;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+
+/**
+ * A number formatter for large, small, positive, negative, integers and decimals with adjustable format parameters.
+ * Test results can be seen at test/java/com.cleanroommc.modularui.FormatTest.
+ */
+public class NumberFormat {
+
+    public static final BigDecimal TEN_THOUSAND = new BigDecimal(10_000);
+
+    public static final Params DEFAULT = paramsBuilder()
+            .roundingMode(RoundingMode.HALF_UP)
+            .maxLength(4)
+            .considerMinusForLength(false)
+            .considerDecimalSeparatorForLength(false)
+            .considerOnlyDecimalsForLength(false)
+            .considerSuffixForLength(true)
+            .spaceAfterNumber(false)
+            .build();
+
+    public static final Params DECIMALS_3 = DEFAULT.copyToBuilder()
+            .considerSuffixForLength(false)
+            .considerOnlyDecimalsForLength(true)
+            .maxLength(3)
+            .build();
+
+    public static final Params AMOUNT_TEXT = DEFAULT.copyToBuilder()
+            .roundingMode(RoundingMode.DOWN)
+            .build();
+
+    public static Params params(DecimalFormat format, int maxLength, boolean considerOnlyDecimalsForLength,
+                                boolean considerDecimalSeparatorForLength, boolean considerMinusForLength,
+                                boolean considerSuffixForLength,
+                                boolean spaceAfterNumber) {
+        return new Params(format, maxLength, considerOnlyDecimalsForLength, considerDecimalSeparatorForLength,
+                considerMinusForLength, considerSuffixForLength, spaceAfterNumber);
+    }
+
+    public static ParamsBuilder paramsBuilder() {
+        return new ParamsBuilder();
+    }
+
+    public static class Params {
+
+        public final DecimalFormat format;
+        public final int maxLength;
+        public final boolean considerOnlyDecimalsForLength;
+        public final boolean considerDecimalSeparatorForLength;
+        public final boolean considerMinusForLength;
+        public final boolean considerSuffixForLength;
+        public final boolean spaceAfterNumber;
+
+        public Params(DecimalFormat format, int maxLength, boolean considerOnlyDecimalsForLength,
+                      boolean considerDecimalSeparatorForLength,
+                      boolean considerMinusForLength, boolean considerSuffixForLength, boolean spaceAfterNumber) {
+            this.format = format;
+            this.maxLength = maxLength;
+            this.considerOnlyDecimalsForLength = considerOnlyDecimalsForLength;
+            this.considerDecimalSeparatorForLength = considerDecimalSeparatorForLength;
+            this.considerMinusForLength = considerMinusForLength;
+            this.considerSuffixForLength = considerSuffixForLength;
+            this.spaceAfterNumber = spaceAfterNumber;
+            if (!this.considerOnlyDecimalsForLength && this.maxLength < 4) {
+                throw new IllegalArgumentException("Max length must be at least 4 characters");
+            }
+        }
+
+        public ParamsBuilder copyToBuilder() {
+            DecimalFormat format = (DecimalFormat) this.format.clone();
+            format.setMinimumFractionDigits(this.format.getMinimumFractionDigits());
+            format.setMaximumFractionDigits(this.format.getMaximumFractionDigits());
+            format.setMinimumIntegerDigits(this.format.getMinimumIntegerDigits());
+            format.setMaximumIntegerDigits(this.format.getMaximumIntegerDigits());
+            format.setRoundingMode(this.format.getRoundingMode());
+            format.setGroupingSize(this.format.getGroupingSize());
+            format.setGroupingUsed(this.format.isGroupingUsed());
+            return new ParamsBuilder()
+                    .format(format)
+                    .maxLength(this.maxLength)
+                    .considerOnlyDecimalsForLength(this.considerOnlyDecimalsForLength)
+                    .considerDecimalSeparatorForLength(this.considerDecimalSeparatorForLength)
+                    .considerMinusForLength(this.considerMinusForLength)
+                    .considerSuffixForLength(this.considerSuffixForLength)
+                    .spaceAfterNumber(this.spaceAfterNumber);
+        }
+
+        public String format(double number) {
+            return NumberFormat.format(number, this);
+        }
+
+        public String format(BigDecimal number) {
+            return NumberFormat.format(number, this);
+        }
+    }
+
+    public static class ParamsBuilder {
+
+        private DecimalFormat format;
+        private int maxLength;
+        private boolean considerOnlyDecimalsForLength;
+        private boolean considerDecimalSeparatorForLength;
+        private boolean considerMinusForLength;
+        private boolean considerSuffixForLength;
+        private boolean spaceAfterNumber;
+
+        private DecimalFormat checkFormat() {
+            if (this.format == null) {
+                this.format = new DecimalFormat("0.###");
+            }
+            return this.format;
+        }
+
+        public ParamsBuilder format(DecimalFormat format) {
+            this.format = format;
+            return this;
+        }
+
+        public ParamsBuilder roundingMode(RoundingMode roundingMode) {
+            checkFormat().setRoundingMode(roundingMode);
+            return this;
+        }
+
+        public ParamsBuilder decimalFormatSymbols(DecimalFormatSymbols symbols) {
+            checkFormat().setDecimalFormatSymbols(symbols);
+            return this;
+        }
+
+        public ParamsBuilder decimalSeparator(char c) {
+            DecimalFormatSymbols symbols = checkFormat().getDecimalFormatSymbols();
+            symbols.setDecimalSeparator(c);
+            checkFormat().setDecimalFormatSymbols(symbols);
+            return this;
+        }
+
+        public ParamsBuilder maxLength(int maxLength) {
+            this.maxLength = maxLength;
+            return this;
+        }
+
+        public ParamsBuilder considerOnlyDecimalsForLength(boolean considerOnlyDecimalsForLength) {
+            this.considerOnlyDecimalsForLength = considerOnlyDecimalsForLength;
+            return this;
+        }
+
+        public ParamsBuilder considerDecimalSeparatorForLength(boolean considerDecimalSeparatorForLength) {
+            this.considerDecimalSeparatorForLength = considerDecimalSeparatorForLength;
+            return this;
+        }
+
+        public ParamsBuilder considerMinusForLength(boolean considerMinusForLength) {
+            this.considerMinusForLength = considerMinusForLength;
+            return this;
+        }
+
+        public ParamsBuilder considerSuffixForLength(boolean considerSuffixForLength) {
+            this.considerSuffixForLength = considerSuffixForLength;
+            return this;
+        }
+
+        public ParamsBuilder spaceAfterNumber(boolean spaceAfterNumber) {
+            this.spaceAfterNumber = spaceAfterNumber;
+            return this;
+        }
+
+        public Params build() {
+            return new Params(checkFormat(), this.maxLength, this.considerOnlyDecimalsForLength,
+                    this.considerDecimalSeparatorForLength,
+                    this.considerMinusForLength, this.considerSuffixForLength, spaceAfterNumber);
+        }
+    }
+
+    public static String format(double number, Params params) {
+        boolean negative = number < 0;
+        int maxLength = params.maxLength;
+        if (negative) {
+            number = -number;
+            if (params.considerMinusForLength) maxLength--;
+        }
+        String formattedNumber = formatInternal(number, maxLength, params);
+        if (negative) formattedNumber = "-" + formattedNumber;
+        return formattedNumber;
+    }
+
+    public static String format(BigDecimal number, Params params) {
+        boolean negative = number.compareTo(BigDecimal.ZERO) < 0;
+        int maxLength = params.maxLength;
+        if (negative) {
+            number = number.negate();
+            if (params.considerMinusForLength) maxLength--;
+        }
+        String formattedNumber = formatInternal(number, maxLength, params);
+        if (negative) formattedNumber = "-" + formattedNumber;
+        return formattedNumber;
+    }
+
+    public static String formatFromUnit(double number, SIPrefix unit, Params params) {
+        return format(number * unit.factor, params);
+    }
+
+    public static SIPrefix findBestPrefix(double number) {
+        if (Double.isNaN(number)) return SIPrefix.One;
+        if (Double.isInfinite(number)) return SIPrefix.Infinite;
+        number = Math.abs(number);
+        if (number == 0 || (number >= 1 && number < 10_000)) return SIPrefix.One;
+        SIPrefix[] high = SIPrefix.HIGH;
+        SIPrefix[] low = SIPrefix.LOW;
+        int n = high.length - 1;
+        SIPrefix prefix;
+        if (number >= 10_000) {
+            int index;
+            for (index = 0; index < n; index++) {
+                if (number < high[index + 1].factor) {
+                    break;
+                }
+            }
+            prefix = high[index];
+        } else {
+            int index;
+            for (index = 0; index < n; index++) {
+                if (number >= low[index].factor) {
+                    break;
+                }
+            }
+            prefix = low[index];
+        }
+        return prefix;
+    }
+
+    public static SIPrefix findBestPrefix(BigDecimal number) {
+        number = number.abs();
+        if ((number.compareTo(BigDecimal.ONE) >= 0 && number.compareTo(TEN_THOUSAND) < 0) ||
+                number.equals(BigDecimal.ZERO)) {
+            return SIPrefix.One;
+        }
+        SIPrefix[] high = SIPrefix.HIGH;
+        SIPrefix[] low = SIPrefix.LOW;
+        int n = high.length - 1;
+        SIPrefix prefix;
+        if (number.compareTo(TEN_THOUSAND) >= 0) {
+            int index;
+            for (index = 0; index < n; index++) {
+                if (number.compareTo(high[index + 1].bigFactor) < 0) {
+                    break;
+                }
+            }
+            prefix = high[index];
+        } else {
+            int index;
+            for (index = 0; index < n; index++) {
+                if (number.compareTo(low[index].bigFactor) >= 0) {
+                    break;
+                }
+            }
+            prefix = low[index];
+        }
+        return prefix;
+    }
+
+    private static String formatInternal(double number, int maxLength, Params params) {
+        if (Double.isNaN(number)) return "NaN";
+        SIPrefix prefix = findBestPrefix(number);
+        if (prefix.infiniteLike) return prefix.stringSymbol;
+        return formatToString(number * prefix.oneOverFactor, prefix.symbol, maxLength, params);
+    }
+
+    private static String formatToString(double value, char prefix, int maxLength, Params params) {
+        if (params.considerSuffixForLength && prefix != Character.MIN_VALUE) {
+            maxLength--;
+            if (params.spaceAfterNumber) maxLength--;
+        }
+        if (params.considerDecimalSeparatorForLength) maxLength--;
+        if (!params.considerOnlyDecimalsForLength) {
+            if (value % 1 > 0) {
+                maxLength -= GTMath.intPlaces(value);
+            }
+        }
+        int m1 = params.format.getMaximumFractionDigits();
+        int m2 = params.format.getMinimumFractionDigits();
+        params.format.setMaximumFractionDigits(maxLength);
+        String s = params.format.format(value);
+        params.format.setMaximumFractionDigits(m1);
+        params.format.setMinimumFractionDigits(m2);
+
+        if (prefix != Character.MIN_VALUE) {
+            if (params.spaceAfterNumber) s += ' ';
+            s += prefix;
+        }
+        return s;
+    }
+
+    private static String formatInternal(BigDecimal number, int maxLength, Params params) {
+        SIPrefix prefix = findBestPrefix(number);
+        if (prefix.infiniteLike) return prefix.stringSymbol;
+        return formatToString(number.multiply(prefix.bigOneOverFactor), prefix.symbol, maxLength, params);
+    }
+
+    private static String formatToString(BigDecimal value, char prefix, int maxLength, Params params) {
+        if (params.considerSuffixForLength && prefix != Character.MIN_VALUE) {
+            maxLength--;
+            if (params.spaceAfterNumber) maxLength--;
+        }
+        if (params.considerDecimalSeparatorForLength) maxLength--;
+        if (!params.considerOnlyDecimalsForLength) {
+            if (value.remainder(BigDecimal.ONE).signum() > 0) {
+                maxLength -= GTMath.intPlaces(value);
+            }
+        }
+        int m1 = params.format.getMaximumFractionDigits();
+        int m2 = params.format.getMinimumFractionDigits();
+        params.format.setMaximumFractionDigits(maxLength);
+        String s = params.format.format(value);
+        params.format.setMaximumFractionDigits(m1);
+        params.format.setMinimumFractionDigits(m2);
+
+        if (prefix != Character.MIN_VALUE) {
+            if (params.spaceAfterNumber) s += ' ';
+            s += prefix;
+        }
+        return s;
+    }
+
+    public static String formatNanos(long nanos) {
+        return DECIMALS_3.format(nanos * SIPrefix.Nano.factor);
+    }
+}
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/java/com/gregtechceu/gtceu/utils/serialization/json/JsonArrayBuilder.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonArrayBuilder.java
new file mode 100644
index 00000000000..2b5b1db52e4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonArrayBuilder.java
@@ -0,0 +1,77 @@
+package com.gregtechceu.gtceu.utils.serialization.json;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import lombok.Getter;
+
+import java.util.function.Consumer;
+
+public class JsonArrayBuilder {
+
+    @Getter
+    private final JsonArray json;
+
+    public JsonArrayBuilder(JsonArray json) {
+        this.json = json;
+    }
+
+    public JsonArrayBuilder() {
+        this(new JsonArray());
+    }
+
+    public JsonArrayBuilder add(boolean element) {
+        this.json.add(element);
+        return this;
+    }
+
+    public JsonArrayBuilder add(char element) {
+        this.json.add(element);
+        return this;
+    }
+
+    public JsonArrayBuilder add(Number element) {
+        this.json.add(element);
+        return this;
+    }
+
+    public JsonArrayBuilder add(String element) {
+        this.json.add(element);
+        return this;
+    }
+
+    public JsonArrayBuilder add(JsonElement element) {
+        this.json.add(element);
+        return this;
+    }
+
+    public JsonArrayBuilder add(JsonBuilder element) {
+        return add(element.getJson());
+    }
+
+    public JsonArrayBuilder add(JsonArrayBuilder element) {
+        return add(element.getJson());
+    }
+
+    public JsonArrayBuilder addObject(Consumer<JsonBuilder> builderConsumer) {
+        JsonBuilder builder = new JsonBuilder();
+        builderConsumer.accept(builder);
+        return add(builder.getJson());
+    }
+
+    public JsonArrayBuilder addArray(Consumer<JsonArrayBuilder> builderConsumer) {
+        JsonArrayBuilder builder = new JsonArrayBuilder();
+        builderConsumer.accept(builder);
+        return add(builder.getJson());
+    }
+
+    public JsonArrayBuilder addAllOf(JsonArray json) {
+        for (JsonElement element : json) {
+            this.json.add(element);
+        }
+        return this;
+    }
+
+    public JsonArrayBuilder addAllOf(JsonArrayBuilder json) {
+        return addAllOf(json.getJson());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonBuilder.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonBuilder.java
new file mode 100644
index 00000000000..1a16445af3f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonBuilder.java
@@ -0,0 +1,92 @@
+package com.gregtechceu.gtceu.utils.serialization.json;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import lombok.Getter;
+
+import java.util.Map;
+import java.util.function.Consumer;
+
+public class JsonBuilder {
+
+    @Getter
+    private final JsonObject json;
+
+    public JsonBuilder(JsonObject json) {
+        this.json = json;
+    }
+
+    public JsonBuilder() {
+        this(new JsonObject());
+    }
+
+    public JsonBuilder add(String key, JsonElement element) {
+        this.json.add(key, element);
+        return this;
+    }
+
+    public JsonBuilder mergeAdd(String key, JsonObject element) {
+        JsonElement merged = this.json.get(key);
+        if (merged == null || !merged.isJsonObject()) return add(key, element);
+        JsonObject mergedObj = merged.getAsJsonObject();
+        for (Map.Entry<String, JsonElement> entry : element.entrySet()) {
+            mergedObj.add(entry.getKey(), entry.getValue());
+        }
+        return this;
+    }
+
+    public JsonBuilder add(String key, String element) {
+        this.json.addProperty(key, element);
+        return this;
+    }
+
+    public JsonBuilder add(String key, Number element) {
+        this.json.addProperty(key, element);
+        return this;
+    }
+
+    public JsonBuilder add(String key, boolean element) {
+        this.json.addProperty(key, element);
+        return this;
+    }
+
+    public JsonBuilder add(String key, char element) {
+        this.json.addProperty(key, element);
+        return this;
+    }
+
+    public JsonBuilder add(String key, JsonBuilder element) {
+        return add(key, element.getJson());
+    }
+
+    public JsonBuilder add(String key, JsonArrayBuilder element) {
+        return add(key, element.getJson());
+    }
+
+    public JsonBuilder mergeAdd(String key, JsonBuilder element) {
+        return mergeAdd(key, element.getJson());
+    }
+
+    public JsonBuilder addObject(String key, Consumer<JsonBuilder> builderConsumer) {
+        JsonBuilder builder = new JsonBuilder();
+        builderConsumer.accept(builder);
+        return add(key, builder.getJson());
+    }
+
+    public JsonBuilder addArray(String key, Consumer<JsonArrayBuilder> builderConsumer) {
+        JsonArrayBuilder builder = new JsonArrayBuilder();
+        builderConsumer.accept(builder);
+        return add(key, builder.getJson());
+    }
+
+    public JsonBuilder addAllOf(JsonObject json) {
+        for (Map.Entry<String, JsonElement> entry : json.entrySet()) {
+            this.json.add(entry.getKey(), entry.getValue());
+        }
+        return this;
+    }
+
+    public JsonBuilder addAllOf(JsonBuilder json) {
+        return addAllOf(json.getJson());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonHelper.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonHelper.java
new file mode 100644
index 00000000000..4794d299aed
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/json/JsonHelper.java
@@ -0,0 +1,214 @@
+package com.gregtechceu.gtceu.utils.serialization.json;
+
+import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
+import com.gregtechceu.gtceu.api.mui.drawable.DrawableSerialization;
+import com.gregtechceu.gtceu.api.mui.utils.Alignment;
+import com.gregtechceu.gtceu.api.mui.utils.Color;
+
+import com.google.gson.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@SuppressWarnings("JavaExistingMethodCanBeUsed")
+public class JsonHelper {
+
+    public static final Gson GSON = new GsonBuilder()
+            .setPrettyPrinting()
+            .registerTypeAdapter(IDrawable.class, new DrawableSerialization())
+            .registerTypeAdapter(Alignment.class, new Alignment.Json())
+            .create();
+
+    public static JsonElement serialize(Object object) {
+        return GSON.toJsonTree(object);
+    }
+
+    public static <T> T deserialize(JsonElement json, Class<T> clazz) {
+        return GSON.fromJson(json, clazz);
+    }
+
+    public static <T> T deserialize(JsonObject json, Class<T> clazz, T defaultValue, String... keys) {
+        JsonElement element = getJsonElement(json, keys);
+        if (element != null) {
+            T t = deserialize(element, clazz);
+            return t == null ? defaultValue : t;
+        }
+        return defaultValue;
+    }
+
+    public static <T> T deserializeWithFallback(JsonObject json, JsonObject fallback, Class<T> clazz, T defaultValue,
+                                                String... keys) {
+        T t = deserialize(json, clazz, null, keys);
+        return t != null ? t : deserialize(fallback, clazz, defaultValue, keys);
+    }
+
+    public static float getFloat(JsonObject json, float defaultValue, String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                if (jsonElement.isJsonPrimitive()) {
+                    return jsonElement.getAsFloat();
+                }
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+
+    public static int getInt(JsonObject json, int defaultValue, String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                if (jsonElement.isJsonPrimitive()) {
+                    return jsonElement.getAsInt();
+                }
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+
+    public static int getIntWithFallback(JsonObject json, JsonObject fallback, int defaultValue,
+                                         String @NotNull... keys) {
+        Integer i = getBoxedInt(json, null, keys);
+        return i != null ? i : getInt(fallback, defaultValue, keys);
+    }
+
+    public static boolean getBoolean(JsonObject json, boolean defaultValue, String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                if (jsonElement.isJsonPrimitive()) {
+                    return jsonElement.getAsBoolean();
+                }
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+
+    public static boolean getBoolWithFallback(JsonObject json, JsonObject fallback, boolean defaultValue,
+                                              String @NotNull... keys) {
+        Boolean i = getBoxedBool(json, null, keys);
+        return i != null ? i : getBoolean(fallback, defaultValue, keys);
+    }
+
+    public static String getString(JsonObject json, String defaultValue, String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                return jsonElement.getAsString();
+            }
+        }
+        return defaultValue;
+    }
+
+    public static <T> T getObject(JsonObject json, T defaultValue, Function<JsonObject, T> factory,
+                                  String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                if (jsonElement.isJsonObject()) {
+                    return factory.apply(jsonElement.getAsJsonObject());
+                }
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+
+    public static <T> T getElement(JsonObject json, T defaultValue, Function<JsonElement, T> factory,
+                                   String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                return factory.apply(jsonElement);
+            }
+        }
+        return defaultValue;
+    }
+
+    public static @Nullable Integer getBoxedInt(JsonObject json, Integer defaultValue, String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                if (jsonElement.isJsonPrimitive()) {
+                    return jsonElement.getAsInt();
+                }
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+
+    public static @Nullable Boolean getBoxedBool(JsonObject json, Boolean defaultValue, String @NotNull... keys) {
+        if (json == null) return defaultValue;
+        for (String key : keys) {
+            if (json.has(key)) {
+                JsonElement jsonElement = json.get(key);
+                if (jsonElement.isJsonPrimitive()) {
+                    return jsonElement.getAsBoolean();
+                }
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+
+    public static int getColor(JsonObject json, int defaultValue, String... keys) {
+        JsonElement element = getJsonElement(json, keys);
+        if (element != null) {
+            return Color.ofJson(element);
+        }
+        return defaultValue;
+    }
+
+    public static int getColorWithFallback(JsonObject json, JsonObject fallback, int defaultValue,
+                                           String @NotNull... keys) {
+        JsonElement element = getJsonElement(json, keys);
+        if (element != null) {
+            return Color.ofJson(element);
+        }
+        return getColor(fallback, defaultValue, keys);
+    }
+
+    public static @Nullable JsonElement getJsonElement(JsonObject json, String @NotNull... keys) {
+        if (json == null) return null;
+        for (String key : keys) {
+            if (json.has(key)) {
+                return json.get(key);
+            }
+        }
+        return null;
+    }
+
+    public static JsonElement parse(InputStream inputStream) {
+        return JsonParser.parseReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
+    }
+
+    public static JsonObject merge(JsonObject base, JsonObject other) {
+        for (Map.Entry<String, JsonElement> entry : other.entrySet()) {
+            base.add(entry.getKey(), entry.getValue());
+        }
+        return base;
+    }
+
+    public static JsonObject makeJson(Consumer<JsonObject> writer) {
+        JsonObject json = new JsonObject();
+        writer.accept(json);
+        return json;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/ByteBufAdapters.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/ByteBufAdapters.java
new file mode 100644
index 00000000000..7a3cf432ba9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/ByteBufAdapters.java
@@ -0,0 +1,207 @@
+package com.gregtechceu.gtceu.utils.serialization.network;
+
+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 com.gregtechceu.gtceu.utils.EqualityTest;
+import com.gregtechceu.gtceu.utils.NetworkUtils;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.JsonOps;
+import io.netty.buffer.ByteBuf;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Objects;
+
+public class ByteBufAdapters {
+
+    // spotless:off
+    public static final IByteBufAdapter<ItemStack> ITEM_STACK = makeAdapter(FriendlyByteBuf::readItem, FriendlyByteBuf::writeItem, ItemStack::matches);
+    public static final IByteBufAdapter<FluidStack> FLUID_STACK = makeMemberAdapter(FluidStack::readFromPacket, FluidStack::writeToPacket, FluidStack::isFluidStackIdentical);
+    public static final IByteBufAdapter<CompoundTag> NBT = makeAdapter(FriendlyByteBuf::readNbt, FriendlyByteBuf::writeNbt, null);
+    public static final IByteBufAdapter<String> STRING = makeAdapter(NetworkUtils::readStringSafe, NetworkUtils::writeStringSafe, null);
+    public static final IByteBufAdapter<ByteBuf> BYTE_BUF = makeAdapter(NetworkUtils::readByteBuf, NetworkUtils::writeByteBuf, null);
+    public static final IByteBufAdapter<FriendlyByteBuf> FRIENDLY_BYTE_BUF = makeAdapter(NetworkUtils::readFriendlyByteBuf, NetworkUtils::writeByteBuf, null);
+    public static final IByteBufAdapter<MonitorGroup> MONITOR_GROUPS = makeAdapter(MonitorGroup.CODEC);
+    public static final IByteBufAdapter<Component> COMPONENT = makeAdapter(FriendlyByteBuf::readComponent, FriendlyByteBuf::writeComponent, (a, b) -> Objects.equals(a.toString(), b.toString()));
+
+    public static final IByteBufAdapter<Integer> INT = makeAdapter(FriendlyByteBuf::readInt, FriendlyByteBuf::writeInt, null);
+    public static final IByteBufAdapter<Long> LONG = makeAdapter(FriendlyByteBuf::readLong, FriendlyByteBuf::writeLong, null);
+    public static final IByteBufAdapter<Float> FLOAT = makeAdapter(FriendlyByteBuf::readFloat, FriendlyByteBuf::writeFloat, null);
+    public static final IByteBufAdapter<Double> DOUBLE = makeAdapter(FriendlyByteBuf::readDouble, FriendlyByteBuf::writeDouble, null);
+    public static final IByteBufAdapter<Boolean> BOOL = makeAdapter(FriendlyByteBuf::readBoolean, FriendlyByteBuf::writeBoolean, null);
+    public static final IByteBufAdapter<Byte> BYTE = makeAdapter(FriendlyByteBuf::readByte, (buffer, b) -> buffer.writeByte(b), null);
+    public static final IByteBufAdapter<Short> SHORT = makeAdapter(FriendlyByteBuf::readShort, (buffer, b) -> buffer.writeShort(b), null);
+    public static final IByteBufAdapter<Character> CHAR = makeAdapter(FriendlyByteBuf::readChar, (buffer, b) -> buffer.writeChar(b), null);
+
+    // spotless:on
+
+    public static final IByteBufAdapter<byte[]> BYTE_ARR = new IByteBufAdapter<>() {
+
+        @Override
+        public byte[] deserialize(FriendlyByteBuf buffer) {
+            return buffer.readByteArray();
+        }
+
+        @Override
+        public void serialize(FriendlyByteBuf buffer, byte[] u) {
+            buffer.writeByteArray(u);
+        }
+
+        @Override
+        public boolean areEqual(byte @NotNull [] t1, byte @NotNull [] t2) {
+            if (t1.length != t2.length) return false;
+            for (int i = 0; i < t1.length; i++) {
+                if (t1[i] != t2[i]) return false;
+            }
+            return true;
+        }
+    };
+
+    public static final IByteBufAdapter<long[]> LONG_ARR = new IByteBufAdapter<>() {
+
+        @Override
+        public long[] deserialize(FriendlyByteBuf buffer) {
+            return buffer.readLongArray();
+        }
+
+        @Override
+        public void serialize(FriendlyByteBuf buffer, long[] u) {
+            buffer.writeLongArray(u);
+        }
+
+        @Override
+        public boolean areEqual(long @NotNull [] t1, long @NotNull [] t2) {
+            if (t1.length != t2.length) return false;
+            for (int i = 0; i < t1.length; i++) {
+                if (t1[i] != t2[i]) return false;
+            }
+            return true;
+        }
+    };
+
+    public static final IByteBufAdapter<BigInteger> BIG_INT = new IByteBufAdapter<>() {
+
+        @Override
+        public BigInteger deserialize(FriendlyByteBuf buffer) {
+            return new BigInteger(buffer.readByteArray());
+        }
+
+        @Override
+        public void serialize(FriendlyByteBuf buffer, BigInteger u) {
+            buffer.writeByteArray(u.toByteArray());
+        }
+
+        @Override
+        public boolean areEqual(@NotNull BigInteger t1, @NotNull BigInteger t2) {
+            return t1.equals(t2);
+        }
+    };
+
+    public static final IByteBufAdapter<BigDecimal> BIG_DECIMAL = new IByteBufAdapter<>() {
+
+        @Override
+        public BigDecimal deserialize(FriendlyByteBuf buffer) {
+            return new BigDecimal(BIG_INT.deserialize(buffer), buffer.readVarInt());
+        }
+
+        @Override
+        public void serialize(FriendlyByteBuf buffer, BigDecimal u) {
+            BIG_INT.serialize(buffer, u.unscaledValue());
+            buffer.writeVarInt(u.scale());
+        }
+
+        @Override
+        public boolean areEqual(@NotNull BigDecimal t1, @NotNull BigDecimal t2) {
+            return t1.equals(t2);
+        }
+    };
+
+    public static final IByteBufAdapter<GTRecipe> GTRECIPE = new IByteBufAdapter<>() {
+
+        @Override
+        public 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, 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(@NotNull GTRecipe t1, @NotNull GTRecipe t2) {
+            return EqualityTest.wrapNullSafe(GTRecipe::equals).areEqual(t1, t2);
+        }
+    };
+
+    public static <T> IByteBufAdapter<T> makeAdapter(@NotNull IByteBufDeserializer<T> deserializer,
+                                                     @NotNull IByteBufSerializer<T> serializer,
+                                                     @Nullable EqualityTest<T> tester) {
+        return new IByteBufAdapter<>() {
+
+            @Override
+            public T deserialize(FriendlyByteBuf buffer) {
+                return deserializer.deserialize(buffer);
+            }
+
+            @Override
+            public void serialize(FriendlyByteBuf buffer, T u) {
+                serializer.serialize(buffer, u);
+            }
+
+            @Override
+            public boolean areEqual(@NotNull T t1, @NotNull T t2) {
+                return tester != null ? tester.areEqual(t1, t2) : Objects.equals(t1, t2);
+            }
+        };
+    }
+
+    public static <T> IByteBufAdapter<T> makeAdapter(@NotNull 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(@NotNull T a, @NotNull 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);
+            }
+        };
+    }
+
+    public static <T> IByteBufAdapter<T> makeMemberAdapter(@NotNull IByteBufDeserializer<T> deserializer,
+                                                           @NotNull IByteBufMemberSerializer<T> memberSerializer,
+                                                           @Nullable EqualityTest<T> comparator) {
+        return makeAdapter(deserializer, memberSerializer.asBasic(), comparator);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufAdapter.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufAdapter.java
new file mode 100644
index 00000000000..ff5d82f0317
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufAdapter.java
@@ -0,0 +1,19 @@
+package com.gregtechceu.gtceu.utils.serialization.network;
+
+import com.gregtechceu.gtceu.utils.EqualityTest;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface IByteBufAdapter<T> extends IByteBufSerializer<T>, IByteBufDeserializer<T>, EqualityTest<T> {
+
+    @Override
+    T deserialize(FriendlyByteBuf buffer);
+
+    @Override
+    void serialize(FriendlyByteBuf buffer, T u);
+
+    @Override
+    boolean areEqual(@NotNull T t1, @NotNull T t2);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufDeserializer.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufDeserializer.java
new file mode 100644
index 00000000000..06623a3f6ff
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufDeserializer.java
@@ -0,0 +1,23 @@
+package com.gregtechceu.gtceu.utils.serialization.network;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+/**
+ * A function to read an object from a {@link FriendlyByteBuf}.
+ *
+ * @param <T> object type
+ */
+public interface IByteBufDeserializer<T> {
+
+    /**
+     * Reads the object from the buffer.
+     *
+     * @param buffer buffer to read from
+     * @return the read object
+     */
+    T deserialize(FriendlyByteBuf buffer);
+
+    static <T> IByteBufDeserializer<T> wrapNullSafe(IByteBufDeserializer<T> deserializer) {
+        return buffer -> buffer.readBoolean() ? null : deserializer.deserialize(buffer);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufMemberSerializer.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufMemberSerializer.java
new file mode 100644
index 00000000000..af35e4f53fd
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufMemberSerializer.java
@@ -0,0 +1,23 @@
+package com.gregtechceu.gtceu.utils.serialization.network;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+/**
+ * A function that writes an object to a {@link FriendlyByteBuf}.
+ *
+ * @param <T> object type
+ */
+public interface IByteBufMemberSerializer<T> {
+
+    /**
+     * Writes the object to the buffer.
+     *
+     * @param value  object to write
+     * @param buffer buffer to write to
+     */
+    void serialize(T value, FriendlyByteBuf buffer);
+
+    default IByteBufSerializer<T> asBasic() {
+        return (buffer, value) -> this.serialize(value, buffer);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufSerializer.java b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufSerializer.java
new file mode 100644
index 00000000000..a420fc7dffc
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/serialization/network/IByteBufSerializer.java
@@ -0,0 +1,28 @@
+package com.gregtechceu.gtceu.utils.serialization.network;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+/**
+ * A function that writes an object to a {@link FriendlyByteBuf}.
+ *
+ * @param <T> object type
+ */
+public interface IByteBufSerializer<T> {
+
+    /**
+     * Writes the object to the buffer.
+     *
+     * @param buffer buffer to write to
+     * @param value  object to write
+     */
+    void serialize(FriendlyByteBuf buffer, T value);
+
+    static <T> IByteBufSerializer<T> wrapNullSafe(IByteBufSerializer<T> serializer) {
+        return (buffer, value) -> {
+            buffer.writeBoolean(value == null);
+            if (value != null) {
+                serializer.serialize(buffer, value);
+            }
+        };
+    }
+}
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/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/mui_display.png b/src/main/resources/assets/gtceu/textures/gui/base/mui_display.png
new file mode 100644
index 00000000000..1a36ea49fd0
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/base/mui_display.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/base/mui_display_small.png b/src/main/resources/assets/gtceu/textures/gui/base/mui_display_small.png
new file mode 100644
index 00000000000..860b0b07c1a
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/base/mui_display_small.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/modular_ui_logo.png b/src/main/resources/assets/gtceu/textures/gui/icon/modular_ui_logo.png
new file mode 100644
index 00000000000..17ebd23d5c6
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/modular_ui_logo.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/add.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/add.png
new file mode 100644
index 00000000000..02b3191681a
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/add.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/all_directions.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/all_directions.png
new file mode 100644
index 00000000000..66633f2652d
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/all_directions.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/block.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/block.png
new file mode 100644
index 00000000000..13bc571bf9c
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/block.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/bookmark.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/bookmark.png
new file mode 100644
index 00000000000..91b87c3894f
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/bookmark.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/bubble.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/bubble.png
new file mode 100644
index 00000000000..a9ecd3200fd
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/bubble.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/checkboard.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/checkboard.png
new file mode 100644
index 00000000000..670d9f8f182
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/checkboard.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/close.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/close.png
new file mode 100644
index 00000000000..05822474b34
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/close.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/code.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/code.png
new file mode 100644
index 00000000000..a968060f30e
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/code.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/copy.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/copy.png
new file mode 100644
index 00000000000..ef30e305f2b
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/copy.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cross.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cross.png
new file mode 100644
index 00000000000..6b971366b00
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cross.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cross_tiny.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cross_tiny.png
new file mode 100644
index 00000000000..a084d7753ac
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cross_tiny.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cursor.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cursor.png
new file mode 100644
index 00000000000..e5e46eb679d
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cursor.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cut.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cut.png
new file mode 100644
index 00000000000..2a8bee7afbb
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/cut.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/disabled.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/disabled.png
new file mode 100644
index 00000000000..8327f26446b
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/disabled.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/download.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/download.png
new file mode 100644
index 00000000000..8e7c9108c47
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/download.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/dupe.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/dupe.png
new file mode 100644
index 00000000000..f20fcda29d1
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/dupe.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/edit.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/edit.png
new file mode 100644
index 00000000000..a48a295e3ce
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/edit.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/exclamation.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/exclamation.png
new file mode 100644
index 00000000000..813a7b25b54
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/exclamation.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/favorite.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/favorite.png
new file mode 100644
index 00000000000..d5496882b7b
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/favorite.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/file.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/file.png
new file mode 100644
index 00000000000..5b9f5e308d6
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/file.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/filter.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/filter.png
new file mode 100644
index 00000000000..3d0c545e040
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/filter.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/folder.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/folder.png
new file mode 100644
index 00000000000..9daf261de56
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/folder.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/fullscreen.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/fullscreen.png
new file mode 100644
index 00000000000..7a809b21ae6
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/fullscreen.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/gear.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/gear.png
new file mode 100644
index 00000000000..84d4eadfc94
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/gear.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/graph.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/graph.png
new file mode 100644
index 00000000000..9db3a71d506
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/graph.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/help.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/help.png
new file mode 100644
index 00000000000..41dddb3d1dc
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/help.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/image.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/image.png
new file mode 100644
index 00000000000..5fa54bed9b6
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/image.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/invisible.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/invisible.png
new file mode 100644
index 00000000000..950a784439f
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/invisible.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/left_handle.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/left_handle.png
new file mode 100644
index 00000000000..5ad278e9ab9
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/left_handle.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/leftload.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/leftload.png
new file mode 100644
index 00000000000..cbd46cfe3ee
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/leftload.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/limb.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/limb.png
new file mode 100644
index 00000000000..7678a6c7983
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/limb.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/locked.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/locked.png
new file mode 100644
index 00000000000..dd2458f173a
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/locked.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/main_handle.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/main_handle.png
new file mode 100644
index 00000000000..6a2bda2002a
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/main_handle.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/material.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/material.png
new file mode 100644
index 00000000000..9a69e459573
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/material.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/maximize.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/maximize.png
new file mode 100644
index 00000000000..34223a2a1a9
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/maximize.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/maze.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/maze.png
new file mode 100644
index 00000000000..66b9bfeeb43
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/maze.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/minimize.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/minimize.png
new file mode 100644
index 00000000000..fd9eeaff9b0
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/minimize.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/more.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/more.png
new file mode 100644
index 00000000000..edbc3244783
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/more.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_down.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_down.png
new file mode 100644
index 00000000000..6cc44ddaa28
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_down.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_left.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_left.png
new file mode 100644
index 00000000000..2c50f56ab3f
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_left.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_right.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_right.png
new file mode 100644
index 00000000000..05d12c4f031
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_right.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_to.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_to.png
new file mode 100644
index 00000000000..f2b0ab36252
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_to.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_up.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_up.png
new file mode 100644
index 00000000000..1c4dfaa557e
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/move_up.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/paste.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/paste.png
new file mode 100644
index 00000000000..25ce5c87e2b
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/paste.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/pause.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/pause.png
new file mode 100644
index 00000000000..38b6fd6d9c7
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/pause.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/play.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/play.png
new file mode 100644
index 00000000000..99e2076ba4e
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/play.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/pose.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/pose.png
new file mode 100644
index 00000000000..76293f35e30
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/pose.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/processor.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/processor.png
new file mode 100644
index 00000000000..6f2e73b9f00
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/processor.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/refresh.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/refresh.png
new file mode 100644
index 00000000000..5e6dd1cdad6
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/refresh.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/remove.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/remove.png
new file mode 100644
index 00000000000..115288d9e77
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/remove.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/reverse.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/reverse.png
new file mode 100644
index 00000000000..8f8bae3586d
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/reverse.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/right_handle.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/right_handle.png
new file mode 100644
index 00000000000..a3487da4bce
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/right_handle.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/rightload.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/rightload.png
new file mode 100644
index 00000000000..8dcabf30a54
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/rightload.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/save.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/save.png
new file mode 100644
index 00000000000..3beb7b8e108
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/save.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/saved.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/saved.png
new file mode 100644
index 00000000000..c22d68563d3
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/saved.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/search.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/search.png
new file mode 100644
index 00000000000..2aac3b0199d
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/search.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/server.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/server.png
new file mode 100644
index 00000000000..b6a3e9f5c63
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/server.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_backward.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_backward.png
new file mode 100644
index 00000000000..a6ee0977b35
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_backward.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_forward.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_forward.png
new file mode 100644
index 00000000000..ac44bd9510d
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_forward.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_to.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_to.png
new file mode 100644
index 00000000000..74e78fbe517
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/shift_to.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/sound.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/sound.png
new file mode 100644
index 00000000000..7a7096d9547
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/sound.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/sphere.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/sphere.png
new file mode 100644
index 00000000000..94fb4d3265b
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/sphere.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/stop.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/stop.png
new file mode 100644
index 00000000000..ab4999569f7
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/stop.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/toggle_config.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/toggle_config.png
new file mode 100644
index 00000000000..f99153f78e8
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/toggle_config.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/unlocked.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/unlocked.png
new file mode 100644
index 00000000000..52f08bdf816
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/unlocked.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/upload.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/upload.png
new file mode 100644
index 00000000000..c2832341879
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/upload.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/visible.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/visible.png
new file mode 100644
index 00000000000..f0e5febdd75
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/visible.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/mui2/wrench.png b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/wrench.png
new file mode 100644
index 00000000000..a66706e8251
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/mui2/wrench.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
index b4cee091f8e..7170a9ced00 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_bottom.png and b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_bottom.png 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
index 3e8334793cf..ad37f030a63 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_left.png and b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_left.png 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
index 8dfef9e2634..ce7a821ca39 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_right.png and b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_right.png 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
index c6423541ef3..564a4676bc1 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_top.png and b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_top.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/widget/mc_button.png b/src/main/resources/assets/gtceu/textures/gui/widget/mc_button.png
new file mode 100644
index 00000000000..a05e4962da7
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/widget/mc_button.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/widget/mc_button_disabled.png b/src/main/resources/assets/gtceu/textures/gui/widget/mc_button_disabled.png
new file mode 100644
index 00000000000..9004d0fbfac
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/widget/mc_button_disabled.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/widget/mc_button_hovered.png b/src/main/resources/assets/gtceu/textures/gui/widget/mc_button_hovered.png
new file mode 100644
index 00000000000..0fe9ec5d322
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/widget/mc_button_hovered.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/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 c7352d5caf9..554f6ae45f5 100644
--- a/src/main/resources/gtceu.mixins.json
+++ b/src/main/resources/gtceu.mixins.json
@@ -6,20 +6,29 @@
     "compatibilityLevel": "JAVA_17",
     "plugin": "com.gregtechceu.gtceu.core.mixins.GTMixinPlugin",
     "client": [
+        "client.KeyboardHandlerMixin",
         "client.AbstractClientPlayerAccessor",
+        "client.AbstractContainerScreenAccessor",
+        "client.AbstractContainerScreenMixin",
+        "client.AbstractWidgetMixin",
         "client.BakedQuadMixin",
         "client.BiomeColorsMixin",
         "client.BlockModelMixin",
         "client.ClientLevelAccessor",
         "client.FaceBakeryMixin",
+        "client.GameRendererMixin",
         "client.GuiGraphicsAccessor",
         "client.GuiGraphicsMixin",
         "client.GuiHeartTypeMixin",
         "client.HumanoidArmorLayerMixin",
+        "client.KeyMappingAccessor",
         "client.LevelRendererMixin",
+        "client.MinecraftMixin",
         "client.ModelManagerMixin",
         "client.MultiPlayerGameModeMixin",
         "client.PlayerInfoAccessor",
+        "client.ScreenAccessor",
+        "client.StringSplitterAccessor",
         "client.VariantDeserializerMixin",
         "dev.client.KeyboardHandlerMixin",
         "ftbchunks.FTBChunksClientMixin",
@@ -62,7 +71,10 @@
         "TagLoaderMixin",
         "TagManagerMixin",
         "TagValueAccessor",
+        "TransientCraftingContainerAccessor",
+        "client.AbstractContainerMenuAccessor",
         "client.ItemEntityMixin",
+        "client.SlotAccessor",
         "dev.test.GameTestRegistryMixin",
         "emi.EmiRecipeFillerMixin",
         "emi.FillRecipePacketMixin",
diff --git a/src/test/java/com/gregtechceu/gtceu/gametest/util/TestUtils.java b/src/test/java/com/gregtechceu/gtceu/gametest/util/TestUtils.java
index 89663238e85..6c2840a8c17 100644
--- a/src/test/java/com/gregtechceu/gtceu/gametest/util/TestUtils.java
+++ b/src/test/java/com/gregtechceu/gtceu/gametest/util/TestUtils.java
@@ -15,7 +15,7 @@
 import com.gregtechceu.gtceu.api.placeholder.MultiLineComponent;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
-import com.gregtechceu.gtceu.common.item.CoverPlaceBehavior;
+import com.gregtechceu.gtceu.common.item.behavior.CoverPlaceBehavior;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;