diff --git a/src/main/java/gregtech/api/GregTechAPI.java b/src/main/java/gregtech/api/GregTechAPI.java
index 8ac1b6503c0..47b9456859d 100644
--- a/src/main/java/gregtech/api/GregTechAPI.java
+++ b/src/main/java/gregtech/api/GregTechAPI.java
@@ -5,7 +5,7 @@
 import gregtech.api.block.IHeatingCoilBlockStats;
 import gregtech.api.block.coil.CoilManager;
 import gregtech.api.command.ICommandManager;
-import gregtech.api.cover.CoverDefinition;
+import gregtech.api.cover.registry.CoverRegistry;
 import gregtech.api.event.HighTierEvent;
 import gregtech.api.gui.UIFactory;
 import gregtech.api.metatileentity.multiblock.IBatteryData;
@@ -74,8 +74,7 @@ public class GregTechAPI {
     @Deprecated
     public static final GTControlledRegistry<ResourceLocation, UIFactory> UI_FACTORY_REGISTRY = new GTControlledRegistry<>(
             Short.MAX_VALUE);
-    public static final GTControlledRegistry<ResourceLocation, CoverDefinition> COVER_REGISTRY = new GTControlledRegistry<>(
-            Integer.MAX_VALUE);
+    public static final CoverRegistry COVER_REGISTRY = new CoverRegistry(Integer.MAX_VALUE);
 
     public static final Map<Material, Map<StoneType, IBlockOre>> oreBlockTable = new HashMap<>();
     public static final Object2ObjectMap<IBlockState, IHeatingCoilBlockStats> HEATING_COILS = new Object2ObjectOpenHashMap<>();
diff --git a/src/main/java/gregtech/api/cover/CoverWithUI.java b/src/main/java/gregtech/api/cover/CoverWithUI.java
index 4cf44149d9f..858977c657e 100644
--- a/src/main/java/gregtech/api/cover/CoverWithUI.java
+++ b/src/main/java/gregtech/api/cover/CoverWithUI.java
@@ -1,6 +1,5 @@
 package gregtech.api.cover;
 
-import gregtech.api.mui.GTGuiTextures;
 import gregtech.api.mui.GTGuiTheme;
 import gregtech.api.mui.GregTechGuiScreen;
 import gregtech.api.mui.factory.CoverGuiFactory;
@@ -8,12 +7,10 @@
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.IStringSerializable;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
 import com.cleanroommc.modularui.api.IGuiHolder;
-import com.cleanroommc.modularui.api.drawable.IDrawable;
 import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.drawable.DynamicDrawable;
 import com.cleanroommc.modularui.drawable.ItemDrawable;
@@ -21,16 +18,11 @@
 import com.cleanroommc.modularui.screen.ModularPanel;
 import com.cleanroommc.modularui.screen.ModularScreen;
 import com.cleanroommc.modularui.screen.UISettings;
-import com.cleanroommc.modularui.utils.Alignment;
 import com.cleanroommc.modularui.utils.Color;
 import com.cleanroommc.modularui.utils.MouseData;
-import com.cleanroommc.modularui.value.BoolValue;
-import com.cleanroommc.modularui.value.sync.EnumSyncValue;
-import com.cleanroommc.modularui.value.sync.IntSyncValue;
 import com.cleanroommc.modularui.value.sync.PanelSyncManager;
 import com.cleanroommc.modularui.widget.ParentWidget;
 import com.cleanroommc.modularui.widget.Widget;
-import com.cleanroommc.modularui.widgets.ToggleButton;
 import com.cleanroommc.modularui.widgets.layout.Flow;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -139,7 +131,7 @@ default ParentWidget<?> createSettingsRow() {
     /**
      * Create a dynamic lang key that switches between {@code cover.generic.enabled} and {@code cover.generic.disabled}
      * depending on the result of the given boolean supplier. <br/>
-     * 
+     *
      * @param keyBase the base of the lang key to use. {@code .enabled} and {@code .disabled} will be appended.
      */
     default IKey createEnabledKey(@NotNull String keyBase, @NotNull BooleanSupplier enabledState) {
@@ -173,104 +165,4 @@ default IKey createAdjustOverlay(boolean increment) {
                 .color(Color.WHITE.main)
                 .scale(scale);
     }
-
-    /**
-     * 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));
-    }
-
-    /**
-     * Get a BoolValue for use with toggle buttons which are "linked together,"
-     * meaning only one of them can be pressed at a time.
-     */
-    default BoolValue.Dynamic boolValueOf(IntSyncValue syncValue, int value) {
-        return new BoolValue.Dynamic(() -> syncValue.getValue() == value, $ -> syncValue.setValue(value));
-    }
-
-    class EnumRowBuilder<T extends Enum<T>> {
-
-        private EnumSyncValue<T> syncValue;
-        private final Class<T> enumValue;
-        private String 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(String 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().marginBottom(2).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 IStringSerializable serializable) {
-                        button.addTooltipLine(IKey.lang(serializable.getName()));
-                    }
-                    row.child(button);
-                }
-            }
-
-            if (this.lang != null && !this.lang.isEmpty())
-                row.child(IKey.lang(this.lang).asWidget().align(Alignment.CenterRight).height(18));
-
-            return row;
-        }
-    }
 }
diff --git a/src/main/java/gregtech/api/cover/registry/CoverRegistry.java b/src/main/java/gregtech/api/cover/registry/CoverRegistry.java
new file mode 100644
index 00000000000..0f0b1dd0e7d
--- /dev/null
+++ b/src/main/java/gregtech/api/cover/registry/CoverRegistry.java
@@ -0,0 +1,54 @@
+package gregtech.api.cover.registry;
+
+import gregtech.api.cover.CoverDefinition;
+import gregtech.api.items.metaitem.MetaItem;
+import gregtech.api.util.GTControlledRegistry;
+import gregtech.api.util.GTUtility;
+import gregtech.common.covers.filter.BaseFilter;
+import gregtech.common.covers.filter.IFilter;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.EnumMap;
+import java.util.List;
+
+public final class CoverRegistry extends GTControlledRegistry<ResourceLocation, CoverDefinition> {
+
+    private static final EnumMap<IFilter.FilterType, List<ItemStack>> filterCovers = new EnumMap<>(
+            IFilter.FilterType.class);
+
+    public CoverRegistry(int maxId) {
+        super(maxId);
+    }
+
+    @Override
+    public void register(int id, @NotNull ResourceLocation key, @NotNull CoverDefinition coverDefinition) {
+        super.register(id, key, coverDefinition);
+
+        ItemStack coverStack = coverDefinition.getDropItemStack();
+        if (coverStack.getItem() instanceof MetaItem<?>metaItem) {
+            MetaItem<?>.MetaValueItem metaValueItem = metaItem.getItem(coverStack);
+            if (metaValueItem == null) return;
+
+            IFilter.Factory factory = metaValueItem.getFilterFactory();
+            if (factory == null) return;
+
+            BaseFilter filter = factory.create(coverStack);
+            IFilter.FilterType filterType = filter.getType();
+            if (filterType.isError()) return;
+
+            filterCovers.computeIfAbsent(filterType, $ -> new ObjectArrayList<>())
+                    .add(coverStack);
+        }
+    }
+
+    @UnmodifiableView
+    public static @NotNull List<ItemStack> getFilterItems(@NotNull IFilter.FilterType filterType) {
+        return GTUtility.unmodifiableOrEmpty(filterCovers.get(filterType));
+    }
+}
diff --git a/src/main/java/gregtech/api/mui/GTGuiTextures.java b/src/main/java/gregtech/api/mui/GTGuiTextures.java
index 80baa6244bf..647cb107bfa 100644
--- a/src/main/java/gregtech/api/mui/GTGuiTextures.java
+++ b/src/main/java/gregtech/api/mui/GTGuiTextures.java
@@ -242,11 +242,11 @@ private static String id(String path) {
             18, 18 * 2, 18, 18, ColorType.DEFAULT);
 
     public static final UITexture[] TRANSFER_MODE_OVERLAY = slice("textures/gui/overlay/transfer_mode_overlay.png",
-            18, 18 * 3, 18, 18, ColorType.DEFAULT);
+            18, 18 * 4, 18, 18, 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);
+            18, 18 * 4, 18, 18, ColorType.DEFAULT);
 
     public static final UITexture[] DISTRIBUTION_MODE_OVERLAY = slice(
             "textures/gui/widget/button_distribution_mode.png",
diff --git a/src/main/java/gregtech/api/mui/util/ValueHelper.java b/src/main/java/gregtech/api/mui/util/ValueHelper.java
new file mode 100644
index 00000000000..605503dd471
--- /dev/null
+++ b/src/main/java/gregtech/api/mui/util/ValueHelper.java
@@ -0,0 +1,59 @@
+package gregtech.api.mui.util;
+
+import com.cleanroommc.modularui.api.value.IBoolValue;
+import com.cleanroommc.modularui.api.value.IByteValue;
+import com.cleanroommc.modularui.api.value.IDoubleValue;
+import com.cleanroommc.modularui.api.value.IEnumValue;
+import com.cleanroommc.modularui.api.value.IIntValue;
+import com.cleanroommc.modularui.api.value.ILongValue;
+import com.cleanroommc.modularui.api.value.IStringValue;
+import com.cleanroommc.modularui.api.value.IValue;
+import com.cleanroommc.modularui.value.BoolValue;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.UnknownNullability;
+
+import java.util.Objects;
+
+public final class ValueHelper {
+
+    public static BoolValue.Dynamic boolValueOf(@NotNull IBoolValue<?> value, boolean target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> value.getBoolValue() == target, $ -> value.setBoolValue(target));
+    }
+
+    public static BoolValue.Dynamic boolValueOf(@NotNull IByteValue<?> value, byte target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> value.getByteValue() == target, $ -> value.setByteValue(target));
+    }
+
+    public static BoolValue.Dynamic boolValueOf(@NotNull IDoubleValue<?> value, double target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> value.getDoubleValue() == target, $ -> value.setDoubleValue(target));
+    }
+
+    public static <T extends Enum<T>> BoolValue.Dynamic boolValueOf(@NotNull IEnumValue<T> value, T target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> value.getValue() == target, $ -> value.setValue(target));
+    }
+
+    public static BoolValue.Dynamic boolValueOf(@NotNull IIntValue<?> value, int target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> value.getIntValue() == target, $ -> value.setIntValue(target));
+    }
+
+    public static BoolValue.Dynamic boolValueOf(@NotNull ILongValue<?> value, long target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> value.getLongValue() == target, $ -> value.setLongValue(target));
+    }
+
+    public static BoolValue.Dynamic boolValueOf(@NotNull IStringValue<?> value, @UnknownNullability String target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> Objects.equals(value.getStringValue(), target),
+                $ -> value.setStringValue(target));
+    }
+
+    public static <T> BoolValue.Dynamic boolValueOf(@NotNull IValue<T> value, @UnknownNullability T target) {
+        Objects.requireNonNull(value);
+        return new BoolValue.Dynamic(() -> Objects.equals(value.getValue(), target), $ -> value.setValue(target));
+    }
+}
diff --git a/src/main/java/gregtech/api/mui/widget/EnumButtonRow.java b/src/main/java/gregtech/api/mui/widget/EnumButtonRow.java
new file mode 100644
index 00000000000..13c46e0d1af
--- /dev/null
+++ b/src/main/java/gregtech/api/mui/widget/EnumButtonRow.java
@@ -0,0 +1,195 @@
+package gregtech.api.mui.widget;
+
+import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.util.ValueHelper;
+
+import com.cleanroommc.modularui.api.drawable.IDrawable;
+import com.cleanroommc.modularui.api.drawable.IKey;
+import com.cleanroommc.modularui.api.value.IEnumValue;
+import com.cleanroommc.modularui.utils.Alignment;
+import com.cleanroommc.modularui.widgets.ToggleButton;
+import com.cleanroommc.modularui.widgets.layout.Flow;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+public class EnumButtonRow<T extends Enum<T>> {
+
+    @NotNull
+    private final IEnumValue<T> value;
+    private final T[] enumValues;
+    private int margin = 2;
+    @Nullable
+    private IKey rowDescription;
+    @Nullable
+    private Function<@NotNull T, @Nullable IDrawable> backgrounds;
+    @Nullable
+    private Function<@NotNull T, @Nullable IDrawable> selectedBackgrounds;
+    @Nullable
+    private Function<@NotNull T, @Nullable IDrawable> overlays;
+    @Nullable
+    private BiConsumer<@NotNull T, @NotNull ToggleButton> widgetExtras;
+
+    public static <T extends Enum<T>> EnumButtonRow<T> builder(@NotNull IEnumValue<T> value) {
+        return new EnumButtonRow<>(value);
+    }
+
+    private EnumButtonRow(@NotNull IEnumValue<T> value) {
+        this.value = value;
+        this.enumValues = value.getEnumClass().getEnumConstants();
+    }
+
+    /**
+     * Set the margin applied to the right side of each button. <br/>
+     * The default is {@code 2}.
+     */
+    public EnumButtonRow<T> buttonMargins(int margin) {
+        this.margin = margin;
+        return this;
+    }
+
+    /**
+     * Add an {@link IKey} to the row that will be right aligned at the end.
+     */
+    public EnumButtonRow<T> rowDescription(@NotNull IKey lang) {
+        this.rowDescription = lang;
+        return this;
+    }
+
+    /**
+     * Add a background to each {@link ToggleButton} when the button is not selected. <br/>
+     * Return {@code null} from the function to skip setting a background on the button associated with the enum value.
+     */
+    public EnumButtonRow<T> backgrounds(Function<@NotNull T, @Nullable IDrawable> background) {
+        this.backgrounds = background;
+        return this;
+    }
+
+    /**
+     * Add a background to each {@link ToggleButton} when the button is selected. <br/>
+     * Return {@code null} from the function to skip setting a selected background on the button associated with the
+     * enum value.
+     */
+    public EnumButtonRow<T> selectedBackgrounds(Function<@NotNull T, @Nullable IDrawable> selectedBackground) {
+        this.selectedBackgrounds = selectedBackground;
+        return this;
+    }
+
+    /**
+     * Add an overlay to each {@link ToggleButton}. <br/>
+     * Return {@code null} from the function to skip setting an overlay on the button associated with the enum value.
+     */
+    public EnumButtonRow<T> overlays(Function<@NotNull T, @Nullable IDrawable> overlay) {
+        this.overlays = overlay;
+        return this;
+    }
+
+    /**
+     * Add an overlay to each {@link ToggleButton}. <br/>
+     * The array can either have a length of 1 to apply the same overlay to every button, or it must have the same
+     * number of elements as the enum does. <br/>
+     * Use {@link #overlays(Function)} if you need more granular control over each button's overlay.
+     *
+     * @throws IllegalArgumentException if the two array length conditions aren't met
+     */
+    public EnumButtonRow<T> overlays(@NotNull IDrawable @NotNull... overlay) {
+        int len = overlay.length;
+        if (len == 1) {
+            return overlays($ -> overlay[0]);
+        } else if (len != enumValues.length) {
+            throw new IllegalArgumentException(
+                    "Number of elements in the overlay array must be 1 or the same as the enum!");
+        }
+
+        return overlays(val -> overlay[val.ordinal()]);
+    }
+
+    /**
+     * Add an overlay with a certain size to each {@link ToggleButton}. <br/>
+     * The array can either have a length of 1 to apply the same overlay to every button, or it must have the same
+     * number of elements as the enum does. <br/>
+     * Use {@link #overlays(Function)} if you need more granular control over each button's overlay.
+     *
+     * @throws IllegalArgumentException if the two array length conditions aren't met
+     *
+     */
+    public EnumButtonRow<T> overlays(int size, @NotNull IDrawable @NotNull... overlay) {
+        int len = overlay.length;
+        if (len == 1) {
+            IDrawable singleOverlay = overlay[0]
+                    .asIcon()
+                    .size(size);
+            return overlays($ -> singleOverlay);
+        } else if (len != enumValues.length) {
+            throw new IllegalArgumentException(
+                    "Number of elements in the overlay array must be 1 or the same as the enum!");
+        }
+
+        return overlays(val -> overlay[val.ordinal()]
+                .asIcon()
+                .size(size));
+    }
+
+    /**
+     * Configure each toggle button directly.
+     */
+    public EnumButtonRow<T> widgetExtras(@NotNull BiConsumer<@NotNull T, @NotNull ToggleButton> widgetExtras) {
+        this.widgetExtras = widgetExtras;
+        return this;
+    }
+
+    public Flow build() {
+        Flow row = Flow.row()
+                .marginBottom(2)
+                .widthRel(1f)
+                .coverChildrenHeight();
+
+        for (T enumVal : enumValues) {
+            ToggleButton button = new ToggleButton()
+                    .marginRight(margin)
+                    .size(18)
+                    .value(ValueHelper.boolValueOf(value, enumVal));
+
+            IDrawable background = GTGuiTextures.MC_BUTTON;
+            if (this.backgrounds != null) {
+                IDrawable backgroundReplacement = this.backgrounds.apply(enumVal);
+                if (backgroundReplacement != null) {
+                    background = backgroundReplacement;
+                }
+            }
+            button.background(background);
+
+            IDrawable selectedBackground = GTGuiTextures.MC_BUTTON_DISABLED;
+            if (this.selectedBackgrounds != null) {
+                IDrawable selectedBackgroundReplacement = this.selectedBackgrounds.apply(enumVal);
+                if (selectedBackgroundReplacement != null) {
+                    selectedBackground = selectedBackgroundReplacement;
+                }
+            }
+            button.selectedBackground(selectedBackground);
+
+            if (overlays != null) {
+                IDrawable overlay = this.overlays.apply(enumVal);
+                if (overlay != null) {
+                    button.overlay(overlay);
+                }
+            }
+
+            if (this.widgetExtras != null) {
+                this.widgetExtras.accept(enumVal, button);
+            }
+
+            row.child(button);
+        }
+
+        if (this.rowDescription != null && !this.rowDescription.get().isEmpty()) {
+            row.child(this.rowDescription.asWidget()
+                    .align(Alignment.CenterRight)
+                    .height(18));
+        }
+
+        return row;
+    }
+}
diff --git a/src/main/java/gregtech/api/util/GTUtility.java b/src/main/java/gregtech/api/util/GTUtility.java
index 597f8ef6095..5384b63b63c 100644
--- a/src/main/java/gregtech/api/util/GTUtility.java
+++ b/src/main/java/gregtech/api/util/GTUtility.java
@@ -67,6 +67,7 @@
 
 import java.util.AbstractList;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -1024,9 +1025,14 @@ public static int combineRGB(@Range(from = 0, to = 255) int r, @Range(from = 0,
         return map.get(key.toWildcard());
     }
 
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
     public static boolean areFluidStacksEqual(@Nullable FluidStack a, @Nullable FluidStack b) {
         if (a == b) return true;
         if (a == null) return false;
         return a.isFluidEqual(b);
     }
+
+    public static <T> @NotNull List<T> unmodifiableOrEmpty(@Nullable List<T> sourceList) {
+        return sourceList == null ? Collections.emptyList() : Collections.unmodifiableList(sourceList);
+    }
 }
