GUI Implementation

Added groups
Added button "option"
Added test mod

33 files changed, 1718 insertions, 40 deletions

diff --git a/build.gradle.kts b/build.gradle.kts
index db614c7..c4562de 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -14,8 +14,27 @@ plugins {
 group = "dev.isxander"
 version = "1.0.0"
 
+val testmod by sourceSets.registering {
+    compileClasspath += sourceSets.main.get().compileClasspath
+    runtimeClasspath += sourceSets.main.get().runtimeClasspath
+}
+
+loom {
+    runs {
+        register("testmod") {
+            client()
+            ideConfigGenerated(true)
+            name("Test Mod")
+            source(testmod.get())
+        }
+    }
+
+    createRemapConfigurations(testmod.get())
+}
+
 repositories {
     mavenCentral()
+    maven("https://maven.terraformersmc.com")
 }
 
 val minecraftVersion: String by project
@@ -24,8 +43,12 @@ val fabricLoaderVersion: String by project
 dependencies {
     minecraft("com.mojang:minecraft:$minecraftVersion")
     mappings("net.fabricmc:yarn:$minecraftVersion+build.+:v2")
-
     modImplementation("net.fabricmc:fabric-loader:$fabricLoaderVersion")
+
+    modImplementation(fabricApi.module("fabric-resource-loader-v0", "0.60.0+1.19.2"))
+
+    "testmodImplementation"(sourceSets.main.get().output)
+    "modTestmodImplementation"("com.terraformersmc:modmenu:4.0.6")
 }
 
 tasks {
diff --git a/src/main/java/dev/isxander/yacl/api/Binding.java b/src/main/java/dev/isxander/yacl/api/Binding.java
index 67ff822..74120a0 100644
--- a/src/main/java/dev/isxander/yacl/api/Binding.java
+++ b/src/main/java/dev/isxander/yacl/api/Binding.java
@@ -10,7 +10,7 @@ public interface Binding<T> {
 
     T getValue();
 
-    void resetValue();
+    T defaultValue();
 
     static <T> Binding<T> of(T def, Supplier<T> getter, Consumer<T> setter) {
         return new GenericBindingImpl<>(def, getter, setter);
diff --git a/src/main/java/dev/isxander/yacl/api/ButtonOption.java b/src/main/java/dev/isxander/yacl/api/ButtonOption.java
new file mode 100644
index 0000000..08436b3
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/api/ButtonOption.java
@@ -0,0 +1,75 @@
+package dev.isxander.yacl.api;
+
+import dev.isxander.yacl.impl.ButtonOptionImpl;
+import net.minecraft.text.MutableText;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public interface ButtonOption extends Option<Runnable> {
+    Runnable action();
+
+    static Builder createBuilder() {
+        return new Builder();
+    }
+
+    class Builder {
+        private Text name;
+        private final List<Text> tooltipLines = new ArrayList<>();
+        private Function<ButtonOption, Control<Runnable>> controlGetter;
+        private Runnable action;
+
+        private Builder() {
+
+        }
+
+        public Builder name(@NotNull Text name) {
+            Validate.notNull(name, "`name` cannot be null");
+
+            this.name = name;
+            return this;
+        }
+
+        public Builder tooltip(@NotNull Text... tooltips) {
+            Validate.notEmpty(tooltips, "`tooltips` cannot be empty");
+
+            tooltipLines.addAll(List.of(tooltips));
+            return this;
+        }
+
+        public Builder action(@NotNull Runnable action) {
+            Validate.notNull(action, "`action` cannot be null");
+
+            this.action = action;
+            return this;
+        }
+
+        public Builder controller(@NotNull Function<ButtonOption, Control<Runnable>> control) {
+            Validate.notNull(control, "`control` cannot be null");
+
+            this.controlGetter = control;
+            return this;
+        }
+
+        public ButtonOption build() {
+            Validate.notNull(name, "`name` must not be null when building `Option`");
+            Validate.notNull(controlGetter, "`control` must not be null when building `Option`");
+            Validate.notNull(action, "`action` must not be null when building `Option`");
+
+            MutableText concatenatedTooltip = Text.empty();
+            boolean first = true;
+            for (Text line : tooltipLines) {
+                if (!first) concatenatedTooltip.append("\n");
+                first = false;
+
+                concatenatedTooltip.append(line);
+            }
+
+            return new ButtonOptionImpl(name, concatenatedTooltip, action, controlGetter);
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/api/ConfigCategory.java b/src/main/java/dev/isxander/yacl/api/ConfigCategory.java
index ee2fbc7..13552d6 100644
--- a/src/main/java/dev/isxander/yacl/api/ConfigCategory.java
+++ b/src/main/java/dev/isxander/yacl/api/ConfigCategory.java
@@ -1,18 +1,22 @@
 package dev.isxander.yacl.api;
 
 import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl.gui.YACLScreen;
 import dev.isxander.yacl.impl.ConfigCategoryImpl;
+import dev.isxander.yacl.impl.OptionGroupImpl;
+import net.minecraft.client.gui.widget.ClickableWidget;
 import net.minecraft.text.Text;
 import org.apache.commons.lang3.Validate;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
 
 public interface ConfigCategory {
     @NotNull Text name();
 
-    @NotNull ImmutableList<Option<?>> options();
+    @NotNull ImmutableList<OptionGroup> groups();
 
     static Builder createBuilder() {
         return new Builder();
@@ -20,31 +24,44 @@ public interface ConfigCategory {
 
     class Builder {
         private Text name;
-        private final List<Option<?>> options = new ArrayList<>();
+        private final List<Option<?>> rootOptions = new ArrayList<>();
+
+        private final List<OptionGroup> groups = new ArrayList<>();
 
         private Builder() {
 
         }
 
-        public Builder setName(@NotNull Text name) {
+        public Builder name(@NotNull Text name) {
             Validate.notNull(name, "`name` cannot be null");
 
             this.name = name;
             return this;
         }
 
-        public Builder addOption(@NotNull Option<?> option) {
+        public Builder option(@NotNull Option<?> option) {
             Validate.notNull(option, "`option` must not be null");
 
-            this.options.add(option);
+            this.rootOptions.add(option);
+            return this;
+        }
+
+        public Builder group(@NotNull OptionGroup group) {
+            Validate.notNull(group, "`group` must not be null");
+
+            this.groups.add(group);
             return this;
         }
 
         public ConfigCategory build() {
             Validate.notNull(name, "`name` must not be null to build `ConfigCategory`");
-            Validate.notEmpty(options, "`at least one option must be added to build `ConfigCategory`");
+            Validate.notEmpty(rootOptions, "`at least one option must be added to build `ConfigCategory`");
+
+            List<OptionGroup> combinedGroups = new ArrayList<>();
+            combinedGroups.add(new OptionGroupImpl(Text.empty(), ImmutableList.copyOf(rootOptions), true));
+            combinedGroups.addAll(groups);
 
-            return new ConfigCategoryImpl(name, ImmutableList.copyOf(options));
+            return new ConfigCategoryImpl(name, ImmutableList.copyOf(combinedGroups));
         }
     }
 }
diff --git a/src/main/java/dev/isxander/yacl/api/Control.java b/src/main/java/dev/isxander/yacl/api/Control.java
index 0733c4f..242b2c8 100644
--- a/src/main/java/dev/isxander/yacl/api/Control.java
+++ b/src/main/java/dev/isxander/yacl/api/Control.java
@@ -1,10 +1,14 @@
 package dev.isxander.yacl.api;
 
 import dev.isxander.yacl.api.utils.Dimension;
-import dev.isxander.yacl.gui.AbstractWidget;
+import dev.isxander.yacl.gui.controllers.ControlWidget;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
 
 public interface Control<T> {
     Option<T> option();
 
-    AbstractWidget provideWidget(Dimension<Integer> widgetDimension);
+    Text formatValue();
+
+    ControlWidget<?> provideWidget(Screen screen, Dimension<Integer> widgetDimension);
 }
diff --git a/src/main/java/dev/isxander/yacl/api/NameableEnum.java b/src/main/java/dev/isxander/yacl/api/NameableEnum.java
new file mode 100644
index 0000000..12a58c3
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/api/NameableEnum.java
@@ -0,0 +1,7 @@
+package dev.isxander.yacl.api;
+
+import net.minecraft.text.Text;
+
+public interface NameableEnum {
+    Text getDisplayName();
+}
diff --git a/src/main/java/dev/isxander/yacl/api/Option.java b/src/main/java/dev/isxander/yacl/api/Option.java
index 1c7a8a1..5a98d50 100644
--- a/src/main/java/dev/isxander/yacl/api/Option.java
+++ b/src/main/java/dev/isxander/yacl/api/Option.java
@@ -10,6 +10,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public interface Option<T> {
@@ -23,11 +24,17 @@ public interface Option<T> {
 
     boolean changed();
 
+    T pendingValue();
+
     void requestSet(T value);
 
     void applyValue();
 
-    static <T> Builder<T> createBuilder() {
+    void forgetPendingValue();
+
+    void requestSetDefault();
+
+    static <T> Builder<T> createBuilder(Class<T> clazz) {
         return new Builder<>();
     }
 
@@ -36,7 +43,7 @@ public interface Option<T> {
 
         private final List<Text> tooltipLines = new ArrayList<>();
 
-        private Control<T> control;
+        private Function<Option<T>, Control<T>> controlGetter;
 
         private Binding<T> binding;
 
@@ -58,10 +65,10 @@ public interface Option<T> {
             return this;
         }
 
-        public Builder<T> controller(@NotNull Control<T> control) {
+        public Builder<T> controller(@NotNull Function<Option<T>, Control<T>> control) {
             Validate.notNull(control, "`control` cannot be null");
 
-            this.control = control;
+            this.controlGetter = control;
             return this;
         }
 
@@ -73,7 +80,7 @@ public interface Option<T> {
         }
 
         public Builder<T> binding(@NotNull T def, @NotNull Supplier<@NotNull T> getter, @NotNull Consumer<@NotNull T> setter) {
-            Validate.notNull(def, "`default` must not be null");
+            Validate.notNull(def, "`def` must not be null");
             Validate.notNull(getter, "`getter` must not be null");
             Validate.notNull(setter, "`setter` must not be null");
 
@@ -83,7 +90,7 @@ public interface Option<T> {
 
         public Option<T> build() {
             Validate.notNull(name, "`name` must not be null when building `Option`");
-            Validate.notNull(control, "`control` must not be null when building `Option`");
+            Validate.notNull(controlGetter, "`control` must not be null when building `Option`");
             Validate.notNull(binding, "`binding` must not be null when building `Option`");
 
             MutableText concatenatedTooltip = Text.empty();
@@ -95,7 +102,7 @@ public interface Option<T> {
                 concatenatedTooltip.append(line);
             }
 
-            return new OptionImpl<>(name, concatenatedTooltip, control, binding);
+            return new OptionImpl<>(name, concatenatedTooltip, controlGetter, binding);
         }
     }
 }
diff --git a/src/main/java/dev/isxander/yacl/api/OptionGroup.java b/src/main/java/dev/isxander/yacl/api/OptionGroup.java
new file mode 100644
index 0000000..bedbc82
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/api/OptionGroup.java
@@ -0,0 +1,52 @@
+package dev.isxander.yacl.api;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl.impl.OptionGroupImpl;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public interface OptionGroup {
+    Text name();
+
+    @NotNull ImmutableList<Option<?>> options();
+
+    boolean isRoot();
+
+    static Builder createBuilder() {
+        return new Builder();
+    }
+
+    class Builder {
+        private Text name = Text.empty();
+        private final List<Option<?>> options = new ArrayList<>();
+
+        private Builder() {
+
+        }
+
+        public Builder name(@NotNull Text name) {
+            Validate.notNull(name, "`name` must not be null");
+
+            this.name = name;
+            return this;
+        }
+
+        public Builder option(@NotNull Option<?> option) {
+            Validate.notNull(option, "`option` must not be null");
+
+            this.options.add(option);
+            return this;
+        }
+
+        public OptionGroup build() {
+            Validate.notEmpty(options, "`options` must not be empty to build `OptionGroup`");
+
+            return new OptionGroupImpl(name, ImmutableList.copyOf(options), false);
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/api/YetAnotherConfigLib.java b/src/main/java/dev/isxander/yacl/api/YetAnotherConfigLib.java
index d7f8416..a598e27 100644
--- a/src/main/java/dev/isxander/yacl/api/YetAnotherConfigLib.java
+++ b/src/main/java/dev/isxander/yacl/api/YetAnotherConfigLib.java
@@ -1,14 +1,17 @@
 package dev.isxander.yacl.api;
 
 import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl.gui.YACLScreen;
 import dev.isxander.yacl.impl.YetAnotherConfigLibImpl;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.text.Text;
 import org.apache.commons.lang3.Validate;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 
 public interface YetAnotherConfigLib {
 
@@ -16,7 +19,11 @@ public interface YetAnotherConfigLib {
 
     ImmutableList<ConfigCategory> categories();
 
-    Screen generateScreen();
+    Runnable saveFunction();
+
+    Consumer<YACLScreen> initConsumer();
+
+    Screen generateScreen(@Nullable Screen parent);
 
     static Builder createBuilder(Text title) {
         return new Builder(title);
@@ -25,31 +32,47 @@ public interface YetAnotherConfigLib {
     class Builder {
         private Text title;
         private final List<ConfigCategory> categories = new ArrayList<>();
+        private Runnable saveFunction = () -> {};
+        private Consumer<YACLScreen> initConsumer = screen -> {};
 
         private Builder(@NotNull Text title) {
             Validate.notNull(title, "`title` cannot be null");
             this.title = title;
         }
 
-        public Builder setTitle(@NotNull Text title) {
+        public Builder title(@NotNull Text title) {
             Validate.notNull(title, "`title` cannot be null");
 
             this.title = title;
             return this;
         }
 
-        public Builder addCategory(@NotNull ConfigCategory category) {
+        public Builder category(@NotNull ConfigCategory category) {
             Validate.notNull(category, "`category` cannot be null");
 
             this.categories.add(category);
             return this;
         }
 
+        public Builder save(@NotNull Runnable saveFunction) {
+            Validate.notNull(saveFunction, "`saveFunction` cannot be null");
+
+            this.saveFunction = saveFunction;
+            return this;
+        }
+
+        public Builder screenInit(@NotNull Consumer<YACLScreen> initConsumer) {
+            Validate.notNull(initConsumer, "`initConsumer` cannot be null");
+
+            this.initConsumer = initConsumer;
+            return this;
+        }
+
         public YetAnotherConfigLib build() {
             Validate.notNull(title, "`title must not be null to build `YetAnotherConfigLib`");
             Validate.notEmpty(categories, "`categories` must not be empty to build `YetAnotherConfigLib`");
 
-            return new YetAnotherConfigLibImpl(title, ImmutableList.copyOf(categories));
+            return new YetAnotherConfigLibImpl(title, ImmutableList.copyOf(categories), saveFunction, initConsumer);
         }
     }
 }
diff --git a/src/main/java/dev/isxander/yacl/api/utils/Dimension.java b/src/main/java/dev/isxander/yacl/api/utils/Dimension.java
index cf7127a..69958b1 100644
--- a/src/main/java/dev/isxander/yacl/api/utils/Dimension.java
+++ b/src/main/java/dev/isxander/yacl/api/utils/Dimension.java
@@ -12,8 +12,29 @@ public interface Dimension<T extends Number> {
     T xLimit();
     T yLimit();
 
+    T centerX();
+    T centerY();
+
     boolean isPointInside(T x, T y);
 
+    Dimension<T> clone();
+
+    Dimension<T> setX(T x);
+    Dimension<T> setY(T y);
+    Dimension<T> setWidth(T width);
+    Dimension<T> setHeight(T height);
+
+    Dimension<T> withX(T x);
+    Dimension<T> withY(T y);
+    Dimension<T> withWidth(T width);
+    Dimension<T> withHeight(T height);
+
+    Dimension<T> move(T x, T y);
+    Dimension<T> expand(T width, T height);
+
+    Dimension<T> moved(T x, T y);
+    Dimension<T> expanded(T width, T height);
+
     static Dimension<Integer> ofInt(int x, int y, int width, int height) {
         return new DimensionIntegerImpl(x, y, width, height);
     }
diff --git a/src/main/java/dev/isxander/yacl/api/utils/OptionUtils.java b/src/main/java/dev/isxander/yacl/api/utils/OptionUtils.java
new file mode 100644
index 0000000..ed51683
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/api/utils/OptionUtils.java
@@ -0,0 +1,28 @@
+package dev.isxander.yacl.api.utils;
+
+import dev.isxander.yacl.api.ConfigCategory;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.OptionGroup;
+import dev.isxander.yacl.api.YetAnotherConfigLib;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class OptionUtils {
+    public static void consumeOptions(YetAnotherConfigLib yacl, Function<Option<?>, Boolean> consumer) {
+        for (ConfigCategory category : yacl.categories()) {
+            for (OptionGroup group : category.groups()) {
+                for (Option<?> option : group.options()) {
+                    if (!consumer.apply(option)) return;
+                }
+            }
+        }
+    }
+
+    public static void forEachOptions(YetAnotherConfigLib yacl, Consumer<Option<?>> consumer) {
+        consumeOptions(yacl, (opt) -> {
+            consumer.accept(opt);
+            return true;
+        });
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/AbstractWidget.java b/src/main/java/dev/isxander/yacl/gui/AbstractWidget.java
index 2a8a519..7affbd4 100644
--- a/src/main/java/dev/isxander/yacl/gui/AbstractWidget.java
+++ b/src/main/java/dev/isxander/yacl/gui/AbstractWidget.java
@@ -1,8 +1,53 @@
 package dev.isxander.yacl.gui;
 
+import com.mojang.blaze3d.systems.RenderSystem;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.font.TextRenderer;
 import net.minecraft.client.gui.Drawable;
+import net.minecraft.client.gui.DrawableHelper;
 import net.minecraft.client.gui.Element;
 import net.minecraft.client.gui.Selectable;
+import net.minecraft.client.gui.widget.ClickableWidget;
+import net.minecraft.client.render.GameRenderer;
+import net.minecraft.client.sound.PositionedSoundInstance;
+import net.minecraft.client.sound.SoundManager;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.sound.SoundEvents;
 
 public abstract class AbstractWidget implements Element, Drawable, Selectable {
+    protected final MinecraftClient client = MinecraftClient.getInstance();
+    protected final TextRenderer textRenderer = client.textRenderer;
+
+    public void tick() {
+
+    }
+
+    protected void drawButtonRect(MatrixStack matrices, int x1, int y1, int x2, int y2, boolean hovered) {
+        if (x1 > x2) {
+            int xx1 = x1;
+            x1 = x2;
+            x2 = xx1;
+        }
+        if (y1 > y2) {
+            int yy1 = y1;
+            y1 = y2;
+            y2 = yy1;
+        }
+        int width = x2 - x1;
+        int height = y2 - y1;
+
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        RenderSystem.setShaderTexture(0, ClickableWidget.WIDGETS_TEXTURE);
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+        int i = hovered ? 2 : 1;
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.enableDepthTest();
+        DrawableHelper.drawTexture(matrices, x1, y1, 0, 0, 46 + i * 20, width / 2, height, 256, 256);
+        DrawableHelper.drawTexture(matrices, x1 + width / 2, y1, 0, 200 - width / 2f, 46 + i * 20, width / 2, height, 256, 256);
+    }
+
+    public void playDownSound() {
+        MinecraftClient.getInstance().getSoundManager().play(PositionedSoundInstance.master(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+    }
 }
diff --git a/src/main/java/dev/isxander/yacl/gui/OptionListWidget.java b/src/main/java/dev/isxander/yacl/gui/OptionListWidget.java
new file mode 100644
index 0000000..6cb7090
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/OptionListWidget.java
@@ -0,0 +1,90 @@
+package dev.isxander.yacl.gui;
+
+import dev.isxander.yacl.api.ConfigCategory;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.OptionGroup;
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.controllers.ControlWidget;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.font.TextRenderer;
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.Selectable;
+import net.minecraft.client.gui.widget.ElementListWidget;
+import net.minecraft.client.util.math.MatrixStack;
+
+import java.util.List;
+
+public class OptionListWidget extends ElementListWidget<OptionListWidget.Entry> {
+
+    public OptionListWidget(ConfigCategory category, YACLScreen screen, MinecraftClient client, int width, int height) {
+        super(client, width / 3 * 2, height, 0, height, 22);
+        left = width - this.width;
+        right = width;
+
+        for (OptionGroup group : category.groups()) {
+            if (!group.isRoot())
+                addEntry(new GroupSeparatorEntry(group));
+            for (Option<?> option : group.options()) {
+                addEntry(new OptionEntry(option.control().provideWidget(screen, null)));
+            }
+        }
+    }
+
+    @Override
+    protected int getScrollbarPositionX() {
+        return left + super.getScrollbarPositionX();
+    }
+
+    public static abstract class Entry extends ElementListWidget.Entry<Entry> {
+
+    }
+
+    private static class OptionEntry extends Entry {
+        private final ControlWidget<?> widget;
+
+        public OptionEntry(ControlWidget<?> widget) {
+            this.widget = widget;
+        }
+
+        @Override
+        public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+            widget.dim = Dimension.ofInt(x, y, entryWidth, 20);
+
+            widget.render(matrices, mouseX, mouseY, tickDelta);
+        }
+
+        @Override
+        public List<? extends Selectable> selectableChildren() {
+            return List.of(widget);
+        }
+
+        @Override
+        public List<? extends Element> children() {
+            return List.of(widget);
+        }
+    }
+
+    private static class GroupSeparatorEntry extends Entry {
+        private final OptionGroup group;
+
+        public GroupSeparatorEntry(OptionGroup group) {
+            this.group = group;
+        }
+
+        @Override
+        public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+            TextRenderer textRenderer = MinecraftClient.getInstance().textRenderer;
+            drawCenteredText(matrices, textRenderer, group.name(), x + entryWidth / 2, y + entryHeight / 2 - textRenderer.fontHeight / 2, -1);
+        }
+
+        @Override
+        public List<? extends Selectable> selectableChildren() {
+            return List.of();
+        }
+
+        @Override
+        public List<? extends Element> children() {
+            return List.of();
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/YACLScreen.java b/src/main/java/dev/isxander/yacl/gui/YACLScreen.java
new file mode 100644
index 0000000..97cc8ed
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/YACLScreen.java
@@ -0,0 +1,150 @@
+package dev.isxander.yacl.gui;
+
+import dev.isxander.yacl.api.ConfigCategory;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.YetAnotherConfigLib;
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.api.utils.OptionUtils;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.Text;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class YACLScreen extends Screen {
+    public final YetAnotherConfigLib config;
+    public int currentCategoryIdx;
+
+    private final Screen parent;
+
+    public OptionListWidget optionList;
+    public final List<ButtonWidget> categoryButtons;
+    public ButtonWidget finishedSaveButton, cancelResetButton, undoButton;
+
+    public YACLScreen(YetAnotherConfigLib config, Screen parent) {
+        super(config.title());
+        this.config = config;
+        this.parent = parent;
+        this.categoryButtons = new ArrayList<>();
+        this.currentCategoryIdx = 0;
+    }
+
+    @Override
+    protected void init() {
+        categoryButtons.clear();
+        int columnWidth = width / 3;
+        int padding = columnWidth / 20;
+        Dimension<Integer> categoryDim = Dimension.ofInt(padding, padding, columnWidth - padding * 2, 20);
+        int idx = 0;
+        for (ConfigCategory category : config.categories()) {
+            ButtonWidget categoryWidget = new ButtonWidget(
+                    categoryDim.x(), categoryDim.y(),
+                    categoryDim.width(), categoryDim.height(),
+                    category.name(),
+                    (btn) -> changeCategory(categoryButtons.indexOf(btn))
+            );
+            if (idx == currentCategoryIdx)
+                categoryWidget.active = false;
+            categoryButtons.add(categoryWidget);
+            addDrawableChild(categoryWidget);
+
+            idx++;
+            categoryDim = categoryDim.moved(0, 21);
+        }
+
+        Dimension<Integer> actionDim = Dimension.ofInt(padding, height - padding - 20, columnWidth - padding * 2, 20);
+        finishedSaveButton = new ButtonWidget(actionDim.x(), actionDim.y(), actionDim.width(), actionDim.height(), Text.empty(), (btn) -> {
+            if (pendingChanges()) {
+                OptionUtils.forEachOptions(config, Option::applyValue);
+                config.saveFunction().run();
+            } else close();
+        });
+        actionDim = actionDim.moved(0, -22).expanded(-actionDim.width() / 2 - 2, 0);
+        cancelResetButton = new ButtonWidget(actionDim.x(), actionDim.y(), actionDim.width(), actionDim.height(), Text.translatable("yacl.gui.cancel"), (btn) -> {
+            if (pendingChanges()) {
+                OptionUtils.forEachOptions(config, Option::forgetPendingValue);
+                close();
+            } else {
+                OptionUtils.forEachOptions(config, Option::requestSetDefault);
+            }
+
+        });
+        actionDim = actionDim.moved(actionDim.width() + 4, 0);
+        undoButton = new ButtonWidget(actionDim.x(), actionDim.y(), actionDim.width(), actionDim.height(), Text.translatable("yacl.gui.undo"), (btn) -> {
+            OptionUtils.forEachOptions(config, Option::forgetPendingValue);
+        });
+
+        updateActionAvailability();
+        addDrawableChild(finishedSaveButton);
+        addDrawableChild(cancelResetButton);
+        addDrawableChild(undoButton);
+
+        ConfigCategory currentCategory = config.categories().get(currentCategoryIdx);
+        optionList = new OptionListWidget(currentCategory, this, client, width, height);
+        addSelectableChild(optionList);
+
+        config.initConsumer().accept(this);
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        renderBackground(matrices);
+
+        super.render(matrices, mouseX, mouseY, delta);
+
+        optionList.render(matrices, mouseX, mouseY, delta);
+    }
+
+    @Override
+    public void tick() {
+        updateActionAvailability();
+    }
+
+    private void changeCategory(int idx) {
+        int currentIndex = 0;
+        for (ButtonWidget categoryWidget : categoryButtons) {
+            categoryWidget.active = currentIndex != idx;
+            currentIndex++;
+        }
+        currentCategoryIdx = idx;
+        refreshGUI();
+    }
+
+    private boolean pendingChanges() {
+        AtomicBoolean pendingChanges = new AtomicBoolean(false);
+        OptionUtils.consumeOptions(config, (option) -> {
+            if (option.changed()) {
+                pendingChanges.set(true);
+                return false;
+            }
+            return true;
+        });
+
+        return pendingChanges.get();
+    }
+
+    private void updateActionAvailability() {
+        boolean pendingChanges = pendingChanges();
+
+        undoButton.active = pendingChanges;
+        finishedSaveButton.setMessage(pendingChanges ? Text.translatable("yacl.gui.save") : Text.translatable("yacl.gui.finished"));
+        cancelResetButton.setMessage(pendingChanges ? Text.translatable("yacl.gui.cancel") : Text.translatable("yacl.gui.reset"));
+    }
+
+    private void refreshGUI() {
+        init(client, width, height);
+    }
+
+    @Override
+    public boolean shouldCloseOnEsc() {
+        return !undoButton.active;
+    }
+
+    @Override
+    public void close() {
+        client.setScreen(parent);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/ActionControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/ActionControl.java
new file mode 100644
index 0000000..66e8e35
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/ActionControl.java
@@ -0,0 +1,58 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.ButtonOption;
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.utils.Dimension;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+
+public class ActionControl implements Control<Runnable> {
+    private final ButtonOption option;
+    private final Text executeText;
+
+    public ActionControl(ButtonOption option) {
+        this(option, Text.translatable("yacl.control.action.execute"));
+    }
+
+    public ActionControl(ButtonOption option, Text executeText) {
+        this.option = option;
+        this.executeText = executeText;
+
+    }
+
+    @Override
+    public ButtonOption option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return executeText;
+    }
+
+    @Override
+    public ControlWidget<ActionControl> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new ActionControlElement(this, screen, widgetDimension);
+    }
+
+    public static class ActionControlElement extends ControlWidget<ActionControl> {
+        public ActionControlElement(ActionControl control, Screen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (isMouseOver(mouseX, mouseY)) {
+                playDownSound();
+                control.option().action().run();
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return getUnhoveredControlWidth();
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/ControlWidget.java b/src/main/java/dev/isxander/yacl/gui/controllers/ControlWidget.java
new file mode 100644
index 0000000..be05ba4
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/ControlWidget.java
@@ -0,0 +1,125 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.AbstractWidget;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.narration.NarrationMessageBuilder;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.OrderedText;
+import net.minecraft.text.Text;
+
+import java.util.List;
+
+public abstract class ControlWidget<T extends Control<?>> extends AbstractWidget {
+    protected final T control;
+    protected final List<OrderedText> wrappedDescription;
+
+    public Dimension<Integer> dim;
+    protected final Screen screen;
+
+    protected boolean hovered = false;
+    protected float hoveredTicks = 0;
+
+    public ControlWidget(T control, Screen screen, Dimension<Integer> dim) {
+        this.control = control;
+        this.dim = dim;
+        this.screen = screen;
+        this.wrappedDescription = textRenderer.wrapLines(control.option().tooltip(), screen.width / 2);
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        hovered = isMouseOver(mouseX, mouseY);
+        if (hovered) {
+            hoveredTicks += delta;
+        } else {
+            hoveredTicks = 0;
+        }
+
+        Text name = control.option().name();
+        String nameString = name.getString();
+
+        boolean firstIter = true;
+        while (textRenderer.getWidth(nameString) > dim.width() - getControlWidth() - getXPadding() - 7) {
+            nameString = nameString.substring(0, nameString.length() - (firstIter ? 2 : 5)).trim();
+            nameString += "...";
+
+            firstIter = false;
+        }
+
+        Text shortenedName = Text.literal(nameString).fillStyle(name.getStyle());
+
+        drawButtonRect(matrices, dim.x(), dim.y(), dim.xLimit(), dim.yLimit(), hovered);
+        matrices.push();
+        matrices.translate(dim.x() + getXPadding(), getTextY(), 0);
+        textRenderer.drawWithShadow(matrices, shortenedName, 0, 0, -1);
+        matrices.pop();
+
+        drawValueText(matrices);
+        if (hovered) {
+            drawHoveredControl(matrices, mouseX, mouseY, delta);
+        }
+
+        if (hoveredTicks > 40) {
+            screen.renderOrderedTooltip(matrices, wrappedDescription, mouseX, mouseY);
+        }
+    }
+
+    protected void drawHoveredControl(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+
+    }
+
+    protected void drawValueText(MatrixStack matrices) {
+        Text valueText = control.formatValue();
+        matrices.push();
+        matrices.translate(dim.xLimit() - textRenderer.getWidth(valueText) - getXPadding(), getTextY(), 0);
+        textRenderer.drawWithShadow(matrices, valueText, 0, 0, -1);
+        matrices.pop();
+    }
+
+    @Override
+    public boolean isMouseOver(double mouseX, double mouseY) {
+        return this.dim.isPointInside((int) mouseX, (int) mouseY);
+    }
+
+    protected int getControlWidth() {
+        return hovered ? getHoveredControlWidth() : getUnhoveredControlWidth();
+    }
+
+    protected abstract int getHoveredControlWidth();
+
+    protected int getUnhoveredControlWidth() {
+        return textRenderer.getWidth(control.formatValue());
+    }
+
+    protected int getXPadding() {
+        return 5;
+    }
+
+    protected int getYPadding() {
+        return 2;
+    }
+
+    protected void drawOutline(MatrixStack matrices, int x1, int y1, int x2, int y2, int width, int color) {
+        DrawableHelper.fill(matrices, x1, y1, x2, y1 + width, color);
+        DrawableHelper.fill(matrices, x2, y1, x2 - width, y2, color);
+        DrawableHelper.fill(matrices, x1, y2, x2, y2 - width, color);
+        DrawableHelper.fill(matrices, x1, y1, x1 + width, y2, color);
+    }
+
+    protected float getTextY() {
+        return dim.y() + dim.height() / 2f - textRenderer.fontHeight / 2f;
+    }
+
+    @Override
+    public SelectionType getType() {
+        return hovered ? SelectionType.HOVERED : SelectionType.NONE;
+    }
+
+    @Override
+    public void appendNarrations(NarrationMessageBuilder builder) {
+
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/EnumControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/EnumControl.java
new file mode 100644
index 0000000..d032937
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/EnumControl.java
@@ -0,0 +1,77 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.NameableEnum;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.utils.Dimension;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+
+import java.util.function.Function;
+
+public class EnumControl<T extends Enum<T>> implements Control<T> {
+    private final Option<T> option;
+    private final Function<T, Text> valueFormatter;
+    private final Class<T> enumClass;
+
+    public EnumControl(Option<T> option, Class<T> enumClass) {
+        this(option, enumClass, value -> {
+            if (value instanceof NameableEnum nameableEnum)
+                return nameableEnum.getDisplayName();
+            return Text.of(value.name());
+        });
+    }
+
+    public EnumControl(Option<T> option, Class<T> enumClass, Function<T, Text> valueFormatter) {
+        this.option = option;
+        this.valueFormatter = valueFormatter;
+        this.enumClass = enumClass;
+    }
+
+    @Override
+    public Option<T> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public ControlWidget<EnumControl<T>> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new EnumControlElement<>(this, screen, widgetDimension, enumClass.getEnumConstants());
+    }
+
+    public static class EnumControlElement<T extends Enum<T>> extends ControlWidget<EnumControl<T>> {
+        private final T[] values;
+
+        public EnumControlElement(EnumControl<T> control, Screen screen, Dimension<Integer> dim, T[] values) {
+            super(control, screen, dim);
+            this.values = values;
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY) || (button != 0 && button != 1))
+                return false;
+
+            playDownSound();
+
+            int change = button == 1 || Screen.hasShiftDown() ? -1 : 1;
+            int targetIdx = control.option().pendingValue().ordinal() + change;
+            if (targetIdx >= values.length) {
+                targetIdx -= values.length;
+            } else if (targetIdx < 0) {
+                targetIdx += values.length;
+            }
+            control.option().requestSet(values[targetIdx]);
+            return true;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return getUnhoveredControlWidth();
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/TickBoxControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/TickBoxControl.java
new file mode 100644
index 0000000..fb0e595
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/TickBoxControl.java
@@ -0,0 +1,100 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.utils.Dimension;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.Text;
+import net.minecraft.util.Formatting;
+
+import java.util.function.Function;
+
+public class TickBoxControl implements Control<Boolean> {
+
+    public static final Function<Boolean, Text> ON_OFF_FORMATTER = (state) ->
+            state
+                    ? Text.translatable("yacl.control.tickbox.on").formatted(Formatting.GREEN)
+                    : Text.translatable("yacl.control.tickbox.off").formatted(Formatting.RED);
+
+    public static final Function<Boolean, Text> TRUE_FALSE_FORMATTER = (state) ->
+            state
+                    ? Text.translatable("yacl.control.tickbox.true").formatted(Formatting.GREEN)
+                    : Text.translatable("yacl.control.tickbox.false").formatted(Formatting.RED);
+
+    public static final Function<Boolean, Text> YES_NO_FORMATTER = (state) ->
+            state
+                    ? Text.translatable("yacl.control.tickbox.yes").formatted(Formatting.GREEN)
+                    : Text.translatable("yacl.control.tickbox.no").formatted(Formatting.RED);
+
+    private final Option<Boolean> option;
+    private final Function<Boolean, Text> valueFormatter;
+
+    public TickBoxControl(Option<Boolean> option) {
+        this(option, ON_OFF_FORMATTER);
+    }
+
+    public TickBoxControl(Option<Boolean> option, Function<Boolean, Text> valueFormatter) {
+        this.option = option;
+        this.valueFormatter = valueFormatter;
+
+    }
+
+    @Override
+    public Option<Boolean> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public ControlWidget<TickBoxControl> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new TickBoxControlElement(this, screen, widgetDimension);
+    }
+
+    public static class TickBoxControlElement extends ControlWidget<TickBoxControl> {
+        private TickBoxControlElement(TickBoxControl control, Screen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+        }
+
+        @Override
+        protected void drawHoveredControl(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+            int outlineSize = 10;
+            int outlineX1 = dim.xLimit() - getXPadding() - outlineSize;
+            int outlineY1 = dim.centerY() - outlineSize / 2;
+            int outlineX2 = dim.xLimit() - getXPadding();
+            int outlineY2 = dim.centerY() + outlineSize / 2;
+            drawOutline(matrices, outlineX1 + 1, outlineY1 + 1, outlineX2 + 1, outlineY2 + 1, 1, 0xFF404040);
+            drawOutline(matrices, outlineX1, outlineY1, outlineX2, outlineY2, 1, -1);
+            if (control.option().pendingValue()) {
+                DrawableHelper.fill(matrices, outlineX1 + 3, outlineY1 + 3, outlineX2 - 1, outlineY2 - 1, 0xFF404040);
+                DrawableHelper.fill(matrices, outlineX1 + 2, outlineY1 + 2, outlineX2 - 2, outlineY2 - 2, -1);
+            }
+        }
+
+        @Override
+        protected void drawValueText(MatrixStack matrices) {
+            if (!hovered)
+                super.drawValueText(matrices);
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY))
+                return false;
+
+            control.option().requestSet(!control.option().pendingValue());
+            playDownSound();
+            return true;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return 10;
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/DoubleSliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/DoubleSliderControl.java
new file mode 100644
index 0000000..5aaa6c4
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/DoubleSliderControl.java
@@ -0,0 +1,72 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Option;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class DoubleSliderControl implements ISliderControl<Double> {
+    public static final Function<Double, Text> DEFAULT_FORMATTER = value -> Text.of(String.format("%.2f", value));
+
+    private final Option<Double> option;
+
+    private final double min, max, interval;
+
+    private final Function<Double, Text> valueFormatter;
+
+    public DoubleSliderControl(Option<Double> option, double min, double max, double interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    public DoubleSliderControl(Option<Double> option, double min, double max, double interval, Function<Double, Text> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    @Override
+    public Option<Double> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public double min() {
+        return min;
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet(value);
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public Text getValueText(double value) {
+        return valueFormatter.apply(value);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/FloatSliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/FloatSliderControl.java
new file mode 100644
index 0000000..d74ec33
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/FloatSliderControl.java
@@ -0,0 +1,72 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Option;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class FloatSliderControl implements ISliderControl<Float> {
+    public static final Function<Float, Text> DEFAULT_FORMATTER = value -> Text.of(String.format("%.1f", value));
+
+    private final Option<Float> option;
+
+    private final float min, max, interval;
+
+    private final Function<Float, Text> valueFormatter;
+
+    public FloatSliderControl(Option<Float> option, float min, float max, float interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    public FloatSliderControl(Option<Float> option, float min, float max, float interval, Function<Float, Text> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    @Override
+    public Option<Float> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public double min() {
+        return min;
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((float) value);
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public Text getValueText(double value) {
+        return valueFormatter.apply((float) value);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/ISliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/ISliderControl.java
new file mode 100644
index 0000000..8c1cdf8
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/ISliderControl.java
@@ -0,0 +1,29 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.controllers.ControlWidget;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+
+public interface ISliderControl<T extends Number> extends Control<T> {
+    double min();
+
+    double max();
+
+    double interval();
+
+    default double range() {
+        return max() - min();
+    }
+
+    void setPendingValue(double value);
+    double pendingValue();
+
+    Text getValueText(double value);
+
+    @Override
+    default ControlWidget<?> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new SliderControlElement(this, screen, widgetDimension, min(), max(), interval());
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/IntegerSliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/IntegerSliderControl.java
new file mode 100644
index 0000000..99c8137
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/IntegerSliderControl.java
@@ -0,0 +1,72 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Option;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class IntegerSliderControl implements ISliderControl<Integer> {
+    public static final Function<Integer, Text> DEFAULT_FORMATTER = value -> Text.of(String.valueOf(value));
+
+    private final Option<Integer> option;
+
+    private final int min, max, interval;
+
+    private final Function<Integer, Text> valueFormatter;
+
+    public IntegerSliderControl(Option<Integer> option, int min, int max, int interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    public IntegerSliderControl(Option<Integer> option, int min, int max, int interval, Function<Integer, Text> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    @Override
+    public Option<Integer> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public double min() {
+        return min;
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((int) value);
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public Text getValueText(double value) {
+        return valueFormatter.apply((int) value);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/SliderControlElement.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/SliderControlElement.java
new file mode 100644
index 0000000..b8dab71
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/SliderControlElement.java
@@ -0,0 +1,125 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.controllers.ControlWidget;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.Text;
+import net.minecraft.util.math.MathHelper;
+
+public class SliderControlElement extends ControlWidget<ISliderControl<?>> {
+    private final double min, max, interval;
+
+    private float interpolation;
+
+    private Dimension<Integer> sliderBounds;
+
+    private boolean mouseDown = false;
+
+    public SliderControlElement(ISliderControl<?> option, Screen screen, Dimension<Integer> dim, double min, double max, double interval) {
+        super(option, screen, dim);
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        super.render(matrices, mouseX, mouseY, delta);
+
+        if (sliderBounds == null)
+            sliderBounds = Dimension.ofInt(dim.xLimit() - getXPadding() - getThumbWidth() / 2 - dim.width() / 3, dim.centerY() - 4, dim.width() / 3, 8);
+        calculateInterpolation();
+    }
+
+    @Override
+    protected void drawHoveredControl(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        // track
+        DrawableHelper.fill(matrices, sliderBounds.x(), sliderBounds.centerY() - 1, sliderBounds.xLimit(), sliderBounds.centerY(), -1);
+        // track shadow
+        DrawableHelper.fill(matrices, sliderBounds.x() + 1, sliderBounds.centerY(), sliderBounds.xLimit() + 1, sliderBounds.centerY() + 1, 0xFF404040);
+
+        // thumb shadow
+        DrawableHelper.fill(matrices, getThumbX() - getThumbWidth() / 2 + 1, sliderBounds.y() + 1, getThumbX() + getThumbWidth() / 2 + 1, sliderBounds.yLimit() + 1, 0xFF404040);
+        // thumb
+        DrawableHelper.fill(matrices, getThumbX() - getThumbWidth() / 2, sliderBounds.y(), getThumbX() + getThumbWidth() / 2, sliderBounds.yLimit(), -1);
+    }
+
+    @Override
+    protected void drawValueText(MatrixStack matrices) {
+        matrices.push();
+        if (hovered)
+            matrices.translate(-(sliderBounds.width() + 6 + getThumbWidth() / 2f), 0, 0);
+        super.drawValueText(matrices);
+        matrices.pop();
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if (button != 0 || !sliderBounds.isPointInside((int) mouseX, (int) mouseY))
+            return false;
+
+        mouseDown = true;
+
+        setValueFromMouse(mouseX);
+        return true;
+    }
+
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int button, double deltaX, double deltaY) {
+        if (button != 0 || !sliderBounds.isPointInside((int) mouseX, (int) mouseY))
+            return false;
+
+        setValueFromMouse(mouseX);
+        return true;
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        if (!isMouseOver(mouseX, mouseY) || !Screen.hasShiftDown())
+            return false;
+
+        control.setPendingValue(MathHelper.clamp(control.pendingValue() + interval * amount, min, max));
+        calculateInterpolation();
+        return true;
+    }
+
+    @Override
+    public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        if (mouseDown)
+            playDownSound();
+        mouseDown = false;
+
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    private void setValueFromMouse(double mouseX) {
+        double value = (mouseX - sliderBounds.x()) / sliderBounds.width() * control.range();
+        double roundedValue = min + (interval * Math.round(value / interval));
+        control.setPendingValue(roundedValue);
+        calculateInterpolation();
+    }
+
+    @Override
+    protected int getHoveredControlWidth() {
+        int textWidth = textRenderer.getWidth(getValueText());
+        return hovered ? sliderBounds.width() + textWidth + 6 + getThumbWidth() / 2 : textWidth ;
+    }
+
+    private void calculateInterpolation() {
+        interpolation = (float) ((control.pendingValue() - control.min()) * 1 / control.range());
+    }
+
+    private Text getValueText() {
+        return control.getValueText(control.pendingValue());
+    }
+
+    private int getThumbX() {
+        return (int) (sliderBounds.x() + sliderBounds.width() * interpolation);
+    }
+
+    private int getThumbWidth() {
+        return 4;
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/impl/ButtonOptionImpl.java b/src/main/java/dev/isxander/yacl/impl/ButtonOptionImpl.java
new file mode 100644
index 0000000..516a5ee
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/impl/ButtonOptionImpl.java
@@ -0,0 +1,105 @@
+package dev.isxander.yacl.impl;
+
+import dev.isxander.yacl.api.Binding;
+import dev.isxander.yacl.api.ButtonOption;
+import dev.isxander.yacl.api.Control;
+import net.minecraft.text.Text;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+
+@ApiStatus.Internal
+public class ButtonOptionImpl implements ButtonOption {
+    private final Text name;
+    private final Text tooltip;
+    private final Runnable action;
+    private final Control<Runnable> control;
+    private final Binding<Runnable> binding;
+
+    public ButtonOptionImpl(
+            @NotNull Text name,
+            @Nullable Text tooltip,
+            @NotNull Runnable action,
+            @NotNull Function<ButtonOption, Control<Runnable>> controlGetter
+    ) {
+        this.name = name;
+        this.tooltip = tooltip;
+        this.action = action;
+        this.control = controlGetter.apply(this);
+        this.binding = new EmptyBinderImpl();
+    }
+
+    @Override
+    public @NotNull Text name() {
+        return name;
+    }
+
+    @Override
+    public @Nullable Text tooltip() {
+        return tooltip;
+    }
+
+    @Override
+    public Runnable action() {
+        return action;
+    }
+
+    @Override
+    public @NotNull Control<Runnable> control() {
+        return control;
+    }
+
+    @Override
+    public @NotNull Binding<Runnable> binding() {
+        return binding;
+    }
+
+    @Override
+    public boolean changed() {
+        return false;
+    }
+
+    @Override
+    public Runnable pendingValue() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void requestSet(Runnable value) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void applyValue() {
+
+    }
+
+    @Override
+    public void forgetPendingValue() {
+
+    }
+
+    @Override
+    public void requestSetDefault() {
+
+    }
+
+    private static class EmptyBinderImpl implements Binding<Runnable> {
+        @Override
+        public void setValue(Runnable value) {
+
+        }
+
+        @Override
+        public Runnable getValue() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public Runnable defaultValue() {
+            throw new UnsupportedOperationException();
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/impl/ConfigCategoryImpl.java b/src/main/java/dev/isxander/yacl/impl/ConfigCategoryImpl.java
index 0f6f33b..27bd60c 100644
--- a/src/main/java/dev/isxander/yacl/impl/ConfigCategoryImpl.java
+++ b/src/main/java/dev/isxander/yacl/impl/ConfigCategoryImpl.java
@@ -2,11 +2,11 @@ package dev.isxander.yacl.impl;
 
 import com.google.common.collect.ImmutableList;
 import dev.isxander.yacl.api.ConfigCategory;
-import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.OptionGroup;
 import net.minecraft.text.Text;
 import org.jetbrains.annotations.ApiStatus;
 
 @ApiStatus.Internal
-public record ConfigCategoryImpl(Text name, ImmutableList<Option<?>> options) implements ConfigCategory {
+public record ConfigCategoryImpl(Text name, ImmutableList<OptionGroup> groups) implements ConfigCategory {
 
 }
diff --git a/src/main/java/dev/isxander/yacl/impl/GenericBindingImpl.java b/src/main/java/dev/isxander/yacl/impl/GenericBindingImpl.java
index f2321c7..9dfe2b0 100644
--- a/src/main/java/dev/isxander/yacl/impl/GenericBindingImpl.java
+++ b/src/main/java/dev/isxander/yacl/impl/GenericBindingImpl.java
@@ -30,7 +30,8 @@ public class GenericBindingImpl<T> implements Binding<T> {
     }
 
     @Override
-    public void resetValue() {
-        setValue(def);
+    public T defaultValue() {
+        return def;
     }
+
 }
diff --git a/src/main/java/dev/isxander/yacl/impl/OptionGroupImpl.java b/src/main/java/dev/isxander/yacl/impl/OptionGroupImpl.java
new file mode 100644
index 0000000..73bff07
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/impl/OptionGroupImpl.java
@@ -0,0 +1,10 @@
+package dev.isxander.yacl.impl;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.OptionGroup;
+import net.minecraft.text.Text;
+import org.jetbrains.annotations.Nullable;
+
+public record OptionGroupImpl(@Nullable Text name, ImmutableList<Option<?>> options, boolean isRoot) implements OptionGroup {
+}
diff --git a/src/main/java/dev/isxander/yacl/impl/OptionImpl.java b/src/main/java/dev/isxander/yacl/impl/OptionImpl.java
index 3f6e5c2..a62726f 100644
--- a/src/main/java/dev/isxander/yacl/impl/OptionImpl.java
+++ b/src/main/java/dev/isxander/yacl/impl/OptionImpl.java
@@ -8,6 +8,8 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.function.Function;
+
 @ApiStatus.Internal
 public class OptionImpl<T> implements Option<T> {
     private final Text name;
@@ -15,16 +17,19 @@ public class OptionImpl<T> implements Option<T> {
     private final Control<T> control;
     private final Binding<T> binding;
 
-    private @Nullable T changedValue = null;
+    private T pendingValue;
 
-    public OptionImpl(@NotNull Text name,
-                      @Nullable Text tooltip,
-                      @NotNull Control<T> control,
-                      @NotNull Binding<T> binding) {
+    public OptionImpl(
+            @NotNull Text name,
+            @Nullable Text tooltip,
+            @NotNull Function<Option<T>, Control<T>> controlGetter,
+            @NotNull Binding<T> binding
+    ) {
         this.name = name;
         this.tooltip = tooltip;
-        this.control = control;
+        this.control = controlGetter.apply(this);
         this.binding = binding;
+        this.pendingValue = binding().getValue();
     }
 
     @Override
@@ -49,17 +54,31 @@ public class OptionImpl<T> implements Option<T> {
 
     @Override
     public boolean changed() {
-        return !binding().getValue().equals(changedValue);
+        return !binding().getValue().equals(pendingValue);
+    }
+
+    @Override
+    public T pendingValue() {
+        return pendingValue;
     }
 
     @Override
     public void requestSet(T value) {
-        this.changedValue = value;
+        pendingValue = value;
     }
 
     @Override
     public void applyValue() {
-        if (changedValue != null)
-            binding().setValue(changedValue);
+        binding().setValue(pendingValue);
+    }
+
+    @Override
+    public void forgetPendingValue() {
+        pendingValue = binding().getValue();
+    }
+
+    @Override
+    public void requestSetDefault() {
+        pendingValue = binding().defaultValue();
     }
 }
diff --git a/src/main/java/dev/isxander/yacl/impl/YetAnotherConfigLibImpl.java b/src/main/java/dev/isxander/yacl/impl/YetAnotherConfigLibImpl.java
index 0cef49f..5938bad 100644
--- a/src/main/java/dev/isxander/yacl/impl/YetAnotherConfigLibImpl.java
+++ b/src/main/java/dev/isxander/yacl/impl/YetAnotherConfigLibImpl.java
@@ -3,14 +3,17 @@ package dev.isxander.yacl.impl;
 import com.google.common.collect.ImmutableList;
 import dev.isxander.yacl.api.ConfigCategory;
 import dev.isxander.yacl.api.YetAnotherConfigLib;
+import dev.isxander.yacl.gui.YACLScreen;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.text.Text;
 import org.jetbrains.annotations.ApiStatus;
 
+import java.util.function.Consumer;
+
 @ApiStatus.Internal
-public record YetAnotherConfigLibImpl(Text title, ImmutableList<ConfigCategory> categories) implements YetAnotherConfigLib {
+public record YetAnotherConfigLibImpl(Text title, ImmutableList<ConfigCategory> categories, Runnable saveFunction, Consumer<YACLScreen> initConsumer) implements YetAnotherConfigLib {
     @Override
-    public Screen generateScreen() {
-        return null;
+    public Screen generateScreen(Screen parent) {
+        return new YACLScreen(this, parent);
     }
 }
diff --git a/src/main/java/dev/isxander/yacl/impl/utils/DimensionIntegerImpl.java b/src/main/java/dev/isxander/yacl/impl/utils/DimensionIntegerImpl.java
index 908157d..4cb1c0e 100644
--- a/src/main/java/dev/isxander/yacl/impl/utils/DimensionIntegerImpl.java
+++ b/src/main/java/dev/isxander/yacl/impl/utils/DimensionIntegerImpl.java
@@ -4,7 +4,37 @@ import dev.isxander.yacl.api.utils.Dimension;
 import org.jetbrains.annotations.ApiStatus;
 
 @ApiStatus.Internal
-public record DimensionIntegerImpl(Integer x, Integer y, Integer width, Integer height) implements Dimension<Integer> {
+public class DimensionIntegerImpl implements Dimension<Integer> {
+    private int x, y;
+    private int width, height;
+
+    public DimensionIntegerImpl(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public Integer x() {
+        return x;
+    }
+
+    @Override
+    public Integer y() {
+        return y;
+    }
+
+    @Override
+    public Integer width() {
+        return width;
+    }
+
+    @Override
+    public Integer height() {
+        return height;
+    }
+
     @Override
     public Integer xLimit() {
         return x + width;
@@ -16,7 +46,71 @@ public record DimensionIntegerImpl(Integer x, Integer y, Integer width, Integer
     }
 
     @Override
+    public Integer centerX() {
+        return x + width / 2;
+    }
+
+    @Override
+    public Integer centerY() {
+        return y + height / 2;
+    }
+
+    @Override
     public boolean isPointInside(Integer x, Integer y) {
         return x >= x() && x <= xLimit() && y >= y() && y <= yLimit();
     }
+
+    @Override
+    public Dimension<Integer> clone() {
+        return new DimensionIntegerImpl(x, y, width, height);
+    }
+
+    @Override public Dimension<Integer> setX(Integer x) { this.x = x; return this; }
+    @Override public Dimension<Integer> setY(Integer y) { this.y = y; return this; }
+    @Override public Dimension<Integer> setWidth(Integer width) { this.width = width; return this; }
+    @Override public Dimension<Integer> setHeight(Integer height) { this.height = height; return this; }
+
+    @Override
+    public Dimension<Integer> withX(Integer x) {
+        return clone().setX(x);
+    }
+
+    @Override
+    public Dimension<Integer> withY(Integer y) {
+        return clone().setY(y);
+    }
+
+    @Override
+    public Dimension<Integer> withWidth(Integer width) {
+        return clone().withWidth(width);
+    }
+
+    @Override
+    public Dimension<Integer> withHeight(Integer height) {
+        return clone().withHeight(height);
+    }
+
+    @Override
+    public Dimension<Integer> move(Integer x, Integer y) {
+        this.x += x;
+        this.y += y;
+        return this;
+    }
+
+    @Override
+    public Dimension<Integer> expand(Integer width, Integer height) {
+        this.width += width;
+        this.height += height;
+        return this;
+    }
+
+    @Override
+    public Dimension<Integer> moved(Integer x, Integer y) {
+        return clone().move(x, y);
+    }
+
+    @Override
+    public Dimension<Integer> expanded(Integer width, Integer height) {
+        return clone().expand(width, height);
+    }
 }
diff --git a/src/main/resources/assets/yet-another-config-lib/lang/en_us.json b/src/main/resources/assets/yet-another-config-lib/lang/en_us.json
new file mode 100644
index 0000000..7f609d3
--- /dev/null
+++ b/src/main/resources/assets/yet-another-config-lib/lang/en_us.json
@@ -0,0 +1,16 @@
+{
+  "yacl.control.tickbox.on": "ON",
+  "yacl.control.tickbox.off": "OFF",
+  "yacl.control.tickbox.true": "True",
+  "yacl.control.tickbox.false": "False",
+  "yacl.control.tickbox.yes": "Yes",
+  "yacl.control.tickbox.no": "No",
+
+  "yacl.control.action.execute": "EXECUTE",
+
+  "yacl.gui.save": "Save Changes",
+  "yacl.gui.finished": "Finished",
+  "yacl.gui.cancel": "Cancel",
+  "yacl.gui.reset": "Reset",
+  "yacl.gui.undo": "Undo"
+}
diff --git a/src/testmod/java/dev/isxander/yacl/test/ModMenuIntegration.java b/src/testmod/java/dev/isxander/yacl/test/ModMenuIntegration.java
new file mode 100644
index 0000000..f328ab4
--- /dev/null
+++ b/src/testmod/java/dev/isxander/yacl/test/ModMenuIntegration.java
@@ -0,0 +1,137 @@
+package dev.isxander.yacl.test;
+
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import com.terraformersmc.modmenu.api.ModMenuApi;
+import dev.isxander.yacl.api.*;
+import dev.isxander.yacl.gui.controllers.ActionControl;
+import dev.isxander.yacl.gui.controllers.EnumControl;
+import dev.isxander.yacl.gui.controllers.TickBoxControl;
+import dev.isxander.yacl.gui.controllers.slider.DoubleSliderControl;
+import dev.isxander.yacl.gui.controllers.slider.FloatSliderControl;
+import dev.isxander.yacl.gui.controllers.slider.IntegerSliderControl;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.text.Text;
+
+public class ModMenuIntegration implements ModMenuApi {
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory() {
+        return (parent) -> YetAnotherConfigLib.createBuilder(Text.of("Test GUI"))
+                .category(ConfigCategory.createBuilder()
+                        .name(Text.of("Control Examples"))
+                        .option(Option.createBuilder(boolean.class)
+                                .name(Text.of("Tick Box"))
+                                .tooltip(Text.of("Super long tooltip that is very descriptive to show off the text wrapping features of the thingy yes whwowwoow"))
+                                .binding(
+                                        false,
+                                        () -> TestSettings.tickbox,
+                                        (value) -> TestSettings.tickbox = value
+                                )
+                                .controller(TickBoxControl::new)
+                                .build())
+                        .option(Option.createBuilder(int.class)
+                                .name(Text.of("Int Slider that is cut off because the slider"))
+                                .binding(
+                                        0,
+                                        () -> TestSettings.intSlider,
+                                        (value) -> TestSettings.intSlider = value
+                                )
+                                .controller(opt -> new IntegerSliderControl(opt, 0, 3, 1))
+                                .build())
+                        .option(Option.createBuilder(double.class)
+                                .name(Text.of("Double Slider"))
+                                .binding(
+                                        0.0,
+                                        () -> TestSettings.doubleSlider,
+                                        (value) -> TestSettings.doubleSlider = value
+                                )
+                                .controller(opt -> new DoubleSliderControl(opt, 0, 3, 0.05))
+                                .build())
+                        .option(Option.createBuilder(float.class)
+                                .name(Text.of("Float Slider"))
+                                .binding(
+                                        0f,
+                                        () -> TestSettings.floatSlider,
+                                        (value) -> TestSettings.floatSlider = value
+                                )
+                                .controller(opt -> new FloatSliderControl(opt, 0, 3, 0.1f))
+                                .build())
+                        .option(Option.createBuilder(TestSettings.Alphabet.class)
+                                .name(Text.of("Enum Cycler"))
+                                .binding(
+                                        TestSettings.Alphabet.A,
+                                        () -> TestSettings.enumOption,
+                                        (value) -> TestSettings.enumOption = value
+                                )
+                                .controller(opt -> new EnumControl<>(opt, TestSettings.Alphabet.class))
+                                .build())
+                        .option(ButtonOption.createBuilder()
+                                .name(Text.of("Button \"Option\""))
+                                .action(() -> System.out.println("aha!"))
+                                .controller(ActionControl::new)
+                                .build())
+                        .build())
+                .category(ConfigCategory.createBuilder()
+                        .name(Text.of("Group Test"))
+                        .option(Option.createBuilder(boolean.class)
+                                .name(Text.of("Root Test"))
+                                .binding(
+                                        false,
+                                        () -> TestSettings.groupTestRoot,
+                                        value -> TestSettings.groupTestRoot = value
+                                )
+                                .controller(TickBoxControl::new)
+                                .build())
+                        .group(OptionGroup.createBuilder()
+                                .name(Text.of("First Group"))
+                                .option(Option.createBuilder(boolean.class)
+                                        .name(Text.of("First Group Test 1"))
+                                        .binding(
+                                                false,
+                                                () -> TestSettings.groupTestFirstGroup,
+                                                value -> TestSettings.groupTestFirstGroup = value
+                                        )
+                                        .controller(TickBoxControl::new)
+                                        .build())
+                                .option(Option.createBuilder(boolean.class)
+                                        .name(Text.of("First Group Test 2"))
+                                        .binding(
+                                                false,
+                                                () -> TestSettings.groupTestFirstGroup2,
+                                                value -> TestSettings.groupTestFirstGroup2 = value
+                                        )
+                                        .controller(TickBoxControl::new)
+                                        .build())
+                                .build())
+                        .group(OptionGroup.createBuilder()
+                                .name(Text.empty())
+                                .option(Option.createBuilder(boolean.class)
+                                        .name(Text.of("Second Group Test"))
+                                        .binding(
+                                                false,
+                                                () -> TestSettings.groupTestSecondGroup,
+                                                value -> TestSettings.groupTestSecondGroup = value
+                                        )
+                                        .controller(TickBoxControl::new)
+                                        .build())
+                                .build())
+                        .build())
+                .build().generateScreen(parent);
+    }
+
+    private static class TestSettings {
+        private static boolean tickbox = false;
+        private static int intSlider = 0;
+        private static double doubleSlider = 0;
+        private static float floatSlider = 0;
+        private static Alphabet enumOption = Alphabet.A;
+
+        private static boolean groupTestRoot = false;
+        private static boolean groupTestFirstGroup = false;
+        private static boolean groupTestFirstGroup2 = false;
+        private static boolean groupTestSecondGroup = false;
+
+        public enum Alphabet {
+            A, B, C
+        }
+    }
+}
diff --git a/src/testmod/resources/fabric.mod.json b/src/testmod/resources/fabric.mod.json
new file mode 100644
index 0000000..0d78804
--- /dev/null
+++ b/src/testmod/resources/fabric.mod.json
@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "id": "test-mod",
+  "version": "1",
+  "name": "YACL Test",
+  "authors": [
+    "isXander"
+  ],
+  "license": "LGPL-3.0-or-later",
+  "environment": "client",
+  "entrypoints": {
+    "modmenu": [
+      "dev.isxander.yacl.test.ModMenuIntegration"
+    ]
+  },
+  "depends": {
+    "fabricloader": ">=0.14.0",
+    "minecraft": "1.19.x",
+    "java": ">=17"
+  }
+}