diff --git a/src/main/java/gregtech/api/util/ITranslatable.java b/src/main/java/gregtech/api/util/ITranslatable.java
new file mode 100644
index 00000000000..35810cb77fe
--- /dev/null
+++ b/src/main/java/gregtech/api/util/ITranslatable.java
@@ -0,0 +1,57 @@
+package gregtech.api.util;
+
+import net.minecraft.util.IStringSerializable;
+
+import com.cleanroommc.modularui.api.drawable.IKey;
+import com.cleanroommc.modularui.api.widget.ITooltip;
+import com.cleanroommc.modularui.drawable.text.LangKey;
+import com.cleanroommc.modularui.widget.Widget;
+import org.jetbrains.annotations.NotNull;
+
+public interface ITranslatable extends IStringSerializable {
+
+    /**
+     * Get the I18n translation key of this object.
+     */
+    @NotNull
+    @Override
+    String getName();
+
+    /**
+     * Get a {@link LangKey} of this objects name.
+     */
+    @NotNull
+    default IKey getKey() {
+        return IKey.lang(getName());
+    }
+
+    /**
+     * Get the I18n translation key of this object depending on a string key.
+     */
+    @NotNull
+    default String getName(@NotNull String key) {
+        return getName();
+    }
+
+    /**
+     * Get a {@link LangKey} of this objects name depending on a string key.
+     */
+    @NotNull
+    default IKey getKey(@NotNull String key) {
+        return IKey.lang(getName(key));
+    }
+
+    /**
+     * Handle adding tooltip line(s) to an {@link ITooltip}, typically {@link Widget}s
+     */
+    default void handleTooltip(@NotNull ITooltip<?> tooltip) {
+        tooltip.addTooltipLine(getKey());
+    }
+
+    /**
+     * Handle adding tooltip line(s) to an {@link ITooltip}, typically {@link Widget}s, depending on a string key.
+     */
+    default void handleTooltip(@NotNull ITooltip<?> tooltip, @NotNull String key) {
+        tooltip.addTooltipLine(getKey(key));
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/CoverConveyor.java b/src/main/java/gregtech/common/covers/CoverConveyor.java
index 7cdd1b9f85b..b6c67675bdd 100644
--- a/src/main/java/gregtech/common/covers/CoverConveyor.java
+++ b/src/main/java/gregtech/common/covers/CoverConveyor.java
@@ -10,7 +10,9 @@
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
 import gregtech.api.mui.GTGuis;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.GTTransferUtils;
+import gregtech.api.util.ITranslatable;
 import gregtech.api.util.ItemStackHashStrategy;
 import gregtech.client.renderer.texture.Textures;
 import gregtech.client.renderer.texture.cube.SimpleSidedCubeRenderer;
@@ -29,7 +31,6 @@
 import net.minecraft.util.EnumActionResult;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
-import net.minecraft.util.IStringSerializable;
 import net.minecraft.util.ITickable;
 import net.minecraft.util.math.MathHelper;
 import net.minecraftforge.common.capabilities.Capability;
@@ -43,7 +44,7 @@
 import codechicken.lib.render.pipeline.IVertexOperation;
 import codechicken.lib.vec.Cuboid6;
 import codechicken.lib.vec.Matrix4;
-import com.cleanroommc.modularui.api.drawable.IDrawable;
+import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.drawable.DynamicDrawable;
 import com.cleanroommc.modularui.factory.GuiData;
 import com.cleanroommc.modularui.factory.SidedPosGuiData;
@@ -63,7 +64,6 @@
 import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
@@ -72,7 +72,7 @@ public class CoverConveyor extends CoverBase implements CoverWithUI, ITickable,
     public final int tier;
     public final int maxItemTransferRate;
     private int transferRate;
-    protected ConveyorMode conveyorMode;
+    protected IOMode ioMode = IOMode.EXPORT;
     protected DistributionMode distributionMode;
     protected ManualImportExportMode manualImportExportMode = ManualImportExportMode.DISABLED;
     protected final ItemFilterContainer itemFilterContainer;
@@ -87,7 +87,6 @@ public CoverConveyor(@NotNull CoverDefinition definition, @NotNull CoverableView
         this.maxItemTransferRate = itemsPerSecond;
         this.transferRate = maxItemTransferRate;
         this.itemsLeftToTransferLastSecond = transferRate;
-        this.conveyorMode = ConveyorMode.EXPORT;
         this.distributionMode = DistributionMode.INSERT_FIRST;
         this.itemFilterContainer = new ItemFilterContainer(this);
     }
@@ -119,14 +118,14 @@ protected void adjustTransferRate(int amount) {
         setTransferRate(MathHelper.clamp(transferRate + amount, 1, maxItemTransferRate));
     }
 
-    public void setConveyorMode(ConveyorMode conveyorMode) {
-        this.conveyorMode = conveyorMode;
-        writeCustomData(GregtechDataCodes.UPDATE_COVER_MODE, buf -> buf.writeEnumValue(conveyorMode));
+    public void setIOMode(IOMode ioMode) {
+        this.ioMode = ioMode;
+        writeCustomData(GregtechDataCodes.UPDATE_COVER_MODE, buf -> buf.writeEnumValue(ioMode));
         markDirty();
     }
 
-    public ConveyorMode getConveyorMode() {
-        return conveyorMode;
+    public IOMode getIOMode() {
+        return ioMode;
     }
 
     public DistributionMode getDistributionMode() {
@@ -176,52 +175,42 @@ protected int doTransferItems(IItemHandler itemHandler, IItemHandler myItemHandl
     }
 
     protected int doTransferItemsAny(IItemHandler itemHandler, IItemHandler myItemHandler, int maxTransferAmount) {
-        if (conveyorMode == ConveyorMode.IMPORT) {
-            return moveInventoryItems(itemHandler, myItemHandler, maxTransferAmount);
-        } else if (conveyorMode == ConveyorMode.EXPORT) {
-            return moveInventoryItems(myItemHandler, itemHandler, maxTransferAmount);
-        }
-        return 0;
+        return switch (ioMode) {
+            case IMPORT -> moveInventoryItems(itemHandler, myItemHandler, maxTransferAmount);
+            case EXPORT -> moveInventoryItems(myItemHandler, itemHandler, maxTransferAmount);
+        };
     }
 
     protected int doTransferItemsByGroup(IItemHandler itemHandler, IItemHandler myItemHandler,
                                          Map<Integer, GroupItemInfo> itemInfos, int maxTransferAmount) {
-        if (conveyorMode == ConveyorMode.IMPORT) {
-            return moveInventoryItems(itemHandler, myItemHandler, itemInfos, maxTransferAmount);
-        } else if (conveyorMode == ConveyorMode.EXPORT) {
-            return moveInventoryItems(myItemHandler, itemHandler, itemInfos, maxTransferAmount);
-        }
-        return 0;
+        return switch (ioMode) {
+            case IMPORT -> moveInventoryItems(itemHandler, myItemHandler, itemInfos, maxTransferAmount);
+            case EXPORT -> moveInventoryItems(myItemHandler, itemHandler, itemInfos, maxTransferAmount);
+        };
     }
 
     protected Map<Integer, GroupItemInfo> doCountDestinationInventoryItemsByMatchIndex(IItemHandler itemHandler,
                                                                                        IItemHandler myItemHandler) {
-        if (conveyorMode == ConveyorMode.IMPORT) {
-            return countInventoryItemsByMatchSlot(myItemHandler);
-        } else if (conveyorMode == ConveyorMode.EXPORT) {
-            return countInventoryItemsByMatchSlot(itemHandler);
-        }
-        return Collections.emptyMap();
+        return switch (ioMode) {
+            case IMPORT -> countInventoryItemsByMatchSlot(myItemHandler);
+            case EXPORT -> countInventoryItemsByMatchSlot(itemHandler);
+        };
     }
 
     protected Map<ItemStack, TypeItemInfo> doCountSourceInventoryItemsByType(IItemHandler itemHandler,
                                                                              IItemHandler myItemHandler) {
-        if (conveyorMode == ConveyorMode.IMPORT) {
-            return countInventoryItemsByType(itemHandler);
-        } else if (conveyorMode == ConveyorMode.EXPORT) {
-            return countInventoryItemsByType(myItemHandler);
-        }
-        return Collections.emptyMap();
+        return switch (ioMode) {
+            case IMPORT -> countInventoryItemsByType(itemHandler);
+            case EXPORT -> countInventoryItemsByType(myItemHandler);
+        };
     }
 
     protected boolean doTransferItemsExact(IItemHandler itemHandler, IItemHandler myItemHandler,
                                            TypeItemInfo itemInfo) {
-        if (conveyorMode == ConveyorMode.IMPORT) {
-            return moveInventoryItemsExact(itemHandler, myItemHandler, itemInfo);
-        } else if (conveyorMode == ConveyorMode.EXPORT) {
-            return moveInventoryItemsExact(myItemHandler, itemHandler, itemInfo);
-        }
-        return false;
+        return switch (ioMode) {
+            case IMPORT -> moveInventoryItemsExact(itemHandler, myItemHandler, itemInfo);
+            case EXPORT -> moveInventoryItemsExact(myItemHandler, itemHandler, itemInfo);
+        };
     }
 
     protected static boolean moveInventoryItemsExact(IItemHandler sourceInventory, IItemHandler targetInventory,
@@ -459,9 +448,10 @@ public void onRemoval() {
     }
 
     @Override
-    public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline,
-                            Cuboid6 plateBox, BlockRenderLayer layer) {
-        if (conveyorMode == ConveyorMode.EXPORT) {
+    public void renderCover(@NotNull CCRenderState renderState, @NotNull Matrix4 translation,
+                            IVertexOperation[] pipeline,
+                            @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer) {
+        if (ioMode.isExport()) {
             Textures.CONVEYOR_OVERLAY.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
         } else {
             Textures.CONVEYOR_OVERLAY_INVERTED.renderSided(getAttachedSide(), plateBox, renderState, pipeline,
@@ -479,7 +469,7 @@ public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexO
     }
 
     @Override
-    public <T> T getCapability(Capability<T> capability, T defaultValue) {
+    public <T> T getCapability(@NotNull Capability<T> capability, T defaultValue) {
         if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
             if (defaultValue == null) {
                 return null;
@@ -489,16 +479,16 @@ public <T> T getCapability(Capability<T> capability, T defaultValue) {
                 this.itemHandlerWrapper = new CoverableItemHandlerWrapper(delegate);
             }
             return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(itemHandlerWrapper);
-        }
-        if (capability == GregtechTileCapabilities.CAPABILITY_CONTROLLABLE) {
+        } else if (capability == GregtechTileCapabilities.CAPABILITY_CONTROLLABLE) {
             return GregtechTileCapabilities.CAPABILITY_CONTROLLABLE.cast(this);
         }
+
         return defaultValue;
     }
 
     @Override
     public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncManager, UISettings settings) {
-        var panel = GTGuis.createPanel(this, 176, 192 + 18);
+        ModularPanel panel = GTGuis.createPanel(this, 176, 192 + 18);
 
         getItemFilterContainer().setMaxTransferSize(getMaxStackSize());
 
@@ -508,81 +498,96 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
     }
 
     protected Flow createUI(GuiData data, PanelSyncManager guiSyncManager) {
-        var column = Flow.column().top(24).margin(7, 0)
-                .widthRel(1f).coverChildrenHeight();
-
-        EnumSyncValue<ManualImportExportMode> manualIOmode = new EnumSyncValue<>(ManualImportExportMode.class,
-                this::getManualImportExportMode, this::setManualImportExportMode);
-
-        EnumSyncValue<ConveyorMode> conveyorMode = new EnumSyncValue<>(ConveyorMode.class,
-                this::getConveyorMode, this::setConveyorMode);
-
-        IntSyncValue throughput = new IntSyncValue(this::getTransferRate, this::setTransferRate);
-
-        EnumSyncValue<DistributionMode> distributionMode = new EnumSyncValue<>(DistributionMode.class,
-                this::getDistributionMode, this::setDistributionMode);
-
-        guiSyncManager.syncValue("manual_io", manualIOmode);
-        guiSyncManager.syncValue("conveyor_mode", conveyorMode);
-        guiSyncManager.syncValue("distribution_mode", distributionMode);
-
-        if (createThroughputRow())
-            column.child(Flow.row().coverChildrenHeight()
-                    .marginBottom(2).widthRel(1f)
+        // noinspection DuplicatedCode
+        Flow column = Flow.column()
+                .top(24)
+                .widthRel(1f)
+                .margin(7, 0)
+                .coverChildrenHeight();
+
+        if (createThroughputRow()) {
+            IntSyncValue throughputSync = new IntSyncValue(this::getTransferRate, this::setTransferRate);
+            column.child(Flow.row()
+                    .widthRel(1f)
+                    .coverChildrenHeight()
+                    .marginBottom(2)
                     .child(new ButtonWidget<>()
-                            .left(0).width(18)
+                            .width(18)
+                            .left(0)
                             .onMousePressed(mouseButton -> {
-                                int val = throughput.getValue() - getIncrementValue(MouseData.create(mouseButton));
-                                throughput.setValue(val, true, true);
+                                int val = throughputSync.getValue() - getIncrementValue(MouseData.create(mouseButton));
+                                throughputSync.setValue(Math.max(val, 1), true, true);
                                 return true;
                             })
                             .onUpdateListener(w -> w.overlay(createAdjustOverlay(false))))
                     .child(new GTTextFieldWidget()
-                            .left(18).right(18)
+                            .left(18)
+                            .right(18)
                             .setPostFix(" items/s")
                             .setTextColor(Color.WHITE.darker(1))
                             .setNumbers(1, maxItemTransferRate)
-                            .value(throughput)
+                            .value(throughputSync)
                             .background(GTGuiTextures.DISPLAY))
                     .child(new ButtonWidget<>()
-                            .right(0).width(18)
+                            .right(0)
+                            .width(18)
                             .onMousePressed(mouseButton -> {
-                                int val = throughput.getValue() + getIncrementValue(MouseData.create(mouseButton));
-                                throughput.setValue(val, true, true);
+                                int val = throughputSync.getValue() + getIncrementValue(MouseData.create(mouseButton));
+                                throughputSync.setValue(Math.min(val, maxItemTransferRate), true, true);
                                 return true;
                             })
                             .onUpdateListener(w -> w.overlay(createAdjustOverlay(true)))));
+        }
 
-        if (createFilterRow())
+        if (createFilterRow()) {
             column.child(getItemFilterContainer().initUI(data, guiSyncManager));
+        }
 
-        if (createManualIOModeRow())
-            column.child(new EnumRowBuilder<>(ManualImportExportMode.class)
-                    .value(manualIOmode)
-                    .lang("cover.generic.manual_io")
-                    .overlay(new IDrawable[] {
-                            new DynamicDrawable(() -> conveyorMode.getValue().isImport() ?
-                                    GTGuiTextures.MANUAL_IO_OVERLAY_OUT[0] : GTGuiTextures.MANUAL_IO_OVERLAY_IN[0]),
-                            new DynamicDrawable(() -> conveyorMode.getValue().isImport() ?
-                                    GTGuiTextures.MANUAL_IO_OVERLAY_OUT[1] : GTGuiTextures.MANUAL_IO_OVERLAY_IN[1]),
-                            new DynamicDrawable(() -> conveyorMode.getValue().isImport() ?
-                                    GTGuiTextures.MANUAL_IO_OVERLAY_OUT[2] : GTGuiTextures.MANUAL_IO_OVERLAY_IN[2])
+        EnumSyncValue<IOMode> conveyorModeSync = new EnumSyncValue<>(IOMode.class, this::getIOMode, this::setIOMode);
+        guiSyncManager.syncValue("conveyor_mode", conveyorModeSync);
+
+        if (createManualIOModeRow()) {
+            EnumSyncValue<ManualImportExportMode> manualIOModeSync = new EnumSyncValue<>(ManualImportExportMode.class,
+                    this::getManualImportExportMode, this::setManualImportExportMode);
+            guiSyncManager.syncValue("manual_io", manualIOModeSync);
+
+            // noinspection DuplicatedCode
+            column.child(EnumButtonRow.builder(manualIOModeSync)
+                    .rowDescription(IKey.lang("cover.generic.manual_io"))
+                    .overlays(val -> {
+                        int textureIndex = val.ordinal();
+                        return new DynamicDrawable(() -> {
+                            if (conveyorModeSync.getValue().isImport()) {
+                                return GTGuiTextures.MANUAL_IO_OVERLAY_OUT[textureIndex];
+                            } else {
+                                return GTGuiTextures.MANUAL_IO_OVERLAY_IN[textureIndex];
+                            }
+                        });
                     })
+                    .widgetExtras((manualImportExportMode, toggleButton) -> manualImportExportMode
+                            .handleTooltip(toggleButton, "conveyor"))
                     .build());
+        }
 
-        if (createConveyorModeRow())
-            column.child(new EnumRowBuilder<>(ConveyorMode.class)
-                    .value(conveyorMode)
-                    .lang("cover.generic.io")
-                    .overlay(GTGuiTextures.CONVEYOR_MODE_OVERLAY)
+        if (createConveyorModeRow()) {
+            column.child(EnumButtonRow.builder(conveyorModeSync)
+                    .rowDescription(IKey.lang("cover.generic.io"))
+                    .overlays(GTGuiTextures.CONVEYOR_MODE_OVERLAY)
+                    .widgetExtras((ioMode, toggleButton) -> ioMode.handleTooltip(toggleButton, "conveyor"))
                     .build());
+        }
 
-        if (createDistributionModeRow())
-            column.child(new EnumRowBuilder<>(DistributionMode.class)
-                    .value(distributionMode)
-                    .overlay(16, GTGuiTextures.DISTRIBUTION_MODE_OVERLAY)
-                    .lang("cover.conveyor.distribution.name")
+        if (createDistributionModeRow()) {
+            EnumSyncValue<DistributionMode> distributionModeSync = new EnumSyncValue<>(DistributionMode.class,
+                    this::getDistributionMode, this::setDistributionMode);
+            guiSyncManager.syncValue("distribution_mode", distributionModeSync);
+
+            column.child(EnumButtonRow.builder(distributionModeSync)
+                    .rowDescription(IKey.lang("cover.conveyor.distribution.name"))
+                    .overlays(16, GTGuiTextures.DISTRIBUTION_MODE_OVERLAY)
+                    .widgetExtras(ITranslatable::handleTooltip)
                     .build());
+        }
 
         return column;
     }
@@ -625,7 +630,7 @@ public void setWorkingEnabled(boolean isActivationAllowed) {
     public void readCustomData(int discriminator, @NotNull PacketBuffer buf) {
         super.readCustomData(discriminator, buf);
         if (discriminator == GregtechDataCodes.UPDATE_COVER_MODE) {
-            this.conveyorMode = buf.readEnumValue(ConveyorMode.class);
+            this.ioMode = buf.readEnumValue(IOMode.class);
             getCoverableView().scheduleRenderUpdate();
         }
     }
@@ -634,7 +639,7 @@ public void readCustomData(int discriminator, @NotNull PacketBuffer buf) {
     public void writeInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.writeInitialSyncData(packetBuffer);
         packetBuffer.writeInt(transferRate);
-        packetBuffer.writeByte(conveyorMode.ordinal());
+        packetBuffer.writeByte(ioMode.ordinal());
         packetBuffer.writeByte(distributionMode.ordinal());
         packetBuffer.writeByte(manualImportExportMode.ordinal());
         getItemFilterContainer().writeInitialSyncData(packetBuffer);
@@ -644,7 +649,7 @@ public void writeInitialSyncData(@NotNull PacketBuffer packetBuffer) {
     public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.readInitialSyncData(packetBuffer);
         this.transferRate = packetBuffer.readInt();
-        this.conveyorMode = ConveyorMode.VALUES[packetBuffer.readByte()];
+        this.ioMode = IOMode.VALUES[packetBuffer.readByte()];
         this.distributionMode = DistributionMode.VALUES[packetBuffer.readByte()];
         this.manualImportExportMode = ManualImportExportMode.VALUES[packetBuffer.readByte()];
         getItemFilterContainer().readInitialSyncData(packetBuffer);
@@ -654,7 +659,7 @@ public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {
     public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
         super.writeToNBT(tagCompound);
         tagCompound.setInteger("TransferRate", transferRate);
-        tagCompound.setInteger("ConveyorMode", conveyorMode.ordinal());
+        tagCompound.setInteger("ConveyorMode", ioMode.ordinal());
         tagCompound.setInteger("DistributionMode", distributionMode.ordinal());
         tagCompound.setBoolean("WorkingAllowed", isWorkingAllowed);
         tagCompound.setInteger("ManualImportExportMode", manualImportExportMode.ordinal());
@@ -665,7 +670,7 @@ public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
     public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         super.readFromNBT(tagCompound);
         this.transferRate = tagCompound.getInteger("TransferRate");
-        this.conveyorMode = ConveyorMode.VALUES[tagCompound.getInteger("ConveyorMode")];
+        this.ioMode = IOMode.VALUES[tagCompound.getInteger("ConveyorMode")];
         this.distributionMode = DistributionMode.VALUES[tagCompound.getInteger("DistributionMode")];
         this.isWorkingAllowed = tagCompound.getBoolean("WorkingAllowed");
         this.manualImportExportMode = ManualImportExportMode.VALUES[tagCompound.getInteger("ManualImportExportMode")];
@@ -683,30 +688,6 @@ public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         return Textures.VOLTAGE_CASINGS[this.tier].getSpriteOnSide(SimpleSidedCubeRenderer.RenderSide.SIDE);
     }
 
-    public enum ConveyorMode implements IStringSerializable, IIOMode {
-
-        IMPORT("cover.conveyor.mode.import"),
-        EXPORT("cover.conveyor.mode.export");
-
-        public static final ConveyorMode[] VALUES = values();
-        public final String localeName;
-
-        ConveyorMode(String localeName) {
-            this.localeName = localeName;
-        }
-
-        @NotNull
-        @Override
-        public String getName() {
-            return localeName;
-        }
-
-        @Override
-        public boolean isImport() {
-            return this == IMPORT;
-        }
-    }
-
     private class CoverableItemHandlerWrapper extends ItemHandlerDelegate {
 
         public CoverableItemHandlerWrapper(IItemHandler delegate) {
@@ -716,29 +697,26 @@ public CoverableItemHandlerWrapper(IItemHandler delegate) {
         @NotNull
         @Override
         public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
-            if (conveyorMode == ConveyorMode.EXPORT && manualImportExportMode == ManualImportExportMode.DISABLED) {
-                return stack;
-            }
-            if (manualImportExportMode == ManualImportExportMode.FILTERED &&
-                    !itemFilterContainer.test(stack)) {
-                return stack;
-            }
-            return super.insertItem(slot, stack, simulate);
+            boolean block = ioMode.isExport() && manualImportExportMode.isDisabled();
+            block |= manualImportExportMode.isFiltered() && !itemFilterContainer.test(stack);
+
+            return block ? stack : super.insertItem(slot, stack, simulate);
         }
 
         @NotNull
         @Override
         public ItemStack extractItem(int slot, int amount, boolean simulate) {
-            if (conveyorMode == ConveyorMode.IMPORT && manualImportExportMode == ManualImportExportMode.DISABLED) {
+            if (ioMode.isImport() && manualImportExportMode.isDisabled()) {
                 return ItemStack.EMPTY;
-            }
-            if (manualImportExportMode == ManualImportExportMode.FILTERED) {
+            } else if (manualImportExportMode.isFiltered()) {
                 ItemStack result = super.extractItem(slot, amount, true);
                 if (result.isEmpty() || !itemFilterContainer.test(result)) {
                     return ItemStack.EMPTY;
                 }
+
                 return simulate ? result : super.extractItem(slot, amount, false);
             }
+
             return super.extractItem(slot, amount, simulate);
         }
     }
diff --git a/src/main/java/gregtech/common/covers/CoverFluidFilter.java b/src/main/java/gregtech/common/covers/CoverFluidFilter.java
index c0d9ff4c375..e3308af986b 100644
--- a/src/main/java/gregtech/common/covers/CoverFluidFilter.java
+++ b/src/main/java/gregtech/common/covers/CoverFluidFilter.java
@@ -6,8 +6,10 @@
 import gregtech.api.cover.CoverWithUI;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.GTLog;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.ITranslatable;
 import gregtech.client.renderer.texture.cube.SimpleOverlayRenderer;
 import gregtech.common.covers.filter.BaseFilter;
 import gregtech.common.covers.filter.BaseFilterContainer;
@@ -143,7 +145,8 @@ public boolean canPipePassThrough() {
 
     @Override
     public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncManager, UISettings settings) {
-        var filteringMode = new EnumSyncValue<>(FluidFilterMode.class, this::getFilterMode, this::setFilterMode);
+        EnumSyncValue<FluidFilterMode> filteringMode = new EnumSyncValue<>(FluidFilterMode.class, this::getFilterMode,
+                this::setFilterMode);
 
         guiSyncManager.syncValue("filtering_mode", filteringMode);
         this.fluidFilterContainer.setMaxTransferSize(1);
@@ -152,10 +155,10 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
                 .size(176, 212).padding(7)
                 .child(CoverWithUI.createTitleRow(getFilterContainer().getFilterStack()))
                 .child(Flow.column().widthRel(1f).align(Alignment.TopLeft).top(22).coverChildrenHeight()
-                        .child(new EnumRowBuilder<>(FluidFilterMode.class)
-                                .value(filteringMode)
-                                .lang("cover.filter.mode.title")
-                                .overlay(16, GTGuiTextures.FILTER_MODE_OVERLAY)
+                        .child(EnumButtonRow.builder(filteringMode)
+                                .rowDescription(IKey.lang("cover.filter.mode.title"))
+                                .overlays(16, GTGuiTextures.FILTER_MODE_OVERLAY)
+                                .widgetExtras(ITranslatable::handleTooltip)
                                 .build())
                         .child(Flow.row()
                                 .marginBottom(2)
@@ -174,10 +177,16 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
                                         .asWidget()
                                         .height(18)
                                         .alignX(1f)))
-                        .child(new Rectangle().setColor(UI_TEXT_COLOR).asWidget()
-                                .height(1).widthRel(0.95f).margin(0, 4))
+                        .child(new Rectangle()
+                                .setColor(UI_TEXT_COLOR)
+                                .asWidget()
+                                .widthRel(0.95f)
+                                .height(1)
+                                .margin(0, 4))
                         .child(getFilter().createWidgets(guiSyncManager)))
-                .child(SlotGroupWidget.playerInventory(false).bottom(7).left(7));
+                .child(SlotGroupWidget.playerInventory(false)
+                        .left(7)
+                        .bottom(7));
     }
 
     @Override
diff --git a/src/main/java/gregtech/common/covers/CoverFluidRegulator.java b/src/main/java/gregtech/common/covers/CoverFluidRegulator.java
index f87ab8b9957..77ec669fbea 100644
--- a/src/main/java/gregtech/common/covers/CoverFluidRegulator.java
+++ b/src/main/java/gregtech/common/covers/CoverFluidRegulator.java
@@ -3,7 +3,9 @@
 import gregtech.api.cover.CoverDefinition;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.GTTransferUtils;
+import gregtech.api.util.ITranslatable;
 import gregtech.client.renderer.texture.Textures;
 import gregtech.client.renderer.texture.cube.SimpleSidedCubeRenderer;
 import gregtech.common.covers.filter.FluidFilterContainer;
@@ -26,8 +28,8 @@
 import com.cleanroommc.modularui.screen.UISettings;
 import com.cleanroommc.modularui.utils.Color;
 import com.cleanroommc.modularui.value.sync.EnumSyncValue;
+import com.cleanroommc.modularui.value.sync.IntSyncValue;
 import com.cleanroommc.modularui.value.sync.PanelSyncManager;
-import com.cleanroommc.modularui.value.sync.StringSyncValue;
 import com.cleanroommc.modularui.widgets.layout.Flow;
 import com.cleanroommc.modularui.widgets.textfield.TextFieldWidget;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
@@ -52,26 +54,22 @@ public CoverFluidRegulator(@NotNull CoverDefinition definition, @NotNull Coverab
     @Override
     protected int doTransferFluidsInternal(IFluidHandler myFluidHandler, IFluidHandler fluidHandler,
                                            int transferLimit) {
-        IFluidHandler sourceHandler;
-        IFluidHandler destHandler;
-
-        if (pumpMode == PumpMode.IMPORT) {
-            sourceHandler = fluidHandler;
-            destHandler = myFluidHandler;
-        } else if (pumpMode == PumpMode.EXPORT) {
-            sourceHandler = myFluidHandler;
-            destHandler = fluidHandler;
-        } else {
-            return 0;
-        }
+        return switch (ioMode) {
+            case IMPORT -> doTransferFluidsAny(fluidHandler, myFluidHandler, transferLimit);
+            case EXPORT -> doTransferFluidsAny(myFluidHandler, fluidHandler, transferLimit);
+        };
+    }
+
+    protected int doTransferFluidsAny(IFluidHandler sourceHandler, IFluidHandler destHandler, int transferLimit) {
         return switch (transferMode) {
             case TRANSFER_ANY -> GTTransferUtils.transferFluids(sourceHandler, destHandler, transferLimit,
-                    fluidFilterContainer::test);
-            case KEEP_EXACT -> doKeepExact(transferLimit, sourceHandler, destHandler,
-                    fluidFilterContainer::test,
+                    fluidFilterContainer);
+            case TRANSFER_EXACT -> doTransferExact(transferLimit, sourceHandler, destHandler, fluidFilterContainer,
                     this.fluidFilterContainer.getTransferSize());
-            case TRANSFER_EXACT -> doTransferExact(transferLimit, sourceHandler, destHandler,
-                    fluidFilterContainer::test, this.fluidFilterContainer.getTransferSize());
+            case KEEP_EXACT -> doKeepExact(transferLimit, sourceHandler, destHandler, fluidFilterContainer,
+                    this.fluidFilterContainer.getTransferSize(), true);
+            case RETAIN_EXACT -> doKeepExact(transferLimit, sourceHandler, destHandler, fluidFilterContainer,
+                    this.fluidFilterContainer.getTransferSize(), false);
         };
     }
 
@@ -81,6 +79,7 @@ protected int doTransferExact(int transferLimit, IFluidHandler sourceHandler, IF
         for (IFluidTankProperties tankProperties : sourceHandler.getTankProperties()) {
             FluidStack sourceFluid = tankProperties.getContents();
             if (this.fluidFilterContainer.hasFilter()) {
+                // noinspection DataFlowIssue
                 supplyAmount = this.fluidFilterContainer.getFilter().getTransferLimit(sourceFluid, supplyAmount);
             }
             if (fluidLeftToTransfer < supplyAmount)
@@ -109,7 +108,7 @@ protected int doKeepExact(final int transferLimit,
                               final IFluidHandler sourceHandler,
                               final IFluidHandler destHandler,
                               final Predicate<FluidStack> fluidFilter,
-                              int keepAmount) {
+                              int keepAmount, boolean direction) {
         if (sourceHandler == null || destHandler == null || fluidFilter == null)
             return 0;
 
@@ -124,16 +123,18 @@ protected int doKeepExact(final int transferLimit,
                 break;
 
             if (this.fluidFilterContainer.hasFilter()) {
+                // noinspection DataFlowIssue
                 keepAmount = this.fluidFilterContainer.getFilter().getTransferLimit(fluidStack, keepAmount);
             }
 
             // if fluid needs to be moved to meet the Keep Exact value
             int amountInDest;
-            if ((amountInDest = destFluids.getOrDefault(fluidStack, 0)) < keepAmount) {
+            if (direction ? (amountInDest = destFluids.getOrDefault(fluidStack, 0)) < keepAmount :
+                    (amountInDest = sourceFluids.getOrDefault(fluidStack, 0)) > keepAmount) {
 
                 // move the lesser of the remaining transfer limit and the difference in actual vs keep exact amount
                 int amountToMove = Math.min(transferLimit - transferred,
-                        keepAmount - amountInDest);
+                        direction ? (keepAmount - amountInDest) : (amountInDest - keepAmount));
 
                 // Nothing to do here, try the next fluid.
                 if (amountToMove <= 0)
@@ -250,26 +251,26 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
 
     @Override
     protected Flow createUI(GuiData data, PanelSyncManager syncManager) {
-        var transferMode = new EnumSyncValue<>(TransferMode.class, this::getTransferMode, this::setTransferMode);
-        transferMode.updateCacheFromSource(true);
-        syncManager.syncValue("transfer_mode", transferMode);
-
-        var bucketMode = new EnumSyncValue<>(BucketMode.class, this::getBucketMode, this::setBucketMode);
-        bucketMode.updateCacheFromSource(true);
-        syncManager.syncValue("bucket_mode", bucketMode);
+        EnumSyncValue<TransferMode> transferModeSync = new EnumSyncValue<>(TransferMode.class, this::getTransferMode,
+                this::setTransferMode);
+        EnumSyncValue<BucketMode> bucketModeSync = new EnumSyncValue<>(BucketMode.class, this::getBucketMode,
+                this::setBucketMode);
+        IntSyncValue filterTransferSize = new IntSyncValue(this::getTransferRate, this::setTransferRate);
 
-        var filterTransferSize = new StringSyncValue(this::getStringTransferRate, this::setStringTransferRate);
-        filterTransferSize.updateCacheFromSource(true);
+        syncManager.syncValue("transfer_mode", transferModeSync);
+        syncManager.syncValue("bucket_mode", bucketModeSync);
 
         return super.createUI(data, syncManager)
-                .child(new EnumRowBuilder<>(TransferMode.class)
-                        .value(transferMode)
-                        .lang("cover.generic.transfer_mode")
-                        .overlay(GTGuiTextures.FLUID_TRANSFER_MODE_OVERLAY)
+                .child(EnumButtonRow.builder(transferModeSync)
+                        .rowDescription(IKey.lang("cover.generic.transfer_mode"))
+                        .overlays(GTGuiTextures.FLUID_TRANSFER_MODE_OVERLAY)
+                        .widgetExtras(
+                                (transferMode, toggleButton) -> transferMode.handleTooltip(toggleButton,
+                                        "fluid_regulator"))
                         .build())
-                .child(new EnumRowBuilder<>(BucketMode.class)
-                        .value(bucketMode)
-                        .overlay(IKey.str("kL"), IKey.str("L"))
+                .child(EnumButtonRow.builder(bucketModeSync)
+                        .overlays(IKey.str("kL"), IKey.str("L"))
+                        .widgetExtras(ITranslatable::handleTooltip)
                         .build()
                         .child(new TextFieldWidget().widthRel(0.5f).right(0)
                                 .setEnabledIf(w -> shouldDisplayAmountSlider())
@@ -283,7 +284,7 @@ public int getMaxTransferRate() {
         return switch (this.transferMode) {
             case TRANSFER_ANY -> 1;
             case TRANSFER_EXACT -> maxFluidTransferRate;
-            case KEEP_EXACT -> Integer.MAX_VALUE;
+            case KEEP_EXACT, RETAIN_EXACT -> Integer.MAX_VALUE;
         };
     }
 
@@ -309,7 +310,7 @@ public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
     @Override
     public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         this.transferMode = TransferMode.VALUES[tagCompound.getInteger("TransferMode")];
-        this.fluidFilterContainer.setMaxTransferSize(this.transferMode.maxStackSize);
+        this.fluidFilterContainer.setMaxTransferSize(getMaxTransferRate());
         super.readFromNBT(tagCompound);
         // legacy NBT tag
         if (!tagCompound.hasKey("filterv2") && tagCompound.hasKey("TransferAmount")) {
diff --git a/src/main/java/gregtech/common/covers/CoverFluidVoidingAdvanced.java b/src/main/java/gregtech/common/covers/CoverFluidVoidingAdvanced.java
index b8be41ff6d3..bc6622ea163 100644
--- a/src/main/java/gregtech/common/covers/CoverFluidVoidingAdvanced.java
+++ b/src/main/java/gregtech/common/covers/CoverFluidVoidingAdvanced.java
@@ -3,6 +3,7 @@
 import gregtech.api.cover.CoverDefinition;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.GTTransferUtils;
 import gregtech.client.renderer.texture.Textures;
 
@@ -121,14 +122,12 @@ protected Flow createUI(GuiData data, PanelSyncManager syncManager) {
                 this.voidingMode == VoidingMode.VOID_OVERFLOW);
 
         return super.createUI(data, syncManager)
-                .child(new EnumRowBuilder<>(VoidingMode.class)
-                        .value(voidingMode)
-                        .lang("cover.voiding.voiding_mode")
-                        .overlay(16, GTGuiTextures.VOIDING_MODE_OVERLAY)
+                .child(EnumButtonRow.builder(voidingMode)
+                        .rowDescription(IKey.lang("cover.voiding.voiding_mode"))
+                        .overlays(16, GTGuiTextures.VOIDING_MODE_OVERLAY)
                         .build())
-                .child(new EnumRowBuilder<>(BucketMode.class)
-                        .value(bucketMode)
-                        .overlay(IKey.str("kL"), IKey.str("L"))
+                .child(EnumButtonRow.builder(bucketMode)
+                        .overlays(IKey.str("kL"), IKey.str("L"))
                         .build()
                         .child(transferTextField
                                 .setEnabledIf(w -> this.fluidFilterContainer.showGlobalTransferLimitSlider() &&
@@ -140,7 +139,7 @@ protected Flow createUI(GuiData data, PanelSyncManager syncManager) {
 
     @Override
     protected int getMaxTransferRate() {
-        return getVoidingMode().maxStackSize;
+        return getVoidingMode().getMaxStackSize();
     }
 
     @Override
@@ -171,7 +170,7 @@ public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
     @Override
     public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         this.voidingMode = VoidingMode.VALUES[tagCompound.getInteger("VoidingMode")];
-        this.fluidFilterContainer.setMaxTransferSize(this.voidingMode.maxStackSize);
+        this.fluidFilterContainer.setMaxTransferSize(getMaxTransferRate());
         this.transferAmount = tagCompound.getInteger("TransferAmount");
         super.readFromNBT(tagCompound);
     }
diff --git a/src/main/java/gregtech/common/covers/CoverItemFilter.java b/src/main/java/gregtech/common/covers/CoverItemFilter.java
index b64c75a5ee1..57972446770 100644
--- a/src/main/java/gregtech/common/covers/CoverItemFilter.java
+++ b/src/main/java/gregtech/common/covers/CoverItemFilter.java
@@ -6,8 +6,10 @@
 import gregtech.api.cover.CoverWithUI;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.GTLog;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.ITranslatable;
 import gregtech.client.renderer.texture.cube.SimpleOverlayRenderer;
 import gregtech.common.covers.filter.BaseFilter;
 import gregtech.common.covers.filter.BaseFilterContainer;
@@ -154,10 +156,10 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
                 .size(176, 212).padding(7)
                 .child(CoverWithUI.createTitleRow(getFilterContainer().getFilterStack()).left(4))
                 .child(Flow.column().widthRel(1f).align(Alignment.TopLeft).top(22).coverChildrenHeight()
-                        .child(new EnumRowBuilder<>(ItemFilterMode.class)
-                                .value(filteringMode)
-                                .lang("cover.filter.mode.title")
-                                .overlay(16, GTGuiTextures.FILTER_MODE_OVERLAY)
+                        .child(EnumButtonRow.builder(filteringMode)
+                                .rowDescription(IKey.lang("cover.filter.mode.title"))
+                                .overlays(16, GTGuiTextures.FILTER_MODE_OVERLAY)
+                                .widgetExtras(ITranslatable::handleTooltip)
                                 .build())
                         .child(Flow.row()
                                 .marginBottom(2)
@@ -176,10 +178,17 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
                                         .asWidget()
                                         .height(18)
                                         .alignX(1f)))
-                        .child(new Rectangle().setColor(UI_TEXT_COLOR).asWidget()
-                                .height(1).widthRel(0.95f).margin(0, 4))
-                        .child(getFilter().createWidgets(guiSyncManager).left(0)))
-                .child(SlotGroupWidget.playerInventory(false).bottom(7).left(7));
+                        .child(new Rectangle()
+                                .setColor(UI_TEXT_COLOR)
+                                .asWidget()
+                                .widthRel(0.95f)
+                                .height(1)
+                                .margin(0, 4))
+                        .child(getFilter().createWidgets(guiSyncManager)
+                                .left(0)))
+                .child(SlotGroupWidget.playerInventory(false)
+                        .left(7)
+                        .bottom(7));
     }
 
     @Override
diff --git a/src/main/java/gregtech/common/covers/CoverItemVoiding.java b/src/main/java/gregtech/common/covers/CoverItemVoiding.java
index a69c9da98f8..a607a099fb6 100644
--- a/src/main/java/gregtech/common/covers/CoverItemVoiding.java
+++ b/src/main/java/gregtech/common/covers/CoverItemVoiding.java
@@ -107,8 +107,9 @@ protected boolean createDistributionModeRow() {
     }
 
     @Override
-    public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline,
-                            Cuboid6 plateBox, BlockRenderLayer layer) {
+    public void renderCover(@NotNull CCRenderState renderState, @NotNull Matrix4 translation,
+                            IVertexOperation[] pipeline,
+                            @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer) {
         Textures.ITEM_VOIDING.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
     }
 
@@ -124,7 +125,7 @@ public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexO
     }
 
     @Override
-    public <T> T getCapability(Capability<T> capability, T defaultValue) {
+    public <T> T getCapability(@NotNull Capability<T> capability, T defaultValue) {
         if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
             return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(nullItemHandler);
         }
diff --git a/src/main/java/gregtech/common/covers/CoverItemVoidingAdvanced.java b/src/main/java/gregtech/common/covers/CoverItemVoidingAdvanced.java
index d66e93c1a69..ad219fc9d3f 100644
--- a/src/main/java/gregtech/common/covers/CoverItemVoidingAdvanced.java
+++ b/src/main/java/gregtech/common/covers/CoverItemVoidingAdvanced.java
@@ -3,6 +3,7 @@
 import gregtech.api.cover.CoverDefinition;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.client.renderer.texture.Textures;
 
 import net.minecraft.item.ItemStack;
@@ -17,6 +18,7 @@
 import codechicken.lib.render.pipeline.IVertexOperation;
 import codechicken.lib.vec.Cuboid6;
 import codechicken.lib.vec.Matrix4;
+import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.factory.GuiData;
 import com.cleanroommc.modularui.factory.SidedPosGuiData;
 import com.cleanroommc.modularui.screen.ModularPanel;
@@ -107,12 +109,13 @@ protected Flow createUI(GuiData data, PanelSyncManager guiSyncManager) {
                 this.voidingMode == VoidingMode.VOID_OVERFLOW);
 
         return super.createUI(data, guiSyncManager)
-                .child(new EnumRowBuilder<>(VoidingMode.class)
-                        .value(voidingMode)
-                        .lang("cover.voiding.voiding_mode")
-                        .overlay(16, GTGuiTextures.VOIDING_MODE_OVERLAY)
+                .child(EnumButtonRow.builder(voidingMode)
+                        .rowDescription(IKey.lang("cover.voiding.voiding_mode"))
+                        .overlays(16, GTGuiTextures.VOIDING_MODE_OVERLAY)
                         .build())
-                .child(Flow.row().right(0).coverChildrenHeight()
+                .child(Flow.row()
+                        .right(0)
+                        .coverChildrenHeight()
                         .child(transferTextField
                                 .setEnabledIf(w -> this.itemFilterContainer.showGlobalTransferLimitSlider() &&
                                         this.voidingMode == VoidingMode.VOID_OVERFLOW)
@@ -123,12 +126,13 @@ protected Flow createUI(GuiData data, PanelSyncManager guiSyncManager) {
 
     @Override
     protected int getMaxStackSize() {
-        return getVoidingMode().maxStackSize;
+        return getVoidingMode().getMaxStackSize();
     }
 
     @Override
-    public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline,
-                            Cuboid6 plateBox, BlockRenderLayer layer) {
+    public void renderCover(@NotNull CCRenderState renderState, @NotNull Matrix4 translation,
+                            IVertexOperation[] pipeline,
+                            @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer) {
         Textures.ITEM_VOIDING_ADVANCED.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
     }
 
@@ -155,15 +159,15 @@ public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {
     }
 
     @Override
-    public void writeToNBT(NBTTagCompound tagCompound) {
+    public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
         super.writeToNBT(tagCompound);
         tagCompound.setInteger("VoidMode", voidingMode.ordinal());
     }
 
     @Override
-    public void readFromNBT(NBTTagCompound tagCompound) {
+    public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         this.voidingMode = VoidingMode.VALUES[tagCompound.getInteger("VoidMode")];
-        this.itemFilterContainer.setMaxTransferSize(this.voidingMode.maxStackSize);
+        this.itemFilterContainer.setMaxTransferSize(getMaxStackSize());
         super.readFromNBT(tagCompound);
     }
 }
diff --git a/src/main/java/gregtech/common/covers/CoverMachineController.java b/src/main/java/gregtech/common/covers/CoverMachineController.java
index 8f076c37319..74a0fbd7df4 100644
--- a/src/main/java/gregtech/common/covers/CoverMachineController.java
+++ b/src/main/java/gregtech/common/covers/CoverMachineController.java
@@ -5,6 +5,7 @@
 import gregtech.api.cover.*;
 import gregtech.api.mui.GTGuiTextures;
 import gregtech.api.mui.GTGuis;
+import gregtech.api.mui.util.ValueHelper;
 import gregtech.client.renderer.texture.Textures;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -203,7 +204,7 @@ private Widget<?> modeButton(EnumSyncValue<ControllerMode> syncValue, Controller
         }
 
         return new ToggleButton().size(18)
-                .value(boolValueOf(syncValue, mode))
+                .value(ValueHelper.boolValueOf(syncValue, mode))
                 .overlay(new ItemDrawable(stack).asIcon().size(16))
                 .tooltip(t -> t.addLine(IKey.lang(mode.localeName))
                         .addLine(IKey.str(TextFormatting.GRAY + stack.getDisplayName())));
diff --git a/src/main/java/gregtech/common/covers/CoverPump.java b/src/main/java/gregtech/common/covers/CoverPump.java
index c595a56774a..0b9eda3241f 100644
--- a/src/main/java/gregtech/common/covers/CoverPump.java
+++ b/src/main/java/gregtech/common/covers/CoverPump.java
@@ -10,7 +10,9 @@
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
 import gregtech.api.mui.GTGuis;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.GTTransferUtils;
+import gregtech.api.util.ITranslatable;
 import gregtech.client.renderer.texture.Textures;
 import gregtech.client.renderer.texture.cube.SimpleSidedCubeRenderer;
 import gregtech.common.covers.filter.FluidFilterContainer;
@@ -26,7 +28,6 @@
 import net.minecraft.util.EnumActionResult;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
-import net.minecraft.util.IStringSerializable;
 import net.minecraft.util.ITickable;
 import net.minecraft.util.math.MathHelper;
 import net.minecraftforge.common.capabilities.Capability;
@@ -41,7 +42,7 @@
 import codechicken.lib.render.pipeline.IVertexOperation;
 import codechicken.lib.vec.Cuboid6;
 import codechicken.lib.vec.Matrix4;
-import com.cleanroommc.modularui.api.drawable.IDrawable;
+import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.drawable.DynamicDrawable;
 import com.cleanroommc.modularui.factory.GuiData;
 import com.cleanroommc.modularui.factory.SidedPosGuiData;
@@ -62,7 +63,7 @@ public class CoverPump extends CoverBase implements CoverWithUI, ITickable, ICon
     public final int tier;
     public final int maxFluidTransferRate;
     protected int transferRate;
-    protected PumpMode pumpMode = PumpMode.EXPORT;
+    protected IOMode ioMode = IOMode.EXPORT;
     protected ManualImportExportMode manualImportExportMode = ManualImportExportMode.DISABLED;
     protected DistributionMode distributionMode = DistributionMode.INSERT_FIRST;
     protected int fluidLeftToTransferLastSecond;
@@ -81,42 +82,35 @@ public CoverPump(@NotNull CoverDefinition definition, @NotNull CoverableView cov
         this.fluidFilterContainer = new FluidFilterContainer(this);
     }
 
-    public void setStringTransferRate(String s) {
-        this.fluidFilterContainer.setTransferSize(
-                getBucketMode() == BucketMode.MILLI_BUCKET ?
-                        Integer.parseInt(s) :
-                        Integer.parseInt(s) * 1000);
+    public void setStringTransferRate(String str) {
+        this.fluidFilterContainer.setTransferSize(getBucketMode().toMilliBuckets(str));
     }
 
     public String getStringTransferRate() {
-        return String.valueOf(getBucketMode() == BucketMode.MILLI_BUCKET ?
-                this.fluidFilterContainer.getTransferSize() :
-                this.fluidFilterContainer.getTransferSize() / 1000);
+        return String.valueOf(getBucketMode().fromMilliBuckets(this.fluidFilterContainer.getTransferSize()));
     }
 
     public void setTransferRate(int transferRate) {
-        if (bucketMode == BucketMode.BUCKET) transferRate *= 1000;
-        this.transferRate = MathHelper.clamp(transferRate, 1, maxFluidTransferRate);
+        this.transferRate = MathHelper.clamp(this.bucketMode.toMilliBuckets(transferRate), 1, maxFluidTransferRate);
         markDirty();
     }
 
     public int getTransferRate() {
-        return bucketMode == BucketMode.BUCKET ? transferRate / 1000 : transferRate;
+        return this.bucketMode.fromMilliBuckets(transferRate);
     }
 
     protected void adjustTransferRate(int amount) {
-        amount *= this.bucketMode == BucketMode.BUCKET ? 1000 : 1;
-        setTransferRate(this.transferRate + amount);
+        setTransferRate(this.transferRate + this.bucketMode.toMilliBuckets(amount));
     }
 
-    public void setPumpMode(PumpMode pumpMode) {
-        this.pumpMode = pumpMode;
-        writeCustomData(GregtechDataCodes.UPDATE_COVER_MODE, buf -> buf.writeEnumValue(pumpMode));
+    public void setIoMode(IOMode ioMode) {
+        this.ioMode = ioMode;
+        writeCustomData(GregtechDataCodes.UPDATE_COVER_MODE, buf -> buf.writeEnumValue(ioMode));
         markDirty();
     }
 
-    public PumpMode getPumpMode() {
-        return pumpMode;
+    public IOMode getIoMode() {
+        return ioMode;
     }
 
     public void setBucketMode(BucketMode bucketMode) {
@@ -156,35 +150,33 @@ public void update() {
 
     protected int doTransferFluids(int transferLimit) {
         TileEntity tileEntity = getNeighbor(getAttachedSide());
-        IFluidHandler fluidHandler = tileEntity == null ? null : tileEntity
-                .getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, getAttachedSide().getOpposite());
+        if (tileEntity == null) return 0;
+        IFluidHandler fluidHandler = tileEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY,
+                getAttachedSide().getOpposite());
         IFluidHandler myFluidHandler = getCoverableView().getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY,
                 getAttachedSide());
-        if (fluidHandler == null || myFluidHandler == null) {
-            return 0;
-        }
-        return doTransferFluidsInternal(myFluidHandler, fluidHandler, transferLimit);
+        return fluidHandler != null && myFluidHandler != null ?
+                doTransferFluidsInternal(myFluidHandler, fluidHandler, transferLimit) : 0;
     }
 
     protected int doTransferFluidsInternal(IFluidHandler myFluidHandler, IFluidHandler fluidHandler,
                                            int transferLimit) {
-        if (pumpMode == PumpMode.IMPORT) {
-            return GTTransferUtils.transferFluids(fluidHandler, myFluidHandler, transferLimit,
-                    fluidFilterContainer::test);
-        } else if (pumpMode == PumpMode.EXPORT) {
-            return GTTransferUtils.transferFluids(myFluidHandler, fluidHandler, transferLimit,
-                    fluidFilterContainer::test);
-        }
-        return 0;
+        return switch (ioMode) {
+            case IMPORT -> GTTransferUtils.transferFluids(fluidHandler, myFluidHandler, transferLimit,
+                    fluidFilterContainer);
+            case EXPORT -> GTTransferUtils.transferFluids(myFluidHandler, fluidHandler, transferLimit,
+                    fluidFilterContainer);
+        };
     }
 
-    protected boolean checkInputFluid(FluidStack fluidStack) {
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    protected boolean isFluidAllowed(FluidStack fluidStack) {
         return fluidFilterContainer.test(fluidStack);
     }
 
     @Override
     public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncManager, UISettings settings) {
-        var panel = GTGuis.createPanel(this, 176, 192);
+        ModularPanel panel = GTGuis.createPanel(this, 176, 192);
 
         getFluidFilterContainer().setMaxTransferSize(getMaxTransferRate());
 
@@ -194,27 +186,24 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
     }
 
     protected Flow createUI(GuiData data, PanelSyncManager syncManager) {
-        var manualIOmode = new EnumSyncValue<>(ManualImportExportMode.class,
-                this::getManualImportExportMode, this::setManualImportExportMode);
-
-        var throughput = new IntSyncValue(this::getTransferRate, this::setTransferRate);
-
-        var pumpMode = new EnumSyncValue<>(PumpMode.class, this::getPumpMode, this::setPumpMode);
-
-        syncManager.syncValue("manual_io", manualIOmode);
-        syncManager.syncValue("pump_mode", pumpMode);
-
-        var column = Flow.column().top(24).margin(7, 0)
-                .widthRel(1f).coverChildrenHeight();
-
-        if (createThroughputRow())
-            column.child(Flow.row().coverChildrenHeight()
-                    .marginBottom(2).widthRel(1f)
+        // noinspection DuplicatedCode
+        Flow column = Flow.column()
+                .top(24)
+                .margin(7, 0)
+                .widthRel(1f)
+                .coverChildrenHeight();
+
+        if (createThroughputRow()) {
+            IntSyncValue throughputSync = new IntSyncValue(this::getTransferRate, this::setTransferRate);
+            column.child(Flow.row()
+                    .widthRel(1f)
+                    .marginBottom(2)
+                    .coverChildrenHeight()
                     .child(new ButtonWidget<>()
                             .left(0).width(18)
                             .onMousePressed(mouseButton -> {
-                                int val = throughput.getValue() - getIncrementValue(MouseData.create(mouseButton));
-                                throughput.setValue(val);
+                                int val = throughputSync.getValue() - getIncrementValue(MouseData.create(mouseButton));
+                                throughputSync.setValue(Math.max(val, 1));
                                 return true;
                             })
                             .onUpdateListener(w -> w.overlay(createAdjustOverlay(false))))
@@ -223,40 +212,56 @@ protected Flow createUI(GuiData data, PanelSyncManager syncManager) {
                             .setPostFix(" L/s")
                             .setTextColor(Color.WHITE.darker(1))
                             .setNumbers(1, maxFluidTransferRate)
-                            .value(throughput)
+                            .value(throughputSync)
                             .background(GTGuiTextures.DISPLAY))
                     .child(new ButtonWidget<>()
-                            .right(0).width(18)
+                            .right(0)
+                            .width(18)
                             .onMousePressed(mouseButton -> {
-                                int val = throughput.getValue() + getIncrementValue(MouseData.create(mouseButton));
-                                throughput.setValue(val);
+                                int val = throughputSync.getValue() + getIncrementValue(MouseData.create(mouseButton));
+                                throughputSync.setValue(Math.min(val, maxFluidTransferRate));
                                 return true;
                             })
                             .onUpdateListener(w -> w.overlay(createAdjustOverlay(true)))));
+        }
 
-        if (createFilterRow())
+        if (createFilterRow()) {
             column.child(getFluidFilterContainer().initUI(data, syncManager));
+        }
 
-        if (createManualIOModeRow())
-            column.child(new EnumRowBuilder<>(ManualImportExportMode.class)
-                    .value(manualIOmode)
-                    .lang("cover.generic.manual_io")
-                    .overlay(new IDrawable[] {
-                            new DynamicDrawable(() -> pumpMode.getValue().isImport() ?
-                                    GTGuiTextures.MANUAL_IO_OVERLAY_OUT[0] : GTGuiTextures.MANUAL_IO_OVERLAY_IN[0]),
-                            new DynamicDrawable(() -> pumpMode.getValue().isImport() ?
-                                    GTGuiTextures.MANUAL_IO_OVERLAY_OUT[1] : GTGuiTextures.MANUAL_IO_OVERLAY_IN[1]),
-                            new DynamicDrawable(() -> pumpMode.getValue().isImport() ?
-                                    GTGuiTextures.MANUAL_IO_OVERLAY_OUT[2] : GTGuiTextures.MANUAL_IO_OVERLAY_IN[2])
+        EnumSyncValue<IOMode> pumpModeSync = new EnumSyncValue<>(IOMode.class, this::getIoMode, this::setIoMode);
+        syncManager.syncValue("pump_mode", pumpModeSync);
+
+        if (createManualIOModeRow()) {
+            EnumSyncValue<ManualImportExportMode> manualIOModeSync = new EnumSyncValue<>(ManualImportExportMode.class,
+                    this::getManualImportExportMode, this::setManualImportExportMode);
+            syncManager.syncValue("manual_io", manualIOModeSync);
+
+            // noinspection DuplicatedCode
+            column.child(EnumButtonRow.builder(manualIOModeSync)
+                    .rowDescription(IKey.lang("cover.generic.manual_io"))
+                    .overlays(val -> {
+                        int textureIndex = val.ordinal();
+                        return new DynamicDrawable(() -> {
+                            if (pumpModeSync.getValue().isImport()) {
+                                return GTGuiTextures.MANUAL_IO_OVERLAY_OUT[textureIndex];
+                            } else {
+                                return GTGuiTextures.MANUAL_IO_OVERLAY_IN[textureIndex];
+                            }
+                        });
                     })
+                    .widgetExtras((manualImportExportMode, toggleButton) -> manualImportExportMode
+                            .handleTooltip(toggleButton, "pump"))
                     .build());
+        }
 
-        if (createPumpModeRow())
-            column.child(new EnumRowBuilder<>(PumpMode.class)
-                    .value(pumpMode)
-                    .lang("cover.pump.mode")
-                    .overlay(GTGuiTextures.CONVEYOR_MODE_OVERLAY) // todo pump mode overlays
+        if (createPumpModeRow()) {
+            column.child(EnumButtonRow.builder(pumpModeSync)
+                    .rowDescription(IKey.lang("cover.pump.mode"))
+                    .overlays(GTGuiTextures.CONVEYOR_MODE_OVERLAY) // todo pump mode overlays
+                    .widgetExtras((ioMode, toggleButton) -> ioMode.handleTooltip(toggleButton, "pump"))
                     .build());
+        }
 
         return column;
     }
@@ -294,7 +299,7 @@ protected int getMaxTransferRate() {
     public void readCustomData(int discriminator, @NotNull PacketBuffer buf) {
         super.readCustomData(discriminator, buf);
         if (discriminator == GregtechDataCodes.UPDATE_COVER_MODE) {
-            this.pumpMode = buf.readEnumValue(PumpMode.class);
+            this.ioMode = buf.readEnumValue(IOMode.class);
             scheduleRenderUpdate();
         }
     }
@@ -302,14 +307,14 @@ public void readCustomData(int discriminator, @NotNull PacketBuffer buf) {
     @Override
     public void writeInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.writeInitialSyncData(packetBuffer);
-        packetBuffer.writeByte(pumpMode.ordinal());
+        packetBuffer.writeByte(ioMode.ordinal());
         getFluidFilterContainer().writeInitialSyncData(packetBuffer);
     }
 
     @Override
     public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.readInitialSyncData(packetBuffer);
-        this.pumpMode = PumpMode.VALUES[packetBuffer.readByte()];
+        this.ioMode = IOMode.VALUES[packetBuffer.readByte()];
         getFluidFilterContainer().readInitialSyncData(packetBuffer);
     }
 
@@ -331,7 +336,7 @@ public void onRemoval() {
     @Override
     public void renderCover(@NotNull CCRenderState renderState, @NotNull Matrix4 translation,
                             IVertexOperation[] pipeline, @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer) {
-        if (pumpMode == PumpMode.EXPORT) {
+        if (ioMode.isExport()) {
             Textures.PUMP_OVERLAY.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
         } else {
             Textures.PUMP_OVERLAY_INVERTED.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
@@ -349,10 +354,10 @@ public <T> T getCapability(@NotNull Capability<T> capability, T defaultValue) {
                 this.fluidHandlerWrapper = new CoverableFluidHandlerWrapper(delegate);
             }
             return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(fluidHandlerWrapper);
-        }
-        if (capability == GregtechTileCapabilities.CAPABILITY_CONTROLLABLE) {
+        } else if (capability == GregtechTileCapabilities.CAPABILITY_CONTROLLABLE) {
             return GregtechTileCapabilities.CAPABILITY_CONTROLLABLE.cast(this);
         }
+
         return defaultValue;
     }
 
@@ -370,7 +375,7 @@ public void setWorkingEnabled(boolean isActivationAllowed) {
     public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
         super.writeToNBT(tagCompound);
         tagCompound.setInteger("TransferRate", transferRate);
-        tagCompound.setInteger("PumpMode", pumpMode.ordinal());
+        tagCompound.setInteger("PumpMode", ioMode.ordinal());
         tagCompound.setInteger("DistributionMode", distributionMode.ordinal());
         tagCompound.setBoolean("WorkingAllowed", isWorkingAllowed);
         tagCompound.setInteger("ManualImportExportMode", manualImportExportMode.ordinal());
@@ -382,7 +387,7 @@ public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
     public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         super.readFromNBT(tagCompound);
         this.transferRate = tagCompound.getInteger("TransferRate");
-        this.pumpMode = PumpMode.VALUES[tagCompound.getInteger("PumpMode")];
+        this.ioMode = IOMode.VALUES[tagCompound.getInteger("PumpMode")];
         this.distributionMode = DistributionMode.VALUES[tagCompound.getInteger("DistributionMode")];
         this.isWorkingAllowed = tagCompound.getBoolean("WorkingAllowed");
         this.manualImportExportMode = ManualImportExportMode.VALUES[tagCompound.getInteger("ManualImportExportMode")];
@@ -400,15 +405,15 @@ public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         return Textures.VOLTAGE_CASINGS[this.tier].getSpriteOnSide(SimpleSidedCubeRenderer.RenderSide.SIDE);
     }
 
-    public enum PumpMode implements IStringSerializable, IIOMode {
+    public enum BucketMode implements ITranslatable {
 
-        IMPORT("cover.pump.mode.import"),
-        EXPORT("cover.pump.mode.export");
+        BUCKET("cover.bucket.mode.bucket"),
+        MILLI_BUCKET("cover.bucket.mode.milli_bucket");
 
-        public static final PumpMode[] VALUES = values();
+        public static final BucketMode[] VALUES = values();
         public final String localeName;
 
-        PumpMode(String localeName) {
+        BucketMode(String localeName) {
             this.localeName = localeName;
         }
 
@@ -418,28 +423,42 @@ public String getName() {
             return localeName;
         }
 
-        @Override
-        public boolean isImport() {
-            return this == IMPORT;
+        /**
+         * Convert from milli buckets to this unit. Will return the input value on {@link #MILLI_BUCKET} and divide by
+         * 1000 on {@link #BUCKET}.
+         */
+        public int fromMilliBuckets(int mB) {
+            return switch (this) {
+                case BUCKET -> mB / 1000;
+                case MILLI_BUCKET -> mB;
+            };
         }
-    }
-
-    public enum BucketMode implements IStringSerializable {
 
-        BUCKET("cover.bucket.mode.bucket"),
-        MILLI_BUCKET("cover.bucket.mode.milli_bucket");
+        /**
+         * Convert from milli buckets to this unit. Will return the input value on {@link #MILLI_BUCKET} and multiply by
+         * 1000 on {@link #BUCKET}.
+         */
+        public int toMilliBuckets(int mB) {
+            return switch (this) {
+                case BUCKET -> mB * 1000;
+                case MILLI_BUCKET -> mB;
+            };
+        }
 
-        public static final BucketMode[] VALUES = values();
-        public final String localeName;
+        /**
+         * Parse a string into milli buckets. Will return the string value unmodified on {@link #MILLI_BUCKET} and
+         * multiplied by 1000 on {@link #BUCKET}.
+         */
+        public int toMilliBuckets(@NotNull String val) {
+            return toMilliBuckets(Integer.parseInt(val));
+        }
 
-        BucketMode(String localeName) {
-            this.localeName = localeName;
+        public boolean isFullBuckets() {
+            return this == BUCKET;
         }
 
-        @NotNull
-        @Override
-        public String getName() {
-            return localeName;
+        public boolean isMilliBuckets() {
+            return this == MILLI_BUCKET;
         }
     }
 
@@ -450,41 +469,36 @@ public CoverableFluidHandlerWrapper(@NotNull IFluidHandler delegate) {
         }
 
         @Override
-        public int fill(FluidStack resource, boolean doFill) {
-            if (pumpMode == PumpMode.EXPORT && manualImportExportMode == ManualImportExportMode.DISABLED) {
-                return 0;
-            }
-            if (!checkInputFluid(resource) && manualImportExportMode == ManualImportExportMode.FILTERED) {
-                return 0;
-            }
-            return super.fill(resource, doFill);
+        public int fill(FluidStack stack, boolean doFill) {
+            boolean block = ioMode.isExport() && manualImportExportMode.isDisabled();
+            block |= manualImportExportMode.isFiltered() && !isFluidAllowed(stack);
+
+            return block ? 0 : super.fill(stack, doFill);
         }
 
         @Nullable
         @Override
-        public FluidStack drain(FluidStack resource, boolean doDrain) {
-            if (pumpMode == PumpMode.IMPORT && manualImportExportMode == ManualImportExportMode.DISABLED) {
-                return null;
-            }
-            if (manualImportExportMode == ManualImportExportMode.FILTERED && !checkInputFluid(resource)) {
-                return null;
-            }
-            return super.drain(resource, doDrain);
+        public FluidStack drain(FluidStack stack, boolean doDrain) {
+            boolean block = ioMode.isImport() && manualImportExportMode.isDisabled();
+            block |= manualImportExportMode.isFiltered() && !isFluidAllowed(stack);
+
+            return block ? null : super.drain(stack, doDrain);
         }
 
         @Nullable
         @Override
         public FluidStack drain(int maxDrain, boolean doDrain) {
-            if (pumpMode == PumpMode.IMPORT && manualImportExportMode == ManualImportExportMode.DISABLED) {
+            if (ioMode.isImport() && manualImportExportMode.isDisabled()) {
                 return null;
-            }
-            if (manualImportExportMode == ManualImportExportMode.FILTERED) {
+            } else if (manualImportExportMode.isFiltered()) {
                 FluidStack result = super.drain(maxDrain, false);
-                if (result == null || result.amount <= 0 || !checkInputFluid(result)) {
+                if (result == null || result.amount <= 0 || !isFluidAllowed(result)) {
                     return null;
                 }
+
                 return doDrain ? super.drain(maxDrain, true) : result;
             }
+
             return super.drain(maxDrain, doDrain);
         }
     }
diff --git a/src/main/java/gregtech/common/covers/CoverRoboticArm.java b/src/main/java/gregtech/common/covers/CoverRoboticArm.java
index 159453207e7..1f3a56b162b 100644
--- a/src/main/java/gregtech/common/covers/CoverRoboticArm.java
+++ b/src/main/java/gregtech/common/covers/CoverRoboticArm.java
@@ -4,6 +4,7 @@
 import gregtech.api.cover.CoverDefinition;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.client.renderer.texture.Textures;
 import gregtech.common.covers.filter.SmartItemFilter;
 import gregtech.common.pipelike.itempipe.net.ItemNetHandler;
@@ -19,14 +20,15 @@
 import codechicken.lib.render.pipeline.IVertexOperation;
 import codechicken.lib.vec.Cuboid6;
 import codechicken.lib.vec.Matrix4;
+import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.factory.GuiData;
 import com.cleanroommc.modularui.factory.SidedPosGuiData;
 import com.cleanroommc.modularui.screen.ModularPanel;
 import com.cleanroommc.modularui.screen.UISettings;
 import com.cleanroommc.modularui.utils.Color;
 import com.cleanroommc.modularui.value.sync.EnumSyncValue;
+import com.cleanroommc.modularui.value.sync.IntSyncValue;
 import com.cleanroommc.modularui.value.sync.PanelSyncManager;
-import com.cleanroommc.modularui.value.sync.StringSyncValue;
 import com.cleanroommc.modularui.widgets.layout.Flow;
 import com.cleanroommc.modularui.widgets.textfield.TextFieldWidget;
 import org.jetbrains.annotations.NotNull;
@@ -36,20 +38,20 @@
 
 public class CoverRoboticArm extends CoverConveyor {
 
-    protected TransferMode transferMode;
+    protected TransferMode transferMode = TransferMode.TRANSFER_ANY;
     protected int itemsTransferBuffered;
 
     public CoverRoboticArm(@NotNull CoverDefinition definition, @NotNull CoverableView coverableView,
                            @NotNull EnumFacing attachedSide, int tier, int itemsPerSecond) {
         super(definition, coverableView, attachedSide, tier, itemsPerSecond);
-        this.transferMode = TransferMode.TRANSFER_ANY;
         this.itemFilterContainer.setMaxTransferSize(1);
     }
 
     @Override
-    public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline,
-                            Cuboid6 plateBox, BlockRenderLayer layer) {
-        if (conveyorMode == ConveyorMode.EXPORT) {
+    public void renderCover(@NotNull CCRenderState renderState, @NotNull Matrix4 translation,
+                            IVertexOperation[] pipeline,
+                            @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer) {
+        if (ioMode.isExport()) {
             Textures.ARM_OVERLAY.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
         } else {
             Textures.ARM_OVERLAY_INVERTED.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation);
@@ -58,18 +60,14 @@ public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexO
 
     @Override
     protected int doTransferItems(IItemHandler itemHandler, IItemHandler myItemHandler, int maxTransferAmount) {
-        if (conveyorMode == ConveyorMode.EXPORT && itemHandler instanceof ItemNetHandler &&
-                transferMode == TransferMode.KEEP_EXACT) {
-            return 0;
-        }
-        if (conveyorMode == ConveyorMode.IMPORT && myItemHandler instanceof ItemNetHandler &&
-                transferMode == TransferMode.KEEP_EXACT) {
-            return 0;
-        }
-        return switch (transferMode) {
+        boolean block = ioMode.isExport() && transferMode.isKeepExact() && itemHandler instanceof ItemNetHandler;
+        block |= ioMode.isImport() && transferMode.isKeepExact() && myItemHandler instanceof ItemNetHandler;
+
+        return block ? 0 : switch (transferMode) {
             case TRANSFER_ANY -> doTransferItemsAny(itemHandler, myItemHandler, maxTransferAmount);
             case TRANSFER_EXACT -> doTransferExact(itemHandler, myItemHandler, maxTransferAmount);
-            case KEEP_EXACT -> doKeepExact(itemHandler, myItemHandler, maxTransferAmount);
+            case KEEP_EXACT -> doKeepExact(itemHandler, myItemHandler, maxTransferAmount, true);
+            case RETAIN_EXACT -> doKeepExact(itemHandler, myItemHandler, maxTransferAmount, false);
         };
     }
 
@@ -122,7 +120,8 @@ protected int doTransferExact(IItemHandler itemHandler, IItemHandler myItemHandl
         return Math.min(itemsTransferred, maxTransferAmount);
     }
 
-    protected int doKeepExact(IItemHandler itemHandler, IItemHandler myItemHandler, int maxTransferAmount) {
+    protected int doKeepExact(IItemHandler itemHandler, IItemHandler myItemHandler, int maxTransferAmount,
+                              boolean direction) {
         Map<Integer, GroupItemInfo> currentItemAmount = doCountDestinationInventoryItemsByMatchIndex(itemHandler,
                 myItemHandler);
         Map<Integer, GroupItemInfo> sourceItemAmounts = doCountDestinationInventoryItemsByMatchIndex(myItemHandler,
@@ -145,12 +144,20 @@ protected int doKeepExact(IItemHandler itemHandler, IItemHandler myItemHandler,
             }
 
             int itemAmount = 0;
-            if (currentItemAmount.containsKey(filterSlotIndex)) {
-                GroupItemInfo destItemInfo = currentItemAmount.get(filterSlotIndex);
-                itemAmount = destItemInfo.totalCount;
+            if (direction) {
+                if (currentItemAmount.containsKey(filterSlotIndex)) {
+                    GroupItemInfo destItemInfo = currentItemAmount.get(filterSlotIndex);
+                    itemAmount = destItemInfo.totalCount;
+                }
+            } else {
+                if (sourceItemAmounts.containsKey(filterSlotIndex)) {
+                    GroupItemInfo sourceItemInfo = sourceItemAmounts.get(filterSlotIndex);
+                    itemAmount = sourceItemInfo.totalCount;
+                }
             }
-            if (itemAmount < itemToKeepAmount) {
-                sourceInfo.totalCount = itemToKeepAmount - itemAmount;
+
+            if (direction ? (itemAmount < itemToKeepAmount) : (itemAmount > itemToKeepAmount)) {
+                sourceInfo.totalCount = direction ? (itemToKeepAmount - itemAmount) : (itemAmount - itemToKeepAmount);
             } else {
                 iterator.remove();
             }
@@ -174,7 +181,7 @@ public void setTransferMode(TransferMode transferMode) {
         if (this.transferMode != transferMode) {
             this.transferMode = transferMode;
             this.getCoverableView().markDirty();
-            this.itemFilterContainer.setMaxTransferSize(transferMode.maxStackSize);
+            this.itemFilterContainer.setMaxTransferSize(getMaxStackSize());
             writeCustomData(GregtechDataCodes.UPDATE_TRANSFER_MODE,
                     buffer -> buffer.writeByte(this.transferMode.ordinal()));
         }
@@ -185,10 +192,7 @@ public TransferMode getTransferMode() {
     }
 
     private boolean shouldDisplayAmountSlider() {
-        if (transferMode == TransferMode.TRANSFER_ANY) {
-            return false;
-        }
-        return itemFilterContainer.showGlobalTransferLimitSlider();
+        return !transferMode.isTransferAny() && itemFilterContainer.showGlobalTransferLimitSlider();
     }
 
     @Override
@@ -198,23 +202,26 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
 
     @Override
     protected Flow createUI(GuiData data, PanelSyncManager guiSyncManager) {
-        EnumSyncValue<TransferMode> transferMode = new EnumSyncValue<>(TransferMode.class, this::getTransferMode,
+        EnumSyncValue<TransferMode> transferModeSync = new EnumSyncValue<>(TransferMode.class, this::getTransferMode,
                 this::setTransferMode);
-        guiSyncManager.syncValue("transfer_mode", transferMode);
+        IntSyncValue filterTransferSize = new IntSyncValue(this.itemFilterContainer::getTransferSize,
+                this.itemFilterContainer::setTransferSize);
 
-        var filterTransferSize = new StringSyncValue(
-                () -> String.valueOf(this.itemFilterContainer.getTransferSize()),
-                s -> this.itemFilterContainer.setTransferSize(Integer.parseInt(s)));
-        filterTransferSize.updateCacheFromSource(true);
+        guiSyncManager.syncValue("transfer_mode", transferModeSync);
 
         return super.createUI(data, guiSyncManager)
-                .child(new EnumRowBuilder<>(TransferMode.class)
-                        .value(transferMode)
-                        .lang("cover.generic.transfer_mode")
-                        .overlay(GTGuiTextures.TRANSFER_MODE_OVERLAY)
+                .child(EnumButtonRow.builder(transferModeSync)
+                        .rowDescription(IKey.lang("cover.generic.transfer_mode"))
+                        .overlays(GTGuiTextures.TRANSFER_MODE_OVERLAY)
+                        .widgetExtras(
+                                (transferMode, toggleButton) -> transferMode.handleTooltip(toggleButton, "robotic_arm"))
                         .build())
-                .child(Flow.row().right(0).coverChildrenHeight()
-                        .child(new TextFieldWidget().widthRel(0.5f).right(0)
+                .child(Flow.row()
+                        .right(0)
+                        .coverChildrenHeight()
+                        .child(new TextFieldWidget()
+                                .right(0)
+                                .widthRel(0.5f)
                                 .setEnabledIf(w -> shouldDisplayAmountSlider())
                                 .setNumbers(0, Integer.MAX_VALUE)
                                 .value(filterTransferSize)
@@ -223,7 +230,11 @@ protected Flow createUI(GuiData data, PanelSyncManager guiSyncManager) {
 
     @Override
     protected int getMaxStackSize() {
-        return getTransferMode().maxStackSize;
+        return switch (transferMode) {
+            case TRANSFER_ANY -> 1;
+            case TRANSFER_EXACT -> 1024;
+            case KEEP_EXACT, RETAIN_EXACT -> Integer.MAX_VALUE;
+        };
     }
 
     @Override
@@ -236,7 +247,7 @@ public void writeInitialSyncData(@NotNull PacketBuffer packetBuffer) {
     public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.readInitialSyncData(packetBuffer);
         this.transferMode = TransferMode.VALUES[packetBuffer.readByte()];
-        this.itemFilterContainer.setMaxTransferSize(this.transferMode.maxStackSize);
+        this.itemFilterContainer.setMaxTransferSize(getMaxStackSize());
     }
 
     @Override
@@ -244,20 +255,20 @@ public void readCustomData(int discriminator, @NotNull PacketBuffer buf) {
         super.readCustomData(discriminator, buf);
         if (discriminator == GregtechDataCodes.UPDATE_TRANSFER_MODE) {
             this.transferMode = TransferMode.VALUES[buf.readByte()];
-            this.itemFilterContainer.setMaxTransferSize(this.transferMode.maxStackSize);
+            this.itemFilterContainer.setMaxTransferSize(getMaxStackSize());
         }
     }
 
     @Override
-    public void writeToNBT(NBTTagCompound tagCompound) {
+    public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
         super.writeToNBT(tagCompound);
         tagCompound.setInteger("TransferMode", transferMode.ordinal());
     }
 
     @Override
-    public void readFromNBT(NBTTagCompound tagCompound) {
+    public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         this.transferMode = TransferMode.VALUES[tagCompound.getInteger("TransferMode")];
-        this.itemFilterContainer.setMaxTransferSize(this.transferMode.maxStackSize);
+        this.itemFilterContainer.setMaxTransferSize(getMaxStackSize());
         super.readFromNBT(tagCompound);
     }
 }
diff --git a/src/main/java/gregtech/common/covers/DistributionMode.java b/src/main/java/gregtech/common/covers/DistributionMode.java
index c704d045b18..1aa6470a665 100644
--- a/src/main/java/gregtech/common/covers/DistributionMode.java
+++ b/src/main/java/gregtech/common/covers/DistributionMode.java
@@ -1,17 +1,17 @@
 package gregtech.common.covers;
 
-import net.minecraft.util.IStringSerializable;
+import gregtech.api.util.ITranslatable;
 
 import org.jetbrains.annotations.NotNull;
 
-public enum DistributionMode implements IStringSerializable {
+public enum DistributionMode implements ITranslatable {
 
     ROUND_ROBIN_GLOBAL("cover.conveyor.distribution.round_robin_enhanced"),
     ROUND_ROBIN_PRIO("cover.conveyor.distribution.round_robin"),
     INSERT_FIRST("cover.conveyor.distribution.first_insert");
 
     public static final DistributionMode[] VALUES = values();
-    public final String localeName;
+    private final String localeName;
 
     DistributionMode(String localeName) {
         this.localeName = localeName;
@@ -22,4 +22,16 @@ public enum DistributionMode implements IStringSerializable {
     public String getName() {
         return localeName;
     }
+
+    public boolean isRoundRobinGlobal() {
+        return this == ROUND_ROBIN_GLOBAL;
+    }
+
+    public boolean isRoundRobinPriority() {
+        return this == ROUND_ROBIN_PRIO;
+    }
+
+    public boolean isInsertFirst() {
+        return this == INSERT_FIRST;
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/FluidFilterMode.java b/src/main/java/gregtech/common/covers/FluidFilterMode.java
index e26c6192e8b..58db850c55a 100644
--- a/src/main/java/gregtech/common/covers/FluidFilterMode.java
+++ b/src/main/java/gregtech/common/covers/FluidFilterMode.java
@@ -1,20 +1,23 @@
 package gregtech.common.covers;
 
-import net.minecraft.util.IStringSerializable;
+import gregtech.api.util.ITranslatable;
 
-public enum FluidFilterMode implements IStringSerializable {
+import org.jetbrains.annotations.NotNull;
+
+public enum FluidFilterMode implements ITranslatable {
 
     FILTER_FILL("cover.fluid_filter.mode.filter_fill"),
     FILTER_DRAIN("cover.fluid_filter.mode.filter_drain"),
     FILTER_BOTH("cover.fluid_filter.mode.filter_both");
 
     public static final FluidFilterMode[] VALUES = values();
-    public final String localeName;
+    private final String localeName;
 
     FluidFilterMode(String localeName) {
         this.localeName = localeName;
     }
 
+    @NotNull
     @Override
     public String getName() {
         return this.localeName;
diff --git a/src/main/java/gregtech/common/covers/IIOMode.java b/src/main/java/gregtech/common/covers/IIOMode.java
deleted file mode 100644
index 02afdc15fa4..00000000000
--- a/src/main/java/gregtech/common/covers/IIOMode.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package gregtech.common.covers;
-
-/**
- * Interface for combining Robot Arm and Pump I/O modes into one type
- */
-public interface IIOMode {
-
-    boolean isImport();
-}
diff --git a/src/main/java/gregtech/common/covers/IOMode.java b/src/main/java/gregtech/common/covers/IOMode.java
new file mode 100644
index 00000000000..d04b8bd4fb4
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/IOMode.java
@@ -0,0 +1,36 @@
+package gregtech.common.covers;
+
+import gregtech.api.util.ITranslatable;
+
+import org.jetbrains.annotations.NotNull;
+
+public enum IOMode implements ITranslatable {
+
+    IMPORT("cover.%s.mode.import"),
+    EXPORT("cover.%s.mode.export");
+
+    public static final IOMode[] VALUES = values();
+    public final String localeName;
+
+    IOMode(String localeName) {
+        this.localeName = localeName;
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return getName("universal");
+    }
+
+    @Override
+    public @NotNull String getName(@NotNull String key) {
+        return String.format(localeName, key);
+    }
+
+    public boolean isImport() {
+        return this == IMPORT;
+    }
+
+    public boolean isExport() {
+        return this == EXPORT;
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/ItemFilterMode.java b/src/main/java/gregtech/common/covers/ItemFilterMode.java
index 6d612915161..26c5a1a3329 100644
--- a/src/main/java/gregtech/common/covers/ItemFilterMode.java
+++ b/src/main/java/gregtech/common/covers/ItemFilterMode.java
@@ -1,22 +1,37 @@
 package gregtech.common.covers;
 
-import net.minecraft.util.IStringSerializable;
+import gregtech.api.util.ITranslatable;
 
-public enum ItemFilterMode implements IStringSerializable {
+import org.jetbrains.annotations.NotNull;
+
+public enum ItemFilterMode implements ITranslatable {
 
     FILTER_INSERT("cover.filter.mode.filter_insert"),
     FILTER_EXTRACT("cover.filter.mode.filter_extract"),
     FILTER_BOTH("cover.filter.mode.filter_both");
 
     public static final ItemFilterMode[] VALUES = values();
-    public final String localeName;
+    private final String localeName;
 
     ItemFilterMode(String localeName) {
         this.localeName = localeName;
     }
 
+    @NotNull
     @Override
     public String getName() {
         return this.localeName;
     }
+
+    public boolean isFilterInsert() {
+        return this == FILTER_INSERT;
+    }
+
+    public boolean isFilterExtract() {
+        return this == FILTER_EXTRACT;
+    }
+
+    public boolean isFilterBoth() {
+        return this == FILTER_BOTH;
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/ManualImportExportMode.java b/src/main/java/gregtech/common/covers/ManualImportExportMode.java
index df3942d7163..2f2c9f2a44c 100644
--- a/src/main/java/gregtech/common/covers/ManualImportExportMode.java
+++ b/src/main/java/gregtech/common/covers/ManualImportExportMode.java
@@ -1,17 +1,19 @@
 package gregtech.common.covers;
 
-import net.minecraft.util.IStringSerializable;
+import gregtech.api.util.ITranslatable;
 
+import com.cleanroommc.modularui.api.drawable.IKey;
+import com.cleanroommc.modularui.api.widget.ITooltip;
 import org.jetbrains.annotations.NotNull;
 
-public enum ManualImportExportMode implements IStringSerializable {
+public enum ManualImportExportMode implements ITranslatable {
 
-    DISABLED("cover.universal.manual_import_export.mode.disabled"),
-    FILTERED("cover.universal.manual_import_export.mode.filtered"),
-    UNFILTERED("cover.universal.manual_import_export.mode.unfiltered");
+    DISABLED("cover.%s.manual_import_export.mode.disabled"),
+    FILTERED("cover.%s.manual_import_export.mode.filtered"),
+    UNFILTERED("cover.%s.manual_import_export.mode.unfiltered");
 
     public static final ManualImportExportMode[] VALUES = values();
-    public final String localeName;
+    private final String localeName;
 
     ManualImportExportMode(String localeName) {
         this.localeName = localeName;
@@ -20,6 +22,29 @@ public enum ManualImportExportMode implements IStringSerializable {
     @NotNull
     @Override
     public String getName() {
-        return localeName;
+        return getName("universal");
+    }
+
+    @Override
+    public @NotNull String getName(@NotNull String key) {
+        return String.format(localeName, key);
+    }
+
+    @Override
+    public void handleTooltip(@NotNull ITooltip<?> tooltip, @NotNull String key) {
+        tooltip.addTooltipLine(getKey());
+        tooltip.addTooltipLine(IKey.lang(getName(key) + ".description"));
+    }
+
+    public boolean isDisabled() {
+        return this == DISABLED;
+    }
+
+    public boolean isFiltered() {
+        return this == FILTERED;
+    }
+
+    public boolean isUnfiltered() {
+        return this == UNFILTERED;
     }
 }
diff --git a/src/main/java/gregtech/common/covers/TransferMode.java b/src/main/java/gregtech/common/covers/TransferMode.java
index 2f278c88ce4..3d379fd1dba 100644
--- a/src/main/java/gregtech/common/covers/TransferMode.java
+++ b/src/main/java/gregtech/common/covers/TransferMode.java
@@ -1,27 +1,55 @@
 package gregtech.common.covers;
 
-import net.minecraft.util.IStringSerializable;
+import gregtech.api.util.ITranslatable;
 
+import com.cleanroommc.modularui.api.drawable.IKey;
+import com.cleanroommc.modularui.api.widget.ITooltip;
 import org.jetbrains.annotations.NotNull;
 
-public enum TransferMode implements IStringSerializable {
+public enum TransferMode implements ITranslatable {
 
-    TRANSFER_ANY("cover.robotic_arm.transfer_mode.transfer_any", 1),
-    TRANSFER_EXACT("cover.robotic_arm.transfer_mode.transfer_exact", 1024),
-    KEEP_EXACT("cover.robotic_arm.transfer_mode.keep_exact", Integer.MAX_VALUE);
+    TRANSFER_ANY("cover.%s.transfer_mode.transfer_any"),
+    TRANSFER_EXACT("cover.%s.transfer_mode.transfer_exact"),
+    KEEP_EXACT("cover.%s.transfer_mode.keep_exact"),
+    RETAIN_EXACT("cover.%s.transfer_mode.retain_exact");
 
     public static final TransferMode[] VALUES = values();
-    public final String localeName;
-    public final int maxStackSize;
+    private final String localeName;
 
-    TransferMode(String localeName, int maxStackSize) {
+    TransferMode(String localeName) {
         this.localeName = localeName;
-        this.maxStackSize = maxStackSize;
     }
 
-    @NotNull
     @Override
-    public String getName() {
-        return localeName;
+    public @NotNull String getName() {
+        throw new UnsupportedOperationException(
+                "TransferMode#getName() called, this wouldn't produce any usable output, use the keyed getName instead!");
+    }
+
+    @Override
+    public @NotNull String getName(@NotNull String key) {
+        return String.format(localeName, key);
+    }
+
+    @Override
+    public void handleTooltip(@NotNull ITooltip<?> tooltip, @NotNull String key) {
+        tooltip.addTooltipLine(getKey(key));
+        tooltip.addTooltipLine(IKey.lang(getName(key) + ".description"));
+    }
+
+    public boolean isTransferAny() {
+        return this == TRANSFER_ANY;
+    }
+
+    public boolean isTransferExact() {
+        return this == TRANSFER_EXACT;
+    }
+
+    public boolean isKeepExact() {
+        return this == KEEP_EXACT;
+    }
+
+    public boolean isRetainExact() {
+        return this == RETAIN_EXACT;
     }
 }
diff --git a/src/main/java/gregtech/common/covers/VoidingMode.java b/src/main/java/gregtech/common/covers/VoidingMode.java
index b7e85666f65..dfcd27e7328 100644
--- a/src/main/java/gregtech/common/covers/VoidingMode.java
+++ b/src/main/java/gregtech/common/covers/VoidingMode.java
@@ -1,17 +1,17 @@
 package gregtech.common.covers;
 
-import net.minecraft.util.IStringSerializable;
+import gregtech.api.util.ITranslatable;
 
 import org.jetbrains.annotations.NotNull;
 
-public enum VoidingMode implements IStringSerializable {
+public enum VoidingMode implements ITranslatable {
 
     VOID_ANY("cover.voiding.voiding_mode.void_any", 1),
     VOID_OVERFLOW("cover.voiding.voiding_mode.void_overflow", Integer.MAX_VALUE);
 
     public static final VoidingMode[] VALUES = values();
-    public final String localeName;
-    public final int maxStackSize;
+    private final String localeName;
+    private final int maxStackSize;
 
     VoidingMode(String localeName, int maxStackSize) {
         this.localeName = localeName;
@@ -23,4 +23,16 @@ public enum VoidingMode implements IStringSerializable {
     public String getName() {
         return localeName;
     }
+
+    public int getMaxStackSize() {
+        return maxStackSize;
+    }
+
+    public boolean isVoidingAny() {
+        return this == VOID_ANY;
+    }
+
+    public boolean isVoidingOverflow() {
+        return this == VOID_OVERFLOW;
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/ender/CoverEnderFluidLink.java b/src/main/java/gregtech/common/covers/ender/CoverEnderFluidLink.java
index 0a3f14a990b..81dcd5940ee 100644
--- a/src/main/java/gregtech/common/covers/ender/CoverEnderFluidLink.java
+++ b/src/main/java/gregtech/common/covers/ender/CoverEnderFluidLink.java
@@ -6,13 +6,14 @@
 import gregtech.api.cover.CoverWithUI;
 import gregtech.api.cover.CoverableView;
 import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.widget.EnumButtonRow;
 import gregtech.api.util.FluidTankSwitchShim;
 import gregtech.api.util.GTTransferUtils;
 import gregtech.api.util.virtualregistry.EntryTypes;
 import gregtech.api.util.virtualregistry.VirtualEnderRegistry;
 import gregtech.api.util.virtualregistry.entries.VirtualTank;
 import gregtech.client.renderer.texture.Textures;
-import gregtech.common.covers.CoverPump;
+import gregtech.common.covers.IOMode;
 import gregtech.common.covers.filter.FluidFilterContainer;
 import gregtech.common.mui.widget.GTFluidSlot;
 
@@ -28,6 +29,7 @@
 import codechicken.lib.render.pipeline.IVertexOperation;
 import codechicken.lib.vec.Cuboid6;
 import codechicken.lib.vec.Matrix4;
+import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.api.widget.IWidget;
 import com.cleanroommc.modularui.factory.GuiData;
 import com.cleanroommc.modularui.value.sync.EnumSyncValue;
@@ -42,7 +44,7 @@ public class CoverEnderFluidLink extends CoverAbstractEnderLink<VirtualTank>
 
     public static final int TRANSFER_RATE = 8000; // mB/t
 
-    protected CoverPump.PumpMode pumpMode = CoverPump.PumpMode.IMPORT;
+    protected IOMode pumpMode = IOMode.IMPORT;
     private final FluidTankSwitchShim linkedTank;
     protected final FluidFilterContainer fluidFilter;
 
@@ -101,19 +103,19 @@ protected void transferFluids() {
         IFluidHandler fluidHandler = getCoverableView().getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY,
                 getAttachedSide());
         if (fluidHandler == null) return;
-        if (pumpMode == CoverPump.PumpMode.IMPORT) {
+        if (pumpMode == IOMode.IMPORT) {
             GTTransferUtils.transferFluids(fluidHandler, activeEntry, TRANSFER_RATE, fluidFilter::test);
-        } else if (pumpMode == CoverPump.PumpMode.EXPORT) {
+        } else if (pumpMode == IOMode.EXPORT) {
             GTTransferUtils.transferFluids(activeEntry, fluidHandler, TRANSFER_RATE, fluidFilter::test);
         }
     }
 
-    public void setPumpMode(CoverPump.PumpMode pumpMode) {
+    public void setPumpMode(IOMode pumpMode) {
         this.pumpMode = pumpMode;
         markDirty();
     }
 
-    public CoverPump.PumpMode getPumpMode() {
+    public IOMode getPumpMode() {
         return pumpMode;
     }
 
@@ -146,33 +148,32 @@ protected IWidget createEntrySlot() {
     protected Flow createWidgets(GuiData data, PanelSyncManager syncManager) {
         getFluidFilterContainer().setMaxTransferSize(1);
 
-        var pumpMode = new EnumSyncValue<>(CoverPump.PumpMode.class, this::getPumpMode, this::setPumpMode);
+        EnumSyncValue<IOMode> pumpMode = new EnumSyncValue<>(IOMode.class, this::getPumpMode, this::setPumpMode);
         syncManager.syncValue("pump_mode", pumpMode);
 
         return super.createWidgets(data, syncManager)
                 .child(getFluidFilterContainer().initUI(data, syncManager))
-                .child(new EnumRowBuilder<>(CoverPump.PumpMode.class)
-                        .value(pumpMode)
-                        .overlay(GTGuiTextures.CONVEYOR_MODE_OVERLAY)
-                        .lang("cover.pump.mode")
+                .child(EnumButtonRow.builder(pumpMode)
+                        .overlays(GTGuiTextures.CONVEYOR_MODE_OVERLAY)
+                        .rowDescription(IKey.lang("cover.pump.mode"))
                         .build());
     }
 
     @Override
-    public void writeToNBT(NBTTagCompound tagCompound) {
+    public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
         super.writeToNBT(tagCompound);
         tagCompound.setInteger("PumpMode", pumpMode.ordinal());
         tagCompound.setTag("Filter", fluidFilter.serializeNBT());
     }
 
     @Override
-    public void readFromNBT(NBTTagCompound tagCompound) {
+    public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         super.readFromNBT(tagCompound);
-        this.pumpMode = CoverPump.PumpMode.values()[tagCompound.getInteger("PumpMode")];
+        this.pumpMode = IOMode.values()[tagCompound.getInteger("PumpMode")];
         this.fluidFilter.deserializeNBT(tagCompound.getCompoundTag("Filter"));
     }
 
-    public <T> T getCapability(Capability<T> capability, T defaultValue) {
+    public <T> T getCapability(@NotNull Capability<T> capability, T defaultValue) {
         if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
             return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(this.activeEntry);
         }
diff --git a/src/main/java/gregtech/common/covers/filter/BaseFilter.java b/src/main/java/gregtech/common/covers/filter/BaseFilter.java
index c5591a5021b..c0f155591f0 100644
--- a/src/main/java/gregtech/common/covers/filter/BaseFilter.java
+++ b/src/main/java/gregtech/common/covers/filter/BaseFilter.java
@@ -52,7 +52,7 @@ public BaseFilterReader getFilterReader() {
 
         @Override
         public FilterType getType() {
-            return FilterType.ITEM;
+            return FilterType.ERROR;
         }
     };
     protected IDirtyNotifiable dirtyNotifiable;
@@ -65,11 +65,13 @@ public final ItemStack getContainerStack() {
 
     public static @NotNull BaseFilter getFilterFromStack(ItemStack stack) {
         if (stack.getItem() instanceof MetaItem<?>metaItem) {
-            var metaValueItem = metaItem.getItem(stack);
-            var factory = metaValueItem == null ? null : metaValueItem.getFilterFactory();
-            if (factory != null)
+            MetaItem<?>.MetaValueItem metaValueItem = metaItem.getItem(stack);
+            Factory factory = metaValueItem == null ? null : metaValueItem.getFilterFactory();
+            if (factory != null) {
                 return factory.create(stack);
+            }
         }
+
         return ERROR_FILTER;
     }
 
diff --git a/src/main/java/gregtech/common/covers/filter/BaseFilterContainer.java b/src/main/java/gregtech/common/covers/filter/BaseFilterContainer.java
index 8c050a2e394..e8ea996016a 100644
--- a/src/main/java/gregtech/common/covers/filter/BaseFilterContainer.java
+++ b/src/main/java/gregtech/common/covers/filter/BaseFilterContainer.java
@@ -1,6 +1,7 @@
 package gregtech.common.covers.filter;
 
 import gregtech.api.cover.CoverWithUI;
+import gregtech.api.cover.registry.CoverRegistry;
 import gregtech.api.mui.GTGuiTextures;
 import gregtech.api.util.IDirtyNotifiable;
 import gregtech.api.util.ItemStackHashStrategy;
@@ -15,6 +16,7 @@
 import com.cleanroommc.modularui.api.drawable.IKey;
 import com.cleanroommc.modularui.api.widget.IWidget;
 import com.cleanroommc.modularui.drawable.GuiTextures;
+import com.cleanroommc.modularui.drawable.ItemDrawable;
 import com.cleanroommc.modularui.factory.GuiData;
 import com.cleanroommc.modularui.network.NetworkUtils;
 import com.cleanroommc.modularui.utils.Alignment;
@@ -28,8 +30,9 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Predicate;
 
-public abstract class BaseFilterContainer extends ItemStackHandler {
+public abstract class BaseFilterContainer<T> extends ItemStackHandler implements Predicate<T> {
 
     private int maxTransferSize = 1;
     private int transferSize;
@@ -42,18 +45,18 @@ protected BaseFilterContainer(IDirtyNotifiable dirtyNotifiable) {
         this.dirtyNotifiable = dirtyNotifiable;
     }
 
-    public boolean test(Object toTest) {
+    public boolean test(T toTest) {
         return !hasFilter() || getFilter().test(toTest);
     }
 
-    public MatchResult match(Object toMatch) {
+    public MatchResult match(T toMatch) {
         if (!hasFilter())
             return MatchResult.create(true, toMatch, -1);
 
         return getFilter().match(toMatch);
     }
 
-    public int getTransferLimit(Object stack) {
+    public int getTransferLimit(T stack) {
         if (!hasFilter() || isBlacklistFilter()) {
             return getTransferSize();
         }
@@ -95,21 +98,26 @@ public boolean isItemValid(int slot, @NotNull ItemStack stack) {
         return isItemValid(stack);
     }
 
-    protected abstract boolean isItemValid(ItemStack stack);
+    protected boolean isItemValid(ItemStack stack) {
+        BaseFilter filter = BaseFilter.getFilterFromStack(stack);
+        return filter.getType() == getFilterType();
+    }
 
     protected abstract @NotNull IKey getFilterKey();
 
+    protected abstract @NotNull IFilter.FilterType getFilterType();
+
     @Override
     public @NotNull ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
         if (!isItemValid(stack)) return stack;
-        var remainder = super.insertItem(slot, stack, simulate);
+        ItemStack remainder = super.insertItem(slot, stack, simulate);
         if (!simulate) setFilter(BaseFilter.getFilterFromStack(stack));
         return remainder;
     }
 
     @Override
     public @NotNull ItemStack extractItem(int slot, int amount, boolean simulate) {
-        var extracted = super.extractItem(slot, amount, simulate);
+        ItemStack extracted = super.extractItem(slot, amount, simulate);
         if (!extracted.isEmpty()) {
             setFilter(null);
         }
@@ -228,9 +236,13 @@ public IWidget initUI(GuiData data, PanelSyncManager manager) {
         });
         ItemStackHashStrategy strategy = ItemStackHashStrategy.comparingItemDamageCount();
 
-        return Flow.row().coverChildrenHeight()
-                .marginBottom(2).widthRel(1f)
+        return Flow.row()
+                .coverChildrenHeight()
+                .widthRel(1f)
+                .marginBottom(2)
                 .child(new ItemSlot()
+                        .marginRight(2)
+                        .size(18)
                         .slot(SyncHandlers.itemSlot(this, 0)
                                 .filter(this::isItemValid)
                                 .singletonSlotGroup(101)
@@ -246,12 +258,26 @@ public IWidget initUI(GuiData data, PanelSyncManager manager) {
                                         manager.callSyncedAction("update_filter_panel", packetBuffer -> {});
                                     }
                                 }))
-                        .size(18).marginRight(2)
-                        .background(GTGuiTextures.SLOT, GTGuiTextures.FILTER_SLOT_OVERLAY.asIcon().size(16)))
+                        .tooltipBuilder(tooltip -> {
+                            ItemStack filterStack = getFilterStack();
+                            if (filterStack.isEmpty()) {
+                                tooltip.addLine(IKey.lang("cover.universal.filter_slot.tooltip_header"));
+                                for (ItemStack filterItem : CoverRegistry.getFilterItems(getFilterType())) {
+                                    tooltip.add(new ItemDrawable(filterItem));
+                                    tooltip.add(IKey.str(" - "));
+                                    tooltip.addLine(IKey.str(filterItem.getDisplayName()));
+                                }
+                            }
+                            // We don't need to .addFromItem because RichTooltip#tooltipBuilder creates compound
+                            // builders if the widget already has one.
+                        })
+                        .background(GTGuiTextures.SLOT, GTGuiTextures.FILTER_SLOT_OVERLAY.asIcon()
+                                .size(16)))
                 .child(new ButtonWidget<>()
-                        .background(GTGuiTextures.MC_BUTTON, GTGuiTextures.FILTER_SETTINGS_OVERLAY.asIcon().size(16))
-                        .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
-                                GTGuiTextures.FILTER_SETTINGS_OVERLAY.asIcon().size(16))
+                        .background(GTGuiTextures.MC_BUTTON, GTGuiTextures.FILTER_SETTINGS_OVERLAY.asIcon()
+                                .size(16))
+                        .hoverBackground(GuiTextures.MC_BUTTON_HOVERED, GTGuiTextures.FILTER_SETTINGS_OVERLAY.asIcon()
+                                .size(16))
                         .setEnabledIf(w -> hasFilter())
                         .onMousePressed(i -> {
                             IPanelHandler panel = filterPanel.get();
@@ -267,8 +293,11 @@ public IWidget initUI(GuiData data, PanelSyncManager manager) {
                 .child(getFilterKey()
                         .color(CoverWithUI.UI_TEXT_COLOR)
                         .shadow(false)
-                        .alignment(Alignment.CenterRight).asWidget()
-                        .left(36).right(0).height(18));
+                        .alignment(Alignment.CenterRight)
+                        .asWidget()
+                        .right(0)
+                        .left(36)
+                        .height(18));
     }
 
     public void writeInitialSyncData(PacketBuffer packetBuffer) {
diff --git a/src/main/java/gregtech/common/covers/filter/FluidFilterContainer.java b/src/main/java/gregtech/common/covers/filter/FluidFilterContainer.java
index df2bc6d54de..51d56dfcb5b 100644
--- a/src/main/java/gregtech/common/covers/filter/FluidFilterContainer.java
+++ b/src/main/java/gregtech/common/covers/filter/FluidFilterContainer.java
@@ -2,27 +2,26 @@
 
 import gregtech.api.util.IDirtyNotifiable;
 
-import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
 
 import com.cleanroommc.modularui.api.drawable.IKey;
 import org.jetbrains.annotations.NotNull;
 
-public class FluidFilterContainer extends BaseFilterContainer {
+public class FluidFilterContainer extends BaseFilterContainer<FluidStack> {
 
     public FluidFilterContainer(IDirtyNotifiable dirtyNotifiable) {
         super(dirtyNotifiable);
     }
 
-    @Override
-    protected boolean isItemValid(ItemStack stack) {
-        var filter = BaseFilter.getFilterFromStack(stack);
-        return filter != BaseFilter.ERROR_FILTER && filter.getType() == IFilter.FilterType.FLUID;
-    }
-
     @Override
     protected @NotNull IKey getFilterKey() {
         return IKey.lang(() -> hasFilter() ?
                 getFilterStack().getTranslationKey() + ".name" :
                 "metaitem.fluid_filter.name");
     }
+
+    @Override
+    protected IFilter.@NotNull FilterType getFilterType() {
+        return IFilter.FilterType.FLUID;
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/filter/IFilter.java b/src/main/java/gregtech/common/covers/filter/IFilter.java
index 1bbde04af5d..78a11e71a65 100644
--- a/src/main/java/gregtech/common/covers/filter/IFilter.java
+++ b/src/main/java/gregtech/common/covers/filter/IFilter.java
@@ -64,8 +64,24 @@ default int getTransferLimit(int slot, int transferSize) {
     FilterType getType();
 
     enum FilterType {
+
         ITEM,
-        FLUID
+        FLUID,
+        ERROR;
+
+        public static final FilterType[] VALUES = values();
+
+        public boolean isItemFilter() {
+            return this == ITEM;
+        }
+
+        public boolean isFluidFilter() {
+            return this == FLUID;
+        }
+
+        public boolean isError() {
+            return this == ERROR;
+        }
     }
 
     // this only exists so i can pass in the constructor reference as a metaitem componant
diff --git a/src/main/java/gregtech/common/covers/filter/ItemFilterContainer.java b/src/main/java/gregtech/common/covers/filter/ItemFilterContainer.java
index 6d1705edf86..d204b47f12a 100644
--- a/src/main/java/gregtech/common/covers/filter/ItemFilterContainer.java
+++ b/src/main/java/gregtech/common/covers/filter/ItemFilterContainer.java
@@ -7,22 +7,21 @@
 import com.cleanroommc.modularui.api.drawable.IKey;
 import org.jetbrains.annotations.NotNull;
 
-public class ItemFilterContainer extends BaseFilterContainer {
+public class ItemFilterContainer extends BaseFilterContainer<ItemStack> {
 
     public ItemFilterContainer(IDirtyNotifiable dirtyNotifiable) {
         super(dirtyNotifiable);
     }
 
-    @Override
-    protected boolean isItemValid(ItemStack stack) {
-        var filter = BaseFilter.getFilterFromStack(stack);
-        return filter != BaseFilter.ERROR_FILTER && filter.getType() == IFilter.FilterType.ITEM;
-    }
-
     @Override
     protected @NotNull IKey getFilterKey() {
         return IKey.lang(() -> hasFilter() ?
                 getFilterStack().getTranslationKey() + ".name" :
                 "metaitem.item_filter.name");
     }
+
+    @Override
+    protected IFilter.@NotNull FilterType getFilterType() {
+        return IFilter.FilterType.ITEM;
+    }
 }
diff --git a/src/main/java/gregtech/common/pipelike/itempipe/net/ItemNetHandler.java b/src/main/java/gregtech/common/pipelike/itempipe/net/ItemNetHandler.java
index 20967af87e4..261dea2e3fd 100644
--- a/src/main/java/gregtech/common/pipelike/itempipe/net/ItemNetHandler.java
+++ b/src/main/java/gregtech/common/pipelike/itempipe/net/ItemNetHandler.java
@@ -10,6 +10,7 @@
 import gregtech.common.covers.CoverItemFilter;
 import gregtech.common.covers.CoverRoboticArm;
 import gregtech.common.covers.DistributionMode;
+import gregtech.common.covers.IOMode;
 import gregtech.common.covers.ItemFilterMode;
 import gregtech.common.pipelike.itempipe.tile.TileEntityItemPipe;
 
@@ -85,56 +86,67 @@ public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate
         // abort if there are two conveyors
         if (pipeConveyor && tileConveyor) return stack;
 
-        if (tileCover != null && !checkImportCover(tileCover, false, stack))
+        if (tileCover != null && !checkImportCover(tileCover, false, stack)) {
             return stack;
+        }
 
-        if (!pipeConveyor && !tileConveyor)
+        if (!pipeConveyor && !tileConveyor) {
             return insertFirst(stack, simulate);
+        }
 
         CoverConveyor conveyor = (CoverConveyor) (pipeConveyor ? pipeCover : tileCover);
-        if (conveyor.getConveyorMode() ==
-                (pipeConveyor ? CoverConveyor.ConveyorMode.IMPORT : CoverConveyor.ConveyorMode.EXPORT)) {
-            boolean roundRobinGlobal = conveyor.getDistributionMode() == DistributionMode.ROUND_ROBIN_GLOBAL;
-            if (roundRobinGlobal || conveyor.getDistributionMode() == DistributionMode.ROUND_ROBIN_PRIO)
-                return insertRoundRobin(stack, simulate, roundRobinGlobal);
+        IOMode conveyorIOMode = conveyor.getIOMode();
+        if (pipeConveyor ? conveyorIOMode.isImport() : conveyorIOMode.isExport()) {
+            DistributionMode distributionMode = conveyor.getDistributionMode();
+            if (!distributionMode.isInsertFirst()) {
+                return insertRoundRobin(stack, simulate, distributionMode.isRoundRobinGlobal());
+            }
         }
 
         return insertFirst(stack, simulate);
     }
 
     public static boolean checkImportCover(Cover cover, boolean onPipe, ItemStack stack) {
-        if (cover == null) return true;
         if (cover instanceof CoverItemFilter filter) {
-            return (filter.getFilterMode() != ItemFilterMode.FILTER_BOTH &&
-                    (filter.getFilterMode() != ItemFilterMode.FILTER_INSERT || !onPipe) &&
-                    (filter.getFilterMode() != ItemFilterMode.FILTER_EXTRACT || onPipe)) || filter.testItemStack(stack);
+            ItemFilterMode filterMode = filter.getFilterMode();
+            return (!filterMode.isFilterBoth() &&
+                    (!filterMode.isFilterInsert() || !onPipe) &&
+                    (!filterMode.isFilterExtract() || onPipe)) ||
+                    filter.testItemStack(stack);
+        } else {
+            return true;
         }
-        return true;
     }
 
     public ItemStack insertFirst(ItemStack stack, boolean simulate) {
         for (ItemRoutePath inv : net.getNetData(pipe.getPipePos(), facing)) {
             stack = insert(inv, stack, simulate);
-            if (stack.isEmpty())
+            if (stack.isEmpty()) {
                 return ItemStack.EMPTY;
+            }
         }
         return stack;
     }
 
     public ItemStack insertRoundRobin(ItemStack stack, boolean simulate, boolean global) {
         List<ItemRoutePath> routePaths = net.getNetData(pipe.getPipePos(), facing);
-        if (routePaths.isEmpty())
+        if (routePaths.isEmpty()) {
             return stack;
-        if (routePaths.size() == 1)
+        }
+
+        if (routePaths.size() == 1) {
             return insert(routePaths.get(0), stack, simulate);
+        }
+
         List<ItemRoutePath> routePathsCopy = new ArrayList<>(routePaths);
 
         if (global) {
             stack = insertToHandlersEnhanced(routePathsCopy, stack, routePaths.size(), simulate);
         } else {
             stack = insertToHandlers(routePathsCopy, stack, simulate);
-            if (!stack.isEmpty() && !routePathsCopy.isEmpty())
+            if (!stack.isEmpty() && !routePathsCopy.isEmpty()) {
                 stack = insertToHandlers(routePathsCopy, stack, simulate);
+            }
         }
 
         return stack;
@@ -307,7 +319,8 @@ public ItemStack insert(ItemRoutePath routePath, ItemStack stack, boolean simula
         if (allowed == 0 || !routePath.matchesFilters(stack)) {
             return stack;
         }
-        Cover pipeCover = routePath.getTargetPipe().getCoverableImplementation()
+        Cover pipeCover = routePath.getTargetPipe()
+                .getCoverableImplementation()
                 .getCoverAtSide(routePath.getTargetFacing());
         Cover tileCover = getCoverOnNeighbour(routePath.getTargetPipe(), routePath.getTargetFacing());
 
@@ -322,16 +335,12 @@ public ItemStack insert(ItemRoutePath routePath, ItemStack stack, boolean simula
             }
             testHandler.setStackInSlot(0, ItemStack.EMPTY);
         }
+
         IItemHandler neighbourHandler = routePath.getHandler();
-        if (pipeCover instanceof CoverRoboticArm &&
-                ((CoverRoboticArm) pipeCover).getConveyorMode() == CoverConveyor.ConveyorMode.EXPORT) {
-            return insertOverRobotArm(neighbourHandler, (CoverRoboticArm) pipeCover, stack, simulate, allowed,
-                    ignoreLimit);
-        }
-        if (tileCover instanceof CoverRoboticArm &&
-                ((CoverRoboticArm) tileCover).getConveyorMode() == CoverConveyor.ConveyorMode.IMPORT) {
-            return insertOverRobotArm(neighbourHandler, (CoverRoboticArm) tileCover, stack, simulate, allowed,
-                    ignoreLimit);
+        if (pipeCover instanceof CoverRoboticArm coverRoboticArm && coverRoboticArm.getIOMode().isExport()) {
+            return insertOverRobotArm(neighbourHandler, coverRoboticArm, stack, simulate, allowed, ignoreLimit);
+        } else if (tileCover instanceof CoverRoboticArm coverRoboticArm && coverRoboticArm.getIOMode().isImport()) {
+            return insertOverRobotArm(neighbourHandler, coverRoboticArm, stack, simulate, allowed, ignoreLimit);
         }
 
         return insert(neighbourHandler, stack, simulate, allowed, ignoreLimit);
diff --git a/src/main/java/gregtech/integration/opencomputers/values/ValueCoverConveyor.java b/src/main/java/gregtech/integration/opencomputers/values/ValueCoverConveyor.java
index 1694dcff6fc..81cf950a27b 100644
--- a/src/main/java/gregtech/integration/opencomputers/values/ValueCoverConveyor.java
+++ b/src/main/java/gregtech/integration/opencomputers/values/ValueCoverConveyor.java
@@ -2,7 +2,7 @@
 
 import gregtech.api.cover.Cover;
 import gregtech.common.covers.CoverConveyor;
-import gregtech.common.covers.CoverConveyor.ConveyorMode;
+import gregtech.common.covers.IOMode;
 import gregtech.integration.opencomputers.InputValidator;
 
 import net.minecraft.util.EnumFacing;
@@ -66,8 +66,8 @@ public Object[] setConveyorMode(final Context context, final Arguments args) {
             return NULL_COVER;
         }
 
-        ConveyorMode mode = InputValidator.getEnumArrayIndex(args, 0, ConveyorMode.values());
-        cover.setConveyorMode(mode);
+        IOMode mode = InputValidator.getEnumArrayIndex(args, 0, IOMode.VALUES);
+        cover.setIOMode(mode);
         return new Object[] {};
     }
 
@@ -78,6 +78,6 @@ public Object[] getConveyorMode(final Context context, final Arguments args) {
             return NULL_COVER;
         }
 
-        return new Object[] { cover.getConveyorMode().ordinal() };
+        return new Object[] { cover.getIOMode().ordinal() };
     }
 }
diff --git a/src/main/java/gregtech/integration/opencomputers/values/ValueCoverEnderFluidLink.java b/src/main/java/gregtech/integration/opencomputers/values/ValueCoverEnderFluidLink.java
index 31c8b2ae10d..55966179dac 100644
--- a/src/main/java/gregtech/integration/opencomputers/values/ValueCoverEnderFluidLink.java
+++ b/src/main/java/gregtech/integration/opencomputers/values/ValueCoverEnderFluidLink.java
@@ -1,7 +1,7 @@
 package gregtech.integration.opencomputers.values;
 
 import gregtech.api.cover.Cover;
-import gregtech.common.covers.CoverPump.PumpMode;
+import gregtech.common.covers.IOMode;
 import gregtech.common.covers.ender.CoverEnderFluidLink;
 import gregtech.integration.opencomputers.InputValidator;
 
@@ -52,7 +52,7 @@ public Object[] setPumpMode(final Context context, final Arguments args) {
             return NULL_COVER;
         }
 
-        PumpMode mode = InputValidator.getEnumArrayIndex(args, 0, PumpMode.values());
+        IOMode mode = InputValidator.getEnumArrayIndex(args, 0, IOMode.VALUES);
         cover.setPumpMode(mode);
         return new Object[] {};
     }
diff --git a/src/main/java/gregtech/integration/opencomputers/values/ValueCoverPump.java b/src/main/java/gregtech/integration/opencomputers/values/ValueCoverPump.java
index 87c9d6457fa..26355be5be7 100644
--- a/src/main/java/gregtech/integration/opencomputers/values/ValueCoverPump.java
+++ b/src/main/java/gregtech/integration/opencomputers/values/ValueCoverPump.java
@@ -2,7 +2,7 @@
 
 import gregtech.api.cover.Cover;
 import gregtech.common.covers.CoverPump;
-import gregtech.common.covers.CoverPump.PumpMode;
+import gregtech.common.covers.IOMode;
 import gregtech.integration.opencomputers.InputValidator;
 
 import net.minecraft.util.EnumFacing;
@@ -66,8 +66,8 @@ public Object[] setPumpMode(final Context context, final Arguments args) {
             return NULL_COVER;
         }
 
-        PumpMode mode = InputValidator.getEnumArrayIndex(args, 0, PumpMode.values());
-        cover.setPumpMode(mode);
+        IOMode mode = InputValidator.getEnumArrayIndex(args, 0, IOMode.VALUES);
+        cover.setIoMode(mode);
         return new Object[] {};
     }
 
@@ -78,6 +78,6 @@ public Object[] getPumpMode(final Context context, final Arguments args) {
             return NULL_COVER;
         }
 
-        return new Object[] { cover.getPumpMode().ordinal() };
+        return new Object[] { cover.getIoMode().ordinal() };
     }
 }
diff --git a/src/main/java/gregtech/integration/theoneprobe/provider/CoverInfoProvider.java b/src/main/java/gregtech/integration/theoneprobe/provider/CoverInfoProvider.java
index 377ff7a51d7..91b464e9420 100644
--- a/src/main/java/gregtech/integration/theoneprobe/provider/CoverInfoProvider.java
+++ b/src/main/java/gregtech/integration/theoneprobe/provider/CoverInfoProvider.java
@@ -61,21 +61,22 @@ protected void addProbeInfo(@NotNull CoverHolder capability, @NotNull IProbeInfo
     private static void conveyorInfo(@NotNull IProbeInfo probeInfo, @NotNull CoverConveyor conveyor) {
         String rateUnit = lang("cover.conveyor.transfer_rate");
 
-        if (conveyor instanceof CoverItemVoiding) {
-            itemVoidingInfo(probeInfo, (CoverItemVoiding) conveyor);
-        } else if (!(conveyor instanceof CoverRoboticArm arm) ||
-                arm.getTransferMode() == TransferMode.TRANSFER_ANY) {
-                    // only display the regular rate if the cover does not have a specialized rate
-                    transferRateText(probeInfo, conveyor.getConveyorMode(), " " + rateUnit, conveyor.getTransferRate());
-                }
+        if (conveyor instanceof CoverItemVoiding coverItemVoiding) {
+            itemVoidingInfo(probeInfo, coverItemVoiding);
+        } else if (!(conveyor instanceof CoverRoboticArm arm) || arm.getTransferMode().isTransferAny()) {
+            // only display the regular rate if the cover does not have a specialized rate
+            transferRateText(probeInfo, conveyor.getIOMode(), " " + rateUnit, conveyor.getTransferRate());
+        }
 
         ItemFilterContainer filter = conveyor.getItemFilterContainer();
         if (conveyor instanceof CoverRoboticArm roboticArm) {
-            if (roboticArm.getTransferMode() != TransferMode.TRANSFER_ANY)
+            TransferMode transferMode = roboticArm.getTransferMode();
+            if (!transferMode.isTransferAny()) {
                 rateUnit = lang("cover.robotic_arm.exact");
+            }
 
-            transferModeText(probeInfo, roboticArm.getTransferMode(), rateUnit,
-                    filter.getTransferSize(), filter.hasFilter());
+            transferModeText(probeInfo, transferMode, "robotic_arm", rateUnit, filter.getTransferSize(),
+                    filter.hasFilter());
         }
         itemFilterText(probeInfo, filter.getFilter());
     }
@@ -108,12 +109,12 @@ private static void pumpInfo(@NotNull IProbeInfo probeInfo, @NotNull CoverPump p
                 "cover.bucket.mode.bucket_rate" :
                 "cover.bucket.mode.milli_bucket_rate");
 
-        if (pump instanceof CoverFluidVoiding) {
-            fluidVoidingInfo(probeInfo, (CoverFluidVoiding) pump);
+        if (pump instanceof CoverFluidVoiding coverFluidVoiding) {
+            fluidVoidingInfo(probeInfo, coverFluidVoiding);
         } else if (!(pump instanceof CoverFluidRegulator regulator) ||
                 regulator.getTransferMode() == TransferMode.TRANSFER_ANY) {
                     // do not display the regular rate if the cover has a specialized rate
-                    transferRateText(probeInfo, pump.getPumpMode(), " " + rateUnit,
+                    transferRateText(probeInfo, pump.getIoMode(), " " + rateUnit,
                             pump.getBucketMode() == CoverPump.BucketMode.BUCKET ? pump.getTransferRate() / 1000 :
                                     pump.getTransferRate());
                 }
@@ -125,8 +126,8 @@ private static void pumpInfo(@NotNull IProbeInfo probeInfo, @NotNull CoverPump p
                         "gregtech.top.unit.fluid_buckets" :
                         "gregtech.top.unit.fluid_milibuckets");
 
-            transferModeText(probeInfo, regulator.getTransferMode(), rateUnit, regulator
-                    .getFluidFilterContainer().getTransferSize(), filter.hasFilter() && !filter.isBlacklistFilter());
+            transferModeText(probeInfo, regulator.getTransferMode(), "fluid_regulator", rateUnit,
+                    filter.getTransferSize(), filter.hasFilter() && !filter.isBlacklistFilter());
         }
         fluidFilterText(probeInfo, filter.getFilter());
     }
@@ -138,17 +139,15 @@ private static void pumpInfo(@NotNull IProbeInfo probeInfo, @NotNull CoverPump p
      * @param voiding   the voiding cover to get data from
      */
     private static void fluidVoidingInfo(@NotNull IProbeInfo probeInfo, @NotNull CoverFluidVoiding voiding) {
-        String unit = lang(voiding.getBucketMode() == CoverPump.BucketMode.BUCKET ?
+        String unit = lang(voiding.getBucketMode().isFullBuckets() ?
                 "gregtech.top.unit.fluid_buckets" :
                 "gregtech.top.unit.fluid_milibuckets");
-        var container = voiding.getFluidFilterContainer();
 
         if (voiding instanceof CoverFluidVoidingAdvanced advanced) {
+            FluidFilterContainer container = voiding.getFluidFilterContainer();
             VoidingMode mode = advanced.getVoidingMode();
             // do not display amount in overflow when a filter is present
-            voidingText(probeInfo, mode, unit,
-                    voiding.getBucketMode() == CoverPump.BucketMode.BUCKET ? advanced.getTransferAmount() / 1000 :
-                            advanced.getTransferAmount(),
+            voidingText(probeInfo, mode, unit, voiding.getBucketMode().fromMilliBuckets(advanced.getTransferAmount()),
                     container.hasFilter() && !container.isBlacklistFilter());
         }
     }
@@ -193,14 +192,14 @@ private static void enderFluidLinkInfo(@NotNull IProbeInfo probeInfo, @NotNull C
     }
 
     /**
-     * Displays text for {@link IIOMode} covers
+     * Displays text for {@link IOMode} covers
      *
      * @param probeInfo the info to add the text to
      * @param mode      the transfer mode of the cover
      * @param rateUnit  the unit of what is transferred
      * @param rate      the transfer rate of the mode
      */
-    private static void transferRateText(@NotNull IProbeInfo probeInfo, @NotNull IIOMode mode, @NotNull String rateUnit,
+    private static void transferRateText(@NotNull IProbeInfo probeInfo, @NotNull IOMode mode, @NotNull String rateUnit,
                                          int rate) {
         String modeText = mode.isImport() ? lang("gregtech.top.mode.import") : lang("gregtech.top.mode.export");
         modeText += " ";
@@ -217,11 +216,12 @@ private static void transferRateText(@NotNull IProbeInfo probeInfo, @NotNull IIO
      * @param hasFilter whether the cover has a filter installed
      */
     private static void transferModeText(@NotNull IProbeInfo probeInfo, @NotNull TransferMode mode,
-                                         @NotNull String rateUnit, int rate, boolean hasFilter) {
-        String text = TextStyleClass.OK + lang(mode.getName());
-        if (!hasFilter && mode != TransferMode.TRANSFER_ANY)
+                                         @NotNull String coverName, @NotNull String rateUnit, int rate,
+                                         boolean hasFilter) {
+        String text = TextStyleClass.OK + lang(mode.getName(coverName));
+        if (!hasFilter && !mode.isTransferAny()) {
             text += TextStyleClass.LABEL + " " + TextFormattingUtil.formatNumbers(rate) + " " + rateUnit;
-
+        }
         probeInfo.text(text);
     }
 
@@ -237,8 +237,9 @@ private static void transferModeText(@NotNull IProbeInfo probeInfo, @NotNull Tra
     private static void voidingText(@NotNull IProbeInfo probeInfo, @NotNull VoidingMode mode, @NotNull String unit,
                                     int amount, boolean hasFilter) {
         String text = TextFormatting.RED + lang(mode.getName());
-        if (mode != VoidingMode.VOID_ANY && !hasFilter)
+        if (mode != VoidingMode.VOID_ANY && !hasFilter) {
             text += " " + TextFormattingUtil.formatNumbers(amount) + " " + unit;
+        }
         probeInfo.text(text);
     }
 
@@ -260,8 +261,8 @@ private static void filterModeText(@NotNull IProbeInfo probeInfo, @NotNull IStri
      */
     private static void itemFilterText(@NotNull IProbeInfo probeInfo, @Nullable BaseFilter filter) {
         String label = TextStyleClass.INFO + lang("gregtech.top.filter.label");
-        if (filter instanceof OreDictionaryItemFilter) {
-            String expression = ((OreDictionaryItemFilter) filter).getExpression();
+        if (filter instanceof OreDictionaryItemFilter oreDictionaryItemFilter) {
+            String expression = oreDictionaryItemFilter.getExpression();
             if (!expression.isEmpty()) probeInfo.text(label + expression);
         } else if (filter instanceof SmartItemFilter smartItemFilter) {
             probeInfo.text(label + lang(smartItemFilter.getFilteringMode().getName()));
diff --git a/src/main/resources/assets/gregtech/lang/en_us.lang b/src/main/resources/assets/gregtech/lang/en_us.lang
index 3429aad9618..92a97972a2b 100644
--- a/src/main/resources/assets/gregtech/lang/en_us.lang
+++ b/src/main/resources/assets/gregtech/lang/en_us.lang
@@ -1353,7 +1353,10 @@ cover.generic.enabled=Enabled
 cover.generic.transfer_mode=Transfer Mode
 cover.generic.manual_io=Manual IO Mode
 cover.generic.io=IO Mode
-cover.pump.mode=Pump Mode
+cover.universal.mode.export=Mode: Export
+cover.universal.mode.import=Mode: Import
+
+cover.universal.filter_slot.tooltip_header=Valid filters:
 cover.conveyor.title=Conveyor Cover Settings (%s)
 cover.conveyor.transfer_rate=§7items/sec
 cover.conveyor.mode.export=Mode: Export
@@ -1364,25 +1367,35 @@ cover.conveyor.distribution.round_robin=§bRound Robin§r with Priority\n§7Trie
 cover.conveyor.distribution.first_insert=§bFirst Insert§r\n§7Will insert into the first inventory it finds
 cover.conveyor.blocks_input.enabled=If enabled, items will not be inserted when cover is set to pull items from the inventory into pipe./n§aEnabled
 cover.conveyor.blocks_input.disabled=If enabled, items will not be inserted when cover is set to pull items from the inventory into pipe./n§cDisabled
-cover.universal.manual_import_export.mode.disabled=Manual I/O: Disabled
-cover.universal.manual_import_export.mode.filtered=Manual I/O: Filtered
-cover.universal.manual_import_export.mode.unfiltered=Manual I/O: Unfiltered
-cover.universal.manual_import_export.mode.description=§eDisabled§r - Items/fluids will only move as specified by the cover and its filter. /n§eAllow Filtered§r - Items/fluids can be extracted and inserted independently of the cover mode, as long as its filter matches (if any). /n§eAllow Unfiltered§r - Items/fluids can be moved independently of the cover mode. Filter applies to the items inserted or extracted by this cover
+cover.universal.manual_import_export.mode.disabled=§cDisabled§r
+cover.universal.manual_import_export.mode.filtered=§eAllow Filtered§r
+cover.universal.manual_import_export.mode.unfiltered=§aAllow Unfiltered§r
+cover.conveyor.manual_import_export.mode.disabled.description=Items will only move as specified by the cover and its filter.
+cover.conveyor.manual_import_export.mode.filtered.description=Items can be extracted and inserted independently of the cover mode, as long as its filter matches (if any).
+cover.conveyor.manual_import_export.mode.unfiltered.description=Items can be moved independently of the cover mode./nThe filter only applies to items inserted or extracted by this cover.
 cover.conveyor.item_filter.title=Item Filter
 cover.conveyor.ore_dictionary.title=Ore Dictionary Name
 cover.conveyor.ore_dictionary.title2=(use * for wildcard)
 cover.robotic_arm.title=Robotic Arm Settings (%s)
 cover.robotic_arm.exact=§7items
-cover.robotic_arm.transfer_mode.transfer_any=Transfer Any
-cover.robotic_arm.transfer_mode.transfer_exact=Supply Exact
-cover.robotic_arm.transfer_mode.keep_exact=Keep Exact
-cover.robotic_arm.transfer_mode.description=§eTransfer Any§r - in this mode, cover will transfer as many items matching its filter as possible./n§eSupply Exact§r - in this mode, cover will supply items in portions specified in item filter slots (or variable under this button for ore dictionary filter). If amount of items is less than portion size, items won't be moved. If there's a §bSmart Item Filter§r, the variable under this button will act as a multiplier instead./n§eKeep Exact§r - in this mode, cover will keep specified amount of items in the destination inventory, supplying additional amount of items if required./n§7Tip: left/right click on filter slots to change item amount,  use shift clicking to change amount faster.
+cover.robotic_arm.transfer_mode.transfer_any=§eTransfer Any§r
+cover.robotic_arm.transfer_mode.transfer_any.description=Cover will transfer as many items matching its filter as possible.
+cover.robotic_arm.transfer_mode.transfer_exact=§eSupply Exact§r
+cover.robotic_arm.transfer_mode.transfer_exact.description=Cover will supply items in portions specified in item filter slots (or variable under this button for ore dictionary filter)./nIf amount of items is less than portion size, items won't be moved. If there's a §bSmart Item Filter§r, the variable under this button will act as a multiplier instead.
+cover.robotic_arm.transfer_mode.keep_exact=§eKeep Exact§r
+cover.robotic_arm.transfer_mode.keep_exact.description=Cover will keep specified amount of items in the destination inventory, supplying additional amount of items if required.
+cover.robotic_arm.transfer_mode.retain_exact=§eRetain Exact§r
+cover.robotic_arm.transfer_mode.retain_exact.description=Cover will keep specified amount of items in the source inventory, sending excess items if required.
 
 cover.pump.title=Pump Cover Settings (%s)
 cover.pump.transfer_rate=%s
+cover.pump.mode=Pump Mode
 cover.pump.mode.export=Mode: Export
 cover.pump.mode.import=Mode: Import
 cover.pump.fluid_filter.title=Fluid Filter
+cover.pump.manual_import_export.mode.disabled.description=Fluids will only move as specified by the cover and its filter.
+cover.pump.manual_import_export.mode.filtered.description=Fluids can be extracted and inserted independently of the cover mode, as long as its filter matches (if any).
+cover.pump.manual_import_export.mode.unfiltered.description=Fluids can be moved independently of the cover mode./nThe filter only applies to fluids inserted or extracted by this cover.
 cover.bucket.mode.bucket=Bucket Mode: kL
 cover.bucket.mode.milli_bucket=Bucket Mode: L
 cover.bucket.mode.bucket_rate=kL/s
@@ -1390,9 +1403,14 @@ cover.bucket.mode.bucket_exact=kL
 cover.bucket.mode.milli_bucket_rate=L/s
 cover.bucket.mode.milli_bucket_exact=L
 cover.fluid_regulator.title=Fluid Regulator Settings (%s)
-cover.fluid_regulator.transfer_mode.description=§eTransfer Any§r - in this mode, cover will transfer as many fluids matching its filter as possible./n§eSupply Exact§r - in this mode, cover will supply fluids in portions specified in the window underneath this button. If amount of fluids is less than portion size, fluids won't be moved./n§eKeep Exact§r - in this mode, cover will keep specified amount of fluids in the destination inventory, supplying additional amount of fluids if required./n§7Tip: shift click will multiply increase/decrease amounts by 10 and ctrl click will multiply by 100.
-cover.fluid_regulator.supply_exact=Supply Exact: %s
-cover.fluid_regulator.keep_exact=Keep Exact: %s
+cover.fluid_regulator.transfer_mode.transfer_any=§eTransfer Any§r
+cover.fluid_regulator.transfer_mode.transfer_any.description=Cover will transfer as many fluids matching its filter as possible.
+cover.fluid_regulator.transfer_mode.transfer_exact=§eSupply Exact§r
+cover.fluid_regulator.transfer_mode.transfer_exact.description=Cover will supply fluids in portions specified in the window underneath this button./nIf amount of fluids is less than portion size, fluids won't be moved.
+cover.fluid_regulator.transfer_mode.keep_exact=§eKeep Exact§r
+cover.fluid_regulator.transfer_mode.keep_exact.description=Cover will keep specified amount of fluids in the destination inventory, supplying additional amount of fluids if required.
+cover.fluid_regulator.transfer_mode.retain_exact=§eRetain Exact§r
+cover.fluid_regulator.transfer_mode.retain_exact.description=Cover will keep specified amount of fluids in the source inventory, sending excess fluids if required.
 
 cover.machine_controller.mode.machine=Control Machine
 cover.machine_controller.mode.cover_up=Control Cover (Top)
diff --git a/src/main/resources/assets/gregtech/textures/gui/overlay/fluid_transfer_mode_overlay.png b/src/main/resources/assets/gregtech/textures/gui/overlay/fluid_transfer_mode_overlay.png
index 6fe690f9fbb..901b533aa87 100644
Binary files a/src/main/resources/assets/gregtech/textures/gui/overlay/fluid_transfer_mode_overlay.png and b/src/main/resources/assets/gregtech/textures/gui/overlay/fluid_transfer_mode_overlay.png differ
diff --git a/src/main/resources/assets/gregtech/textures/gui/overlay/transfer_mode_overlay.png b/src/main/resources/assets/gregtech/textures/gui/overlay/transfer_mode_overlay.png
index 9364d84544d..c72f390af81 100644
Binary files a/src/main/resources/assets/gregtech/textures/gui/overlay/transfer_mode_overlay.png and b/src/main/resources/assets/gregtech/textures/gui/overlay/transfer_mode_overlay.png differ
diff --git a/src/test/java/gregtech/common/covers/CoverFluidRegulatorTest.java b/src/test/java/gregtech/common/covers/CoverFluidRegulatorTest.java
index b5402ff0afa..4b8570895d3 100644
--- a/src/test/java/gregtech/common/covers/CoverFluidRegulatorTest.java
+++ b/src/test/java/gregtech/common/covers/CoverFluidRegulatorTest.java
@@ -45,7 +45,7 @@ public void doKeepExact_does_nothing_if_no_destination_tank_exists() {
                 new FluidTankList(false, new FluidTank(water.copy(), 64000)));
 
         // Tell it to keep exact from a machine with an empty fluid tank and null target fluid tank
-        int amountTransferred = cfr.doKeepExact(1000, source, null, isWater, 1000);
+        int amountTransferred = cfr.doKeepExact(1000, source, null, isWater, 1000, true);
 
         MatcherAssert.assertThat("Unexpectedly moved fluids, nothing is supposed to happen", amountTransferred, is(0));
     }
@@ -66,7 +66,7 @@ public void doKeepExact_moves_one_fluid_into_an_empty_tank() {
                 new FluidTankList(false));
 
         // Tell it to keep exact from a machine with an empty fluid tank and no target fluid tank
-        int amountTransferred = cfr.doKeepExact(1000, source, dest, isWater, 1000);
+        int amountTransferred = cfr.doKeepExact(1000, source, dest, isWater, 1000, true);
 
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(1000));
     }
@@ -84,7 +84,7 @@ public void doKeepExact_moves_only_as_much_fluid_as_exists_in_the_source() {
         IFluidHandler dest = new FluidHandlerProxy(new FluidTankList(false, new FluidTank(64000)),
                 new FluidTankList(false));
 
-        int amountTransferred = cfr.doKeepExact(10000, source, dest, isWater, 10000);
+        int amountTransferred = cfr.doKeepExact(10000, source, dest, isWater, 10000, true);
 
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(1234));
     }
@@ -104,7 +104,7 @@ public void doKeepExact_moves_only_the_fluid_required_if_more_could_be_moved() {
                         new FluidTank(new FluidStack(FluidRegistry.WATER, 100), 64000)),
                 new FluidTankList(false));
 
-        int amountTransferred = cfr.doKeepExact(10000, source, dest, isWater, 144);
+        int amountTransferred = cfr.doKeepExact(10000, source, dest, isWater, 144, true);
 
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(44));
     }
@@ -129,7 +129,7 @@ public void doKeepExact_moves_multiple_valid_fluids() {
                 new FluidTankList(false));
 
         // accept any fluid this time
-        int amountTransferred = cfr.doKeepExact(10000, source, dest, fs -> true, 144);
+        int amountTransferred = cfr.doKeepExact(10000, source, dest, fs -> true, 144, true);
 
         // expect that 44mB of water and 144mB of lava will be moved
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(44 + 144));
@@ -164,7 +164,7 @@ public void doKeepExact_respects_transfer_limit_with_one_fluid() {
                 new FluidTankList(false));
 
         // accept any fluid this time
-        int amountTransferred = cfr.doKeepExact(100, source, dest, fs -> true, 144);
+        int amountTransferred = cfr.doKeepExact(100, source, dest, fs -> true, 144, true);
 
         // expect that at most 100mB of fluids total will be moved this tick, as if possible it would do 144mB
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(100));
@@ -190,7 +190,7 @@ public void doKeepExact_respects_transfer_limit_with_multiple_fluids() {
                 new FluidTankList(false));
 
         // accept any fluid this time
-        int amountTransferred = cfr.doKeepExact(100, source, dest, fs -> true, 144);
+        int amountTransferred = cfr.doKeepExact(100, source, dest, fs -> true, 144, true);
 
         // expect that at most 100mB of fluids total will be moved this tick, as if possible it would do 188mB
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(100));
@@ -216,7 +216,7 @@ public void doKeepExact_does_nothing_if_levels_are_already_correct_in_dest() {
                 new FluidTankList(false));
 
         // accept any fluid this time
-        int amountTransferred = cfr.doKeepExact(10000, source, dest, fs -> true, 144);
+        int amountTransferred = cfr.doKeepExact(10000, source, dest, fs -> true, 144, true);
 
         // expect that no fluids are moved because Keep Exact levels are already met
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(0));
@@ -242,7 +242,7 @@ public void doKeepExact_ignores_fluids_not_in_filter() {
                 new FluidTankList(false));
 
         // accept any fluid this time
-        int amountTransferred = cfr.doKeepExact(10000, source, dest, isWater, 144);
+        int amountTransferred = cfr.doKeepExact(10000, source, dest, isWater, 144, true);
 
         // expect that no fluids are moved because already have enough water and lava isn't in the filter
         MatcherAssert.assertThat("Wrong fluid amount moved", amountTransferred, is(0));