Change package and modid to yacl3 and yet_another_config_lib_3 respectively

45 files changed, 5328 insertions, 0 deletions

diff --git a/common/src/main/java/dev/isxander/yacl3/gui/AbstractWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/AbstractWidget.java
new file mode 100644
index 0000000..8b9779c
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/AbstractWidget.java
@@ -0,0 +1,94 @@
+package dev.isxander.yacl3.gui;
+
+import dev.isxander.yacl3.api.utils.Dimension;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.Renderable;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.resources.sounds.SimpleSoundInstance;
+import net.minecraft.sounds.SoundEvents;
+
+import java.awt.*;
+
+public abstract class AbstractWidget implements GuiEventListener, Renderable, NarratableEntry {
+    protected final Minecraft client = Minecraft.getInstance();
+    protected final Font textRenderer = client.font;
+    protected final int inactiveColor = 0xFFA0A0A0;
+
+    private Dimension<Integer> dim;
+
+    public AbstractWidget(Dimension<Integer> dim) {
+        this.dim = dim;
+    }
+
+    public boolean canReset() {
+        return false;
+    }
+
+    @Override
+    public boolean isMouseOver(double mouseX, double mouseY) {
+        if (dim == null) return false;
+        return this.dim.isPointInside((int) mouseX, (int) mouseY);
+    }
+
+    public void setDimension(Dimension<Integer> dim) {
+        this.dim = dim;
+    }
+
+    public Dimension<Integer> getDimension() {
+        return dim;
+    }
+
+    @Override
+    public NarrationPriority narrationPriority() {
+        return NarrationPriority.NONE;
+    }
+
+    public void unfocus() {
+
+    }
+
+    public boolean matchesSearch(String query) {
+        return true;
+    }
+
+    @Override
+    public void updateNarration(NarrationElementOutput builder) {
+
+    }
+
+    protected void drawButtonRect(GuiGraphics graphics, int x1, int y1, int x2, int y2, boolean hovered, boolean enabled) {
+        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;
+
+        int i = !enabled ? 0 : hovered ? 2 : 1;
+        graphics.blit(net.minecraft.client.gui.components.AbstractWidget.WIDGETS_LOCATION, x1, y1, 0, 0, 46 + i * 20, width / 2, height, 256, 256);
+        graphics.blit(net.minecraft.client.gui.components.AbstractWidget.WIDGETS_LOCATION, x1 + width / 2, y1, 0, 200 - width / 2f, 46 + i * 20, width / 2, height, 256, 256);
+    }
+
+    protected int multiplyColor(int hex, float amount) {
+        Color color = new Color(hex, true);
+
+        return new Color(Math.max((int)(color.getRed() * amount), 0),
+                  Math.max((int)(color.getGreen() * amount), 0),
+                  Math.max((int)(color.getBlue() * amount), 0),
+                  color.getAlpha()).getRGB();
+    }
+
+    public void playDownSound() {
+        Minecraft.getInstance().getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/DescriptionWithName.java b/common/src/main/java/dev/isxander/yacl3/gui/DescriptionWithName.java
new file mode 100644
index 0000000..6ad72e8
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/DescriptionWithName.java
@@ -0,0 +1,11 @@
+package dev.isxander.yacl3.gui;
+
+import dev.isxander.yacl3.api.OptionDescription;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+
+public record DescriptionWithName(Component name, OptionDescription description) {
+    public static DescriptionWithName of(Component name, OptionDescription description) {
+        return new DescriptionWithName(name.copy().withStyle(ChatFormatting.BOLD), description);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/ElementListWidgetExt.java b/common/src/main/java/dev/isxander/yacl3/gui/ElementListWidgetExt.java
new file mode 100644
index 0000000..e3944ee
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/ElementListWidgetExt.java
@@ -0,0 +1,222 @@
+package dev.isxander.yacl3.gui;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.ContainerObjectSelectionList;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.layouts.LayoutElement;
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+
+public class ElementListWidgetExt<E extends ElementListWidgetExt.Entry<E>> extends ContainerObjectSelectionList<E> implements LayoutElement {
+    protected int x, y;
+
+    private double smoothScrollAmount = getScrollAmount();
+    private boolean returnSmoothAmount = false;
+    private final boolean doSmoothScrolling;
+
+    public ElementListWidgetExt(Minecraft client, int x, int y, int width, int height, boolean smoothScrolling) {
+        super(client, width, height, y, y + height, 22);
+        this.x = this.x0 = x;
+        this.y = y;
+        this.x1 = this.x0 + width;
+        this.doSmoothScrolling = smoothScrolling;
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        // default implementation bases scroll step from total height of entries, this is constant
+        this.setScrollAmount(this.getScrollAmount() - amount * 20);
+        return true;
+    }
+
+    @Override
+    protected void renderBackground(GuiGraphics graphics) {
+        // render transparent background if in-game.
+        setRenderBackground(true);
+        setRenderTopAndBottom(false);
+    }
+
+    @Override
+    protected int getScrollbarPosition() {
+        // default implementation does not respect left/right
+        return this.x1 - 2;
+    }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        smoothScrollAmount = Mth.lerp(Minecraft.getInstance().getDeltaFrameTime() * 0.5, smoothScrollAmount, getScrollAmount());
+        returnSmoothAmount = true;
+
+        graphics.enableScissor(x0, y0, x1, y1);
+
+        super.render(graphics, mouseX, mouseY, delta);
+
+        graphics.disableScissor();
+
+        returnSmoothAmount = false;
+    }
+
+    public void updateDimensions(ScreenRectangle rectangle) {
+        this.x0 = rectangle.left();
+        this.y0 = rectangle.top();
+        this.x1 = rectangle.right();
+        this.y1 = rectangle.bottom();
+        this.width = rectangle.width();
+        this.height = rectangle.height();
+    }
+
+    /**
+     * awful code to only use smooth scroll state when rendering,
+     * not other code that needs target scroll amount
+     */
+    @Override
+    public double getScrollAmount() {
+        if (returnSmoothAmount && doSmoothScrolling)
+            return smoothScrollAmount;
+
+        return super.getScrollAmount();
+    }
+
+    protected void resetSmoothScrolling() {
+        this.smoothScrollAmount = getScrollAmount();
+    }
+
+    @Nullable
+    @Override
+    protected E getEntryAtPosition(double x, double y) {
+        y += getScrollAmount();
+
+        if (x < this.x0 || x > this.x1)
+            return null;
+
+        int currentY = this.y0 - headerHeight + 4;
+        for (E entry : children()) {
+            if (y >= currentY && y <= currentY + entry.getItemHeight()) {
+                return entry;
+            }
+
+            currentY += entry.getItemHeight();
+        }
+
+        return null;
+    }
+
+    /*
+      below code is licensed from cloth-config under LGPL3
+      modified to inherit vanilla's EntryListWidget and use yarn mappings
+
+      code is responsible for having dynamic item heights
+    */
+
+    @Override
+    protected int getMaxPosition() {
+        return children().stream().map(E::getItemHeight).reduce(0, Integer::sum) + headerHeight;
+    }
+
+    @Override
+    protected void centerScrollOn(E entry) {
+        double d = (this.height) / -2d;
+        for (int i = 0; i < this.children().indexOf(entry) && i < this.getItemCount(); i++)
+            d += children().get(i).getItemHeight();
+        this.setScrollAmount(d);
+    }
+
+    @Override
+    protected int getRowTop(int index) {
+        int integer = y0 + 4 - (int) this.getScrollAmount() + headerHeight;
+        for (int i = 0; i < children().size() && i < index; i++)
+            integer += children().get(i).getItemHeight();
+        return integer;
+    }
+
+    @Override
+    protected void renderList(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        int left = this.getRowLeft();
+        int right = this.getRowWidth();
+        int count = this.getItemCount();
+
+        for(int i = 0; i < count; ++i) {
+            E entry = children().get(i);
+            int top = this.getRowTop(i);
+            int bottom = top + entry.getItemHeight();
+            int entryHeight = entry.getItemHeight() - 4;
+            if (bottom >= this.y0 && top <= this.y1) {
+                this.renderItem(graphics, mouseX, mouseY, delta, i, left, top, right, entryHeight);
+            }
+        }
+    }
+
+    /* END cloth config code */
+
+    @Override
+    public void setX(int i) {
+        this.x = x0 = i;
+        this.x1 = x0 + width;
+    }
+
+    @Override
+    public void setY(int i) {
+        this.y = y0 = i;
+        this.y1 = y0 + height;
+    }
+
+    @Override
+    public int getX() {
+        return x;
+    }
+
+    @Override
+    public int getY() {
+        return y;
+    }
+
+    @Override
+    public int getWidth() {
+        return width;
+    }
+
+    @Override
+    public int getHeight() {
+        return height;
+    }
+
+    @Override
+    public void visitWidgets(Consumer<AbstractWidget> consumer) {
+    }
+
+    public abstract static class Entry<E extends Entry<E>> extends ContainerObjectSelectionList.Entry<E> {
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            for (GuiEventListener child : this.children()) {
+                if (child.mouseClicked(mouseX, mouseY, button)) {
+                    if (button == InputConstants.MOUSE_BUTTON_LEFT)
+                        this.setDragging(true);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        @Override
+        public boolean mouseDragged(double mouseX, double mouseY, int button, double deltaX, double deltaY) {
+            if (isDragging() && button == InputConstants.MOUSE_BUTTON_LEFT) {
+                for (GuiEventListener child : this.children()) {
+                    if (child.mouseDragged(mouseX, mouseY, button, deltaX, deltaY))
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        public int getItemHeight() {
+            return 22;
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/ImageRenderer.java b/common/src/main/java/dev/isxander/yacl3/gui/ImageRenderer.java
new file mode 100644
index 0000000..5b5da97
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/ImageRenderer.java
@@ -0,0 +1,386 @@
+package dev.isxander.yacl3.gui;
+
+import com.mojang.blaze3d.Blaze3D;
+import com.mojang.blaze3d.platform.NativeImage;
+import com.twelvemonkeys.imageio.plugins.webp.WebPImageReaderSpi;
+import dev.isxander.yacl3.impl.utils.YACLConstants;
+import net.minecraft.CrashReport;
+import net.minecraft.CrashReportCategory;
+import net.minecraft.ReportedException;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.texture.DynamicTexture;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.Resource;
+import net.minecraft.server.packs.resources.ResourceManager;
+import net.minecraft.util.FastColor;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+public interface ImageRenderer {
+    int render(GuiGraphics graphics, int x, int y, int renderWidth);
+
+    void close();
+
+    Map<ResourceLocation, CompletableFuture<Optional<ImageRenderer>>> CACHE = new ConcurrentHashMap<>();
+
+    static CompletableFuture<Optional<ImageRenderer>> getOrMakeAsync(ResourceLocation id, Supplier<Optional<ImageRenderer>> factory) {
+        return CACHE.computeIfAbsent(id, key -> CompletableFuture.supplyAsync(factory, YACLConstants.SINGLE_THREAD_EXECUTOR));
+    }
+
+    static CompletableFuture<Optional<ImageRenderer>> getOrMakeSync(ResourceLocation id, Supplier<Optional<ImageRenderer>> factory) {
+        return CACHE.computeIfAbsent(id, key -> CompletableFuture.completedFuture(factory.get()));
+    }
+
+    static void closeAll() {
+        CACHE.values().forEach(future -> future.thenAccept(opt -> opt.ifPresent(ImageRenderer::close)));
+        CACHE.clear();
+    }
+
+    class TextureBacked implements ImageRenderer {
+        private final ResourceLocation location;
+        private final int width, height;
+        private final int textureWidth, textureHeight;
+        private final float u, v;
+
+        public TextureBacked(ResourceLocation location, float u, float v, int width, int height, int textureWidth, int textureHeight) {
+            this.location = location;
+            this.width = width;
+            this.height = height;
+            this.textureWidth = textureWidth;
+            this.textureHeight = textureHeight;
+            this.u = u;
+            this.v = v;
+        }
+
+        @Override
+        public int render(GuiGraphics graphics, int x, int y, int renderWidth) {
+            float ratio = renderWidth / (float)this.width;
+            int targetHeight = (int) (this.height * ratio);
+
+            graphics.pose().pushPose();
+            graphics.pose().translate(x, y, 0);
+            graphics.pose().scale(ratio, ratio, 1);
+            graphics.blit(location, 0, 0, this.u, this.v, this.width, this.height, this.textureWidth, this.textureHeight);
+            graphics.pose().popPose();
+
+            return targetHeight;
+        }
+
+        @Override
+        public void close() {
+
+        }
+    }
+
+    class NativeImageBacked implements ImageRenderer {
+        protected static final TextureManager textureManager = Minecraft.getInstance().getTextureManager();
+
+        protected NativeImage image;
+        protected DynamicTexture texture;
+        protected final ResourceLocation uniqueLocation;
+        protected final int width, height;
+
+        public NativeImageBacked(NativeImage image, ResourceLocation uniqueLocation) {
+            this.image = image;
+            this.texture = new DynamicTexture(image);
+            this.uniqueLocation = uniqueLocation;
+            textureManager.register(this.uniqueLocation, this.texture);
+            this.width = image.getWidth();
+            this.height = image.getHeight();
+        }
+
+        private NativeImageBacked(Path imagePath, ResourceLocation uniqueLocation) throws IOException {
+            this.uniqueLocation = uniqueLocation;
+            this.image = NativeImage.read(new FileInputStream(imagePath.toFile()));
+            this.width = image.getWidth();
+            this.height = image.getHeight();
+            this.texture = new DynamicTexture(image);
+            textureManager.register(this.uniqueLocation, this.texture);
+        }
+
+        public static Optional<ImageRenderer> createFromPath(Path path, ResourceLocation uniqueLocation) {
+            try {
+                return Optional.of(new NativeImageBacked(path, uniqueLocation));
+            } catch (IOException e) {
+                e.printStackTrace();
+                return Optional.empty();
+            }
+        }
+
+        @Override
+        public int render(GuiGraphics graphics, int x, int y, int renderWidth) {
+            if (image == null) return 0;
+
+            float ratio = renderWidth / (float)this.width;
+            int targetHeight = (int) (this.height * ratio);
+
+            graphics.pose().pushPose();
+            graphics.pose().translate(x, y, 0);
+            graphics.pose().scale(ratio, ratio, 1);
+            graphics.blit(uniqueLocation, 0, 0, 0, 0, this.width, this.height, this.width, this.height);
+            graphics.pose().popPose();
+
+            return targetHeight;
+        }
+
+        @Override
+        public void close() {
+            image.close();
+            image = null;
+            texture = null;
+            textureManager.release(uniqueLocation);
+        }
+    }
+
+    class AnimatedNativeImageBacked extends NativeImageBacked {
+        private int currentFrame;
+        private double lastFrameTime;
+
+        private final double[] frameDelays;
+        private final int frameCount;
+
+        private final int packCols, packRows;
+        private final int frameWidth, frameHeight;
+
+        public AnimatedNativeImageBacked(NativeImage image, int frameWidth, int frameHeight, int frameCount, double[] frameDelayMS, int packCols, int packRows, ResourceLocation uniqueLocation) {
+            super(image, uniqueLocation);
+            this.frameWidth = frameWidth;
+            this.frameHeight = frameHeight;
+            this.frameCount = frameCount;
+            this.frameDelays = frameDelayMS;
+            this.packCols = packCols;
+            this.packRows = packRows;
+        }
+
+        public static AnimatedNativeImageBacked createGIFFromTexture(ResourceLocation textureLocation) throws IOException {
+            ResourceManager resourceManager = Minecraft.getInstance().getResourceManager();
+            Resource resource = resourceManager.getResource(textureLocation).orElseThrow();
+
+            return createGIF(resource.open(), textureLocation);
+        }
+
+        public static AnimatedNativeImageBacked createWEBPFromTexture(ResourceLocation textureLocation) throws IOException {
+            ResourceManager resourceManager = Minecraft.getInstance().getResourceManager();
+            Resource resource = resourceManager.getResource(textureLocation).orElseThrow();
+
+            return createWEBP(resource.open(), textureLocation);
+        }
+
+        public static AnimatedNativeImageBacked createGIF(InputStream is, ResourceLocation uniqueLocation) {
+            try (is) {
+                ImageReader reader = ImageIO.getImageReadersBySuffix("gif").next();
+                reader.setInput(ImageIO.createImageInputStream(is));
+
+
+
+                AnimFrameProvider animFrameFunction = i -> {
+                    IIOMetadata metadata = reader.getImageMetadata(i);
+                    String metaFormatName = metadata.getNativeMetadataFormatName();
+                    IIOMetadataNode root = (IIOMetadataNode) metadata.getAsTree(metaFormatName);
+                    IIOMetadataNode graphicsControlExtensionNode = (IIOMetadataNode) root.getElementsByTagName("GraphicControlExtension").item(0);
+                    int delay = Integer.parseInt(graphicsControlExtensionNode.getAttribute("delayTime")) * 10;
+
+                    return new AnimFrame(delay, 0, 0);
+                };
+
+                return createFromImageReader(reader, animFrameFunction, uniqueLocation);
+            } catch (Exception e) {
+                CrashReport crashReport = CrashReport.forThrowable(e, "Failed to load GIF image");
+                CrashReportCategory category = crashReport.addCategory("YACL Gui");
+                category.setDetail("Image identifier", uniqueLocation.toString());
+                throw new ReportedException(crashReport);
+            }
+        }
+
+        public static AnimatedNativeImageBacked createWEBP(InputStream is, ResourceLocation uniqueLocation) {
+            try (is) {
+                ImageReader reader = new WebPImageReaderSpi().createReaderInstance();
+                reader.setInput(ImageIO.createImageInputStream(is));
+
+                int numImages = reader.getNumImages(true); // Force reading of all frames
+                AnimFrameProvider animFrameFunction = i -> null;
+                if (numImages > 1) {
+                    // WebP reader does not expose frame delay, prepare for reflection hell
+                    Class<?> webpReaderClass = Class.forName("com.twelvemonkeys.imageio.plugins.webp.WebPImageReader");
+                    Field framesField = webpReaderClass.getDeclaredField("frames");
+                    framesField.setAccessible(true);
+                    List<?> frames = (List<?>) framesField.get(reader);
+
+                    Class<?> animationFrameClass = Class.forName("com.twelvemonkeys.imageio.plugins.webp.AnimationFrame");
+                    Field durationField = animationFrameClass.getDeclaredField("duration");
+                    durationField.setAccessible(true);
+                    Field boundsField = animationFrameClass.getDeclaredField("bounds");
+                    boundsField.setAccessible(true);
+
+                    animFrameFunction = i -> {
+                        Rectangle bounds = (Rectangle) boundsField.get(frames.get(i));
+                        return new AnimFrame((int) durationField.get(frames.get(i)), bounds.x, bounds.y);
+                    };
+                    // that was fun
+                }
+
+                return createFromImageReader(reader, animFrameFunction, uniqueLocation);
+            } catch (Throwable e) {
+                CrashReport crashReport = CrashReport.forThrowable(e, "Failed to load WEBP image");
+                CrashReportCategory category = crashReport.addCategory("YACL Gui");
+                category.setDetail("Image identifier", uniqueLocation.toString());
+                throw new ReportedException(crashReport);
+            }
+        }
+
+        private static AnimatedNativeImageBacked createFromImageReader(ImageReader reader, AnimFrameProvider animationProvider, ResourceLocation uniqueLocation) throws Exception {
+            int frameCount = reader.getNumImages(true);
+
+            // Because this is being backed into a texture atlas, we need a maximum dimension
+            // so you can get the texture atlas size.
+            // Smaller frames are given black borders
+            int frameWidth = IntStream.range(reader.getMinIndex(), frameCount).map(i -> {
+                try {
+                    return reader.getWidth(i);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }).max().orElseThrow();
+            int frameHeight = IntStream.range(reader.getMinIndex(), frameCount).map(i -> {
+                try {
+                    return reader.getHeight(i);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }).max().orElseThrow();
+
+            // Packs the frames into an optimal 1:1 texture.
+            // OpenGL can only have texture axis with a max of 32768 pixels,
+            // and packing them to that length is not efficient, apparently.
+            double ratio = frameWidth / (double)frameHeight;
+            int cols = (int)Math.ceil(Math.sqrt(frameCount) / Math.sqrt(ratio));
+            int rows = (int)Math.ceil(frameCount / (double)cols);
+
+            NativeImage image = new NativeImage(frameWidth * cols, frameHeight * rows, true);
+
+            // Fill whole atlas with black, as each frame may have different dimensions
+            // that would cause borders of transparent pixels to appear around the frames
+            for (int x = 0; x < frameWidth * cols; x++) {
+                for (int y = 0; y < frameHeight * rows; y++) {
+                    image.setPixelRGBA(x, y, 0xFF000000);
+                }
+            }
+
+            BufferedImage bi = null;
+            Graphics2D graphics = null;
+
+            // each frame may have a different delay
+            double[] frameDelays = new double[frameCount];
+
+            for (int i = reader.getMinIndex(); i < frameCount - 1; i++) {
+                AnimFrame frame = animationProvider.get(i);
+                if (frameCount > 1) // frame will be null if not animation
+                    frameDelays[i] = frame.durationMS;
+
+                if (bi == null) {
+                    // first frame...
+                    bi = reader.read(i);
+                    graphics = bi.createGraphics();
+                } else {
+                    // WebP reader sometimes provides delta frames, (only the pixels that changed since the last frame)
+                    // so instead of overwriting the image every frame, we draw delta frames on top of the previous frame
+                    // to keep a complete image.
+                    BufferedImage deltaFrame = reader.read(i);
+                    graphics.drawImage(deltaFrame, frame.xOffset, frame.yOffset, null);
+                }
+
+                // Each frame may have different dimensions, so we need to center them.
+                int xOffset = (frameWidth - bi.getWidth()) / 2;
+                int yOffset = (frameHeight - bi.getHeight()) / 2;
+
+                for (int w = 0; w < bi.getWidth(); w++) {
+                    for (int h = 0; h < bi.getHeight(); h++) {
+                        int rgb = bi.getRGB(w, h);
+                        int r = FastColor.ARGB32.red(rgb);
+                        int g = FastColor.ARGB32.green(rgb);
+                        int b = FastColor.ARGB32.blue(rgb);
+
+                        int col = i % cols;
+                        int row = (int) Math.floor(i / (double)cols);
+
+                        image.setPixelRGBA(
+                                frameWidth * col + w + xOffset,
+                                frameHeight * row + h + yOffset,
+                                FastColor.ABGR32.color(255, b, g, r) // NativeImage uses ABGR for some reason
+                        );
+                    }
+                }
+            }
+            // gives the texture to GL for rendering
+            // usually, you create a native image with NativeImage.create, which sets the pixels and
+            // runs this function itself. In this case, we need to do it manually.
+            image.upload(0, 0, 0, false);
+
+            graphics.dispose();
+            reader.dispose();
+
+            return new AnimatedNativeImageBacked(image, frameWidth, frameHeight, frameCount, frameDelays, cols, rows, uniqueLocation);
+        }
+
+        @Override
+        public int render(GuiGraphics graphics, int x, int y, int renderWidth) {
+            if (image == null) return 0;
+
+            float ratio = renderWidth / (float)frameWidth;
+            int targetHeight = (int) (frameHeight * ratio);
+
+            int currentCol = currentFrame % packCols;
+            int currentRow = (int) Math.floor(currentFrame / (double)packCols);
+
+            graphics.pose().pushPose();
+            graphics.pose().translate(x, y, 0);
+            graphics.pose().scale(ratio, ratio, 1);
+            graphics.blit(
+                    uniqueLocation,
+                    0, 0,
+                    frameWidth * currentCol, frameHeight * currentRow,
+                    frameWidth, frameHeight,
+                    this.width, this.height
+            );
+            graphics.pose().popPose();
+
+            if (frameCount > 1) {
+                double timeMS = Blaze3D.getTime() * 1000;
+                if (lastFrameTime == 0) lastFrameTime = timeMS;
+                if (timeMS - lastFrameTime >= frameDelays[currentFrame]) {
+                    currentFrame++;
+                    lastFrameTime = timeMS;
+                }
+                if (currentFrame >= frameCount - 1)
+                    currentFrame = 0;
+            }
+
+            return targetHeight;
+        }
+
+        @FunctionalInterface
+        private interface AnimFrameProvider {
+            AnimFrame get(int frame) throws Exception;
+        }
+        private record AnimFrame(int durationMS, int xOffset, int yOffset) {}
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/LowProfileButtonWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/LowProfileButtonWidget.java
new file mode 100644
index 0000000..3f5822f
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/LowProfileButtonWidget.java
@@ -0,0 +1,28 @@
+package dev.isxander.yacl3.gui;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.Tooltip;
+import net.minecraft.network.chat.Component;
+
+public class LowProfileButtonWidget extends Button {
+    public LowProfileButtonWidget(int x, int y, int width, int height, Component message, OnPress onPress) {
+        super(x, y, width, height, message, onPress, DEFAULT_NARRATION);
+    }
+
+    public LowProfileButtonWidget(int x, int y, int width, int height, Component message, OnPress onPress, Tooltip tooltip) {
+        this(x, y, width, height, message, onPress);
+        setTooltip(tooltip);
+    }
+
+    @Override
+    public void renderWidget(GuiGraphics graphics, int mouseX, int mouseY, float deltaTicks) {
+        if (!isHoveredOrFocused() || !active) {
+            int j = this.active ? 0xFFFFFF : 0xA0A0A0;
+            this.renderString(graphics, Minecraft.getInstance().font, j);
+        } else {
+            super.renderWidget(graphics, mouseX, mouseY, deltaTicks);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/OptionDescriptionWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/OptionDescriptionWidget.java
new file mode 100644
index 0000000..63371d6
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/OptionDescriptionWidget.java
@@ -0,0 +1,215 @@
+package dev.isxander.yacl3.gui;
+
+import com.mojang.blaze3d.Blaze3D;
+import com.mojang.blaze3d.platform.InputConstants;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.ComponentPath;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.navigation.FocusNavigationEvent;
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.Style;
+import net.minecraft.util.FormattedCharSequence;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+public class OptionDescriptionWidget extends AbstractWidget {
+    private static final int AUTO_SCROLL_TIMER = 1500;
+    private static final float AUTO_SCROLL_SPEED = 1; // lines per second
+
+    private @Nullable DescriptionWithName description;
+    private List<FormattedCharSequence> wrappedText;
+
+    private static final Minecraft minecraft = Minecraft.getInstance();
+    private static final Font font = minecraft.font;
+
+    private Supplier<ScreenRectangle> dimensions;
+
+    private float targetScrollAmount, currentScrollAmount;
+    private int maxScrollAmount;
+    private int descriptionY;
+
+    private int lastInteractionTime;
+    private boolean scrollingBackward;
+
+    public OptionDescriptionWidget(Supplier<ScreenRectangle> dimensions, @Nullable DescriptionWithName description) {
+        super(0, 0, 0, 0, description == null ? Component.empty() : description.name());
+        this.dimensions = dimensions;
+        this.setOptionDescription(description);
+    }
+
+    @Override
+    public void renderWidget(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        if (description == null) return;
+
+        currentScrollAmount = Mth.lerp(delta * 0.5f, currentScrollAmount, targetScrollAmount);
+
+        ScreenRectangle dimensions = this.dimensions.get();
+        this.setX(dimensions.left());
+        this.setY(dimensions.top());
+        this.width = dimensions.width();
+        this.height = dimensions.height();
+
+        int y = getY();
+
+        int nameWidth = font.width(description.name());
+        if (nameWidth > getWidth()) {
+            renderScrollingString(graphics, font, description.name(), getX(), y, getX() + getWidth(), y + font.lineHeight, -1);
+        } else {
+            graphics.drawString(font, description.name(), getX(), y, 0xFFFFFF);
+        }
+
+        y += 5 + font.lineHeight;
+
+        graphics.enableScissor(getX(), y, getX() + getWidth(), getY() + getHeight());
+
+        y -= (int)currentScrollAmount;
+
+        if (description.description().image().isDone()) {
+            var image = description.description().image().join();
+            if (image.isPresent()) {
+                image.get().render(graphics, getX(), y, getWidth());
+                y += image.get().render(graphics, getX(), y, getWidth()) + 5;
+            }
+        }
+
+        if (wrappedText == null)
+            wrappedText = font.split(description.description().text(), getWidth());
+
+        descriptionY = y;
+        for (var line : wrappedText) {
+            graphics.drawString(font, line, getX(), y, 0xFFFFFF);
+            y += font.lineHeight;
+        }
+
+        graphics.disableScissor();
+
+        maxScrollAmount = Math.max(0, y + (int)currentScrollAmount - getY() - getHeight());
+
+        if (isHoveredOrFocused()) {
+            lastInteractionTime = currentTimeMS();
+        }
+        Style hoveredStyle = getDescStyle(mouseX, mouseY);
+        if (hoveredStyle != null && hoveredStyle.getHoverEvent() != null) {
+            graphics.renderComponentHoverEffect(font, hoveredStyle, mouseX, mouseY);
+        }
+
+        if (isFocused()) {
+            graphics.renderOutline(getX(), getY(), getWidth(), getHeight(), -1);
+        }
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        Style clickedStyle = getDescStyle((int) mouseX, (int) mouseY);
+        if (clickedStyle != null && clickedStyle.getClickEvent() != null) {
+            if (minecraft.screen.handleComponentClicked(clickedStyle)) {
+                playDownSound(minecraft.getSoundManager());
+                return true;
+            }
+            return false;
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        if (isMouseOver(mouseX, mouseY)) {
+            targetScrollAmount = Mth.clamp(targetScrollAmount - (int) amount * 10, 0, maxScrollAmount);
+            lastInteractionTime = currentTimeMS();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (isFocused()) {
+            switch (keyCode) {
+                case InputConstants.KEY_UP ->
+                    targetScrollAmount = Mth.clamp(targetScrollAmount - 10, 0, maxScrollAmount);
+                case InputConstants.KEY_DOWN ->
+                    targetScrollAmount = Mth.clamp(targetScrollAmount + 10, 0, maxScrollAmount);
+                default -> {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public void tick() {
+        float pxPerTick = AUTO_SCROLL_SPEED / 20f * font.lineHeight;
+        if (maxScrollAmount > 0 && currentTimeMS() - lastInteractionTime > AUTO_SCROLL_TIMER) {
+            if (scrollingBackward) {
+                pxPerTick *= -1;
+                if (targetScrollAmount + pxPerTick < 0) {
+                    scrollingBackward = false;
+                    lastInteractionTime = currentTimeMS();
+                }
+            } else {
+                if (targetScrollAmount + pxPerTick > maxScrollAmount) {
+                    scrollingBackward = true;
+                    lastInteractionTime = currentTimeMS();
+                }
+            }
+
+            targetScrollAmount = Mth.clamp(targetScrollAmount + pxPerTick, 0, maxScrollAmount);
+        }
+    }
+
+    private Style getDescStyle(int mouseX, int mouseY) {
+        if (!clicked(mouseX, mouseY))
+            return null;
+
+        int x = mouseX - getX();
+        int y = mouseY - descriptionY;
+
+        if (x < 0 || x > getX() + getWidth()) return null;
+        if (y < 0 || y > getY() + getHeight()) return null;
+
+        int line = y / font.lineHeight;
+
+        if (line >= wrappedText.size()) return null;
+
+        return font.getSplitter().componentStyleAtWidth(wrappedText.get(line), x);
+    }
+
+    @Override
+    protected void updateWidgetNarration(NarrationElementOutput builder) {
+        if (description != null) {
+            builder.add(NarratedElementType.TITLE, description.name());
+            builder.add(NarratedElementType.HINT, description.description().text());
+        }
+
+    }
+
+    public void setOptionDescription(DescriptionWithName description) {
+        this.description = description;
+        this.wrappedText = null;
+        this.targetScrollAmount = 0;
+        this.currentScrollAmount = 0;
+        this.lastInteractionTime = currentTimeMS();
+    }
+
+    private int currentTimeMS() {
+        return (int)(Blaze3D.getTime() * 1000);
+    }
+
+    @Nullable
+    @Override
+    public ComponentPath nextFocusPath(FocusNavigationEvent event) {
+        // prevents focusing on this widget
+        return null;
+    }
+
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/OptionListWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/OptionListWidget.java
new file mode 100644
index 0000000..54d58f4
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/OptionListWidget.java
@@ -0,0 +1,572 @@
+package dev.isxander.yacl3.gui;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.impl.utils.YACLConstants;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.MultiLineLabel;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+public class OptionListWidget extends ElementListWidgetExt<OptionListWidget.Entry> {
+    private final YACLScreen yaclScreen;
+    private final ConfigCategory category;
+    private ImmutableList<Entry> viewableChildren;
+    private String searchQuery = "";
+    private final Consumer<DescriptionWithName> hoverEvent;
+    private DescriptionWithName lastHoveredOption;
+
+    public OptionListWidget(YACLScreen screen, ConfigCategory category, Minecraft client, int x, int y, int width, int height, Consumer<DescriptionWithName> hoverEvent) {
+        super(client, x, y, width, height, true);
+        this.yaclScreen = screen;
+        this.category = category;
+        this.hoverEvent = hoverEvent;
+
+        refreshOptions();
+
+        for (OptionGroup group : category.groups()) {
+            if (group instanceof ListOption<?> listOption) {
+                listOption.addRefreshListener(() -> refreshListEntries(listOption, category));
+            }
+        }
+    }
+
+    public void refreshOptions() {
+        clearEntries();
+
+        for (OptionGroup group : category.groups()) {
+            GroupSeparatorEntry groupSeparatorEntry;
+            if (!group.isRoot()) {
+                groupSeparatorEntry = group instanceof ListOption<?> listOption
+                        ? new ListGroupSeparatorEntry(listOption, yaclScreen)
+                        : new GroupSeparatorEntry(group, yaclScreen);
+                addEntry(groupSeparatorEntry);
+            } else {
+                groupSeparatorEntry = null;
+            }
+
+            List<Entry> optionEntries = new ArrayList<>();
+
+            // add empty entry to make sure users know it's empty not just bugging out
+            if (groupSeparatorEntry instanceof ListGroupSeparatorEntry listGroupSeparatorEntry) {
+                if (listGroupSeparatorEntry.listOption.options().isEmpty()) {
+                    EmptyListLabel emptyListLabel = new EmptyListLabel(listGroupSeparatorEntry, category);
+                    addEntry(emptyListLabel);
+                    optionEntries.add(emptyListLabel);
+                }
+            }
+
+            for (Option<?> option : group.options()) {
+                OptionEntry entry = new OptionEntry(option, category, group, groupSeparatorEntry, option.controller().provideWidget(yaclScreen, getDefaultEntryDimension()));
+                addEntry(entry);
+                optionEntries.add(entry);
+            }
+
+            if (groupSeparatorEntry != null) {
+                groupSeparatorEntry.setChildEntries(optionEntries);
+            }
+        }
+
+        recacheViewableChildren();
+        setScrollAmount(0);
+        resetSmoothScrolling();
+    }
+
+    private void refreshListEntries(ListOption<?> listOption, ConfigCategory category) {
+        // find group separator for group
+        ListGroupSeparatorEntry groupSeparator = super.children().stream().filter(e -> e instanceof ListGroupSeparatorEntry gs && gs.group == listOption).map(ListGroupSeparatorEntry.class::cast).findAny().orElse(null);
+
+        if (groupSeparator == null) {
+            YACLConstants.LOGGER.warn("Can't find group seperator to refresh list option entries for list option " + listOption.name());
+            return;
+        }
+
+        for (Entry entry : groupSeparator.childEntries)
+            super.removeEntry(entry);
+        groupSeparator.childEntries.clear();
+
+        // if no entries, below loop won't run where addEntryBelow() recaches viewable children
+        if (listOption.options().isEmpty()) {
+            EmptyListLabel emptyListLabel;
+            addEntryBelow(groupSeparator, emptyListLabel = new EmptyListLabel(groupSeparator, category));
+            groupSeparator.childEntries.add(emptyListLabel);
+            return;
+        }
+
+        Entry lastEntry = groupSeparator;
+        for (ListOptionEntry<?> listOptionEntry : listOption.options()) {
+            OptionEntry optionEntry = new OptionEntry(listOptionEntry, category, listOption, groupSeparator, listOptionEntry.controller().provideWidget(yaclScreen, getDefaultEntryDimension()));
+            addEntryBelow(lastEntry, optionEntry);
+            groupSeparator.childEntries.add(optionEntry);
+            lastEntry = optionEntry;
+        }
+    }
+
+    public Dimension<Integer> getDefaultEntryDimension() {
+        return Dimension.ofInt(getRowLeft(), 0, getRowWidth(), 20);
+    }
+
+    public void expandAllGroups() {
+        for (Entry entry : super.children()) {
+            if (entry instanceof GroupSeparatorEntry groupSeparatorEntry) {
+                groupSeparatorEntry.setExpanded(true);
+            }
+        }
+    }
+
+    public void updateSearchQuery(String query) {
+        this.searchQuery = query;
+        expandAllGroups();
+        recacheViewableChildren();
+    }
+
+    @Override
+    public int getRowWidth() {
+        return Math.min(396, (int)(width / 1.3f));
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        for (Entry child : children()) {
+            if (child != getEntryAtPosition(mouseX, mouseY) && child instanceof OptionEntry optionEntry)
+                optionEntry.widget.unfocus();
+        }
+
+        return super.mouseClicked(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        super.mouseScrolled(mouseX, mouseY, amount);
+
+        for (Entry child : children()) {
+            if (child.mouseScrolled(mouseX, mouseY, amount))
+                break;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        for (Entry child : children()) {
+            if (child.keyPressed(keyCode, scanCode, modifiers))
+                return true;
+        }
+
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+
+    @Override
+    public boolean charTyped(char chr, int modifiers) {
+        for (Entry child : children()) {
+            if (child.charTyped(chr, modifiers))
+                return true;
+        }
+
+        return super.charTyped(chr, modifiers);
+    }
+
+    @Override
+    protected int getScrollbarPosition() {
+        return x1 - (int)(width * 0.05f);
+    }
+
+    public void recacheViewableChildren() {
+        this.viewableChildren = ImmutableList.copyOf(super.children().stream().filter(Entry::isViewable).toList());
+
+        // update y positions before they need to be rendered are rendered
+        int i = 0;
+        for (Entry entry : viewableChildren) {
+            if (entry instanceof OptionEntry optionEntry)
+                optionEntry.widget.setDimension(optionEntry.widget.getDimension().withY(getRowTop(i)));
+            i++;
+        }
+    }
+
+    @Override
+    public List<Entry> children() {
+        return viewableChildren;
+    }
+
+    public void addEntry(int index, Entry entry) {
+        super.children().add(index, entry);
+        recacheViewableChildren();
+    }
+
+    public void addEntryBelow(Entry below, Entry entry) {
+        int idx = super.children().indexOf(below) + 1;
+
+        if (idx == 0)
+            throw new IllegalStateException("The entry to insert below does not exist!");
+
+        addEntry(idx, entry);
+    }
+
+    public void addEntryBelowWithoutScroll(Entry below, Entry entry) {
+        double d = (double)this.getMaxScroll() - this.getScrollAmount();
+        addEntryBelow(below, entry);
+        setScrollAmount(getMaxScroll() - d);
+    }
+
+    @Override
+    public boolean removeEntryFromTop(Entry entry) {
+        boolean ret = super.removeEntryFromTop(entry);
+        recacheViewableChildren();
+        return ret;
+    }
+
+    @Override
+    public boolean removeEntry(Entry entry) {
+        boolean ret = super.removeEntry(entry);
+        recacheViewableChildren();
+        return ret;
+    }
+
+    private void setHoverDescription(DescriptionWithName description) {
+        if (description != lastHoveredOption) {
+            lastHoveredOption = description;
+            hoverEvent.accept(description);
+        }
+    }
+
+    public abstract class Entry extends ElementListWidgetExt.Entry<Entry> {
+        public boolean isViewable() {
+            return true;
+        }
+
+        protected boolean isHovered() {
+            return Objects.equals(getHovered(), this);
+        }
+    }
+
+    public class OptionEntry extends Entry {
+        public final Option<?> option;
+        public final ConfigCategory category;
+        public final OptionGroup group;
+
+        public final @Nullable GroupSeparatorEntry groupSeparatorEntry;
+
+        public final AbstractWidget widget;
+
+        private final TextScaledButtonWidget resetButton;
+
+        private final String categoryName;
+        private final String groupName;
+
+        public OptionEntry(Option<?> option, ConfigCategory category, OptionGroup group, @Nullable GroupSeparatorEntry groupSeparatorEntry, AbstractWidget widget) {
+            this.option = option;
+            this.category = category;
+            this.group = group;
+            this.groupSeparatorEntry = groupSeparatorEntry;
+            this.widget = widget;
+            this.categoryName = category.name().getString().toLowerCase();
+            this.groupName = group.name().getString().toLowerCase();
+            if (option.canResetToDefault() && this.widget.canReset()) {
+                this.widget.setDimension(this.widget.getDimension().expanded(-20, 0));
+                this.resetButton = new TextScaledButtonWidget(yaclScreen, widget.getDimension().xLimit(), -50, 20, 20, 2f, Component.literal("\u21BB"), button -> {
+                    option.requestSetDefault();
+                });
+                option.addListener((opt, val) -> this.resetButton.active = !opt.isPendingValueDefault() && opt.available());
+                this.resetButton.active = !option.isPendingValueDefault() && option.available();
+            } else {
+                this.resetButton = null;
+            }
+        }
+
+        @Override
+        public void render(GuiGraphics graphics, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+            widget.setDimension(widget.getDimension().withY(y));
+
+            widget.render(graphics, mouseX, mouseY, tickDelta);
+
+            if (resetButton != null) {
+                resetButton.setY(y);
+                resetButton.render(graphics, mouseX, mouseY, tickDelta);
+            }
+
+            if (isHovered()) {
+                setHoverDescription(DescriptionWithName.of(option.name(), option.description()));
+            }
+        }
+
+        @Override
+        public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+            return widget.mouseScrolled(mouseX, mouseY, amount);
+        }
+
+        @Override
+        public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+            return widget.keyPressed(keyCode, scanCode, modifiers);
+        }
+
+        @Override
+        public boolean charTyped(char chr, int modifiers) {
+            return widget.charTyped(chr, modifiers);
+        }
+
+        @Override
+        public boolean isViewable() {
+            return (groupSeparatorEntry == null || groupSeparatorEntry.isExpanded())
+                    && (searchQuery.isEmpty()
+                    || groupName.contains(searchQuery)
+                    || widget.matchesSearch(searchQuery));
+        }
+
+        @Override
+        public int getItemHeight() {
+            return Math.max(widget.getDimension().height(), resetButton != null ? resetButton.getHeight() : 0) + 2;
+        }
+
+        @Override
+        public void setFocused(boolean focused) {
+            super.setFocused(focused);
+            if (focused)
+                setHoverDescription(DescriptionWithName.of(option.name(), option.description()));
+        }
+
+        @Override
+        public List<? extends NarratableEntry> narratables() {
+            if (resetButton == null)
+                return ImmutableList.of(widget);
+
+            return ImmutableList.of(widget, resetButton);
+        }
+
+        @Override
+        public List<? extends GuiEventListener> children() {
+            if (resetButton == null)
+                return ImmutableList.of(widget);
+
+            return ImmutableList.of(widget, resetButton);
+        }
+    }
+
+    public class GroupSeparatorEntry extends Entry {
+        protected final OptionGroup group;
+        protected final MultiLineLabel wrappedName;
+        protected final MultiLineLabel wrappedTooltip;
+
+        protected final LowProfileButtonWidget expandMinimizeButton;
+
+        protected final Screen screen;
+        protected final Font font = Minecraft.getInstance().font;
+
+        protected boolean groupExpanded;
+
+        protected List<Entry> childEntries = new ArrayList<>();
+
+        private int y;
+
+        private GroupSeparatorEntry(OptionGroup group, Screen screen) {
+            this.group = group;
+            this.screen = screen;
+            this.wrappedName = MultiLineLabel.create(font, group.name(), getRowWidth() - 45);
+            this.wrappedTooltip = MultiLineLabel.create(font, group.tooltip(), screen.width / 3 * 2 - 10);
+            this.groupExpanded = !group.collapsed();
+            this.expandMinimizeButton = new LowProfileButtonWidget(0, 0, 20, 20, Component.empty(), btn -> onExpandButtonPress());
+            updateExpandMinimizeText();
+        }
+
+        @Override
+        public void render(GuiGraphics graphics, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+            this.y = y;
+
+            int buttonY = y + entryHeight / 2 - expandMinimizeButton.getHeight() / 2 + 1;
+
+            expandMinimizeButton.setY(buttonY);
+            expandMinimizeButton.setX(x);
+            expandMinimizeButton.render(graphics, mouseX, mouseY, tickDelta);
+
+            wrappedName.renderCentered(graphics, x + entryWidth / 2, y + getYPadding());
+
+            if (isHovered()) {
+                setHoverDescription(DescriptionWithName.of(group.name(), group.description()));
+            }
+        }
+
+        public boolean isExpanded() {
+            return groupExpanded;
+        }
+
+        public void setExpanded(boolean expanded) {
+            if (this.groupExpanded == expanded)
+                return;
+
+            this.groupExpanded = expanded;
+            updateExpandMinimizeText();
+            recacheViewableChildren();
+        }
+
+        protected void onExpandButtonPress() {
+            setExpanded(!isExpanded());
+        }
+
+        protected void updateExpandMinimizeText() {
+            expandMinimizeButton.setMessage(Component.literal(isExpanded() ? "▼" : "▶"));
+        }
+
+        public void setChildEntries(List<? extends Entry> childEntries) {
+            this.childEntries.clear();
+            this.childEntries.addAll(childEntries);
+        }
+
+        @Override
+        public boolean isViewable() {
+            return searchQuery.isEmpty() || childEntries.stream().anyMatch(Entry::isViewable);
+        }
+
+        @Override
+        public int getItemHeight() {
+            return Math.max(wrappedName.getLineCount(), 1) * font.lineHeight + getYPadding() * 2;
+        }
+
+        private int getYPadding() {
+            return 6;
+        }
+
+        @Override
+        public void setFocused(boolean focused) {
+            super.setFocused(focused);
+            if (focused)
+                setHoverDescription(DescriptionWithName.of(group.name(), group.description()));
+        }
+
+        @Override
+        public List<? extends NarratableEntry> narratables() {
+            return ImmutableList.of(new NarratableEntry() {
+                @Override
+                public NarrationPriority narrationPriority() {
+                    return NarrationPriority.HOVERED;
+                }
+
+                @Override
+                public void updateNarration(NarrationElementOutput builder) {
+                    builder.add(NarratedElementType.TITLE, group.name());
+                    builder.add(NarratedElementType.HINT, group.tooltip());
+                }
+            });
+        }
+
+        @Override
+        public List<? extends GuiEventListener> children() {
+            return ImmutableList.of(expandMinimizeButton);
+        }
+    }
+
+    public class ListGroupSeparatorEntry extends GroupSeparatorEntry {
+        private final ListOption<?> listOption;
+        private final TextScaledButtonWidget resetListButton;
+        private final TooltipButtonWidget addListButton;
+
+        private ListGroupSeparatorEntry(ListOption<?> group, Screen screen) {
+            super(group, screen);
+            this.listOption = group;
+
+            this.resetListButton = new TextScaledButtonWidget(screen, getRowRight() - 20, -50, 20, 20, 2f, Component.literal("\u21BB"), button -> {
+                group.requestSetDefault();
+            });
+            group.addListener((opt, val) -> this.resetListButton.active = !opt.isPendingValueDefault() && opt.available());
+            this.resetListButton.active = !group.isPendingValueDefault() && group.available();
+
+
+            this.addListButton = new TooltipButtonWidget(yaclScreen, resetListButton.getX() - 20, -50, 20, 20, Component.literal("+"), Component.translatable("yacl.list.add_top"), btn -> {
+                group.insertNewEntryToTop();
+                setExpanded(true);
+            });
+
+            updateExpandMinimizeText();
+            minimizeIfUnavailable();
+        }
+
+        @Override
+        public void render(GuiGraphics graphics, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+            updateExpandMinimizeText(); // update every render because option could become available/unavailable at any time
+
+            super.render(graphics, index, y, x, entryWidth, entryHeight, mouseX, mouseY, hovered, tickDelta);
+
+            int buttonY = expandMinimizeButton.getY();
+
+            resetListButton.setY(buttonY);
+            addListButton.setY(buttonY);
+
+            resetListButton.render(graphics, mouseX, mouseY, tickDelta);
+            addListButton.render(graphics, mouseX, mouseY, tickDelta);
+        }
+
+        private void minimizeIfUnavailable() {
+            if (!listOption.available() && isExpanded()) {
+                setExpanded(false);
+            }
+        }
+
+        @Override
+        protected void updateExpandMinimizeText() {
+            super.updateExpandMinimizeText();
+            expandMinimizeButton.active = listOption == null || listOption.available();
+            if (addListButton != null)
+                addListButton.active = expandMinimizeButton.active;
+        }
+
+        @Override
+        public void setExpanded(boolean expanded) {
+            super.setExpanded(listOption.available() && expanded);
+        }
+
+        @Override
+        public List<? extends GuiEventListener> children() {
+            return ImmutableList.of(expandMinimizeButton, addListButton, resetListButton);
+        }
+    }
+
+    public class EmptyListLabel extends Entry {
+        private final ListGroupSeparatorEntry parent;
+        private final String groupName;
+        private final String categoryName;
+
+        public EmptyListLabel(ListGroupSeparatorEntry parent, ConfigCategory category) {
+            this.parent = parent;
+            this.groupName = parent.group.name().getString().toLowerCase();
+            this.categoryName = category.name().getString().toLowerCase();
+        }
+
+        @Override
+        public void render(GuiGraphics graphics, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+            graphics.drawCenteredString(Minecraft.getInstance().font, Component.translatable("yacl.list.empty").withStyle(ChatFormatting.DARK_GRAY, ChatFormatting.ITALIC), x + entryWidth / 2, y, -1);
+        }
+
+        @Override
+        public boolean isViewable() {
+            return parent.isExpanded() && (searchQuery.isEmpty() || groupName.contains(searchQuery));
+        }
+
+        @Override
+        public int getItemHeight() {
+            return 11;
+        }
+
+        @Override
+        public List<? extends GuiEventListener> children() {
+            return ImmutableList.of();
+        }
+
+        @Override
+        public List<? extends NarratableEntry> narratables() {
+            return ImmutableList.of();
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/RequireRestartScreen.java b/common/src/main/java/dev/isxander/yacl3/gui/RequireRestartScreen.java
new file mode 100644
index 0000000..5ba4b03
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/RequireRestartScreen.java
@@ -0,0 +1,21 @@
+package dev.isxander.yacl3.gui;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.ConfirmScreen;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+
+public class RequireRestartScreen extends ConfirmScreen {
+    public RequireRestartScreen(Screen parent) {
+        super(option -> {
+            if (option) Minecraft.getInstance().stop();
+            else Minecraft.getInstance().setScreen(parent);
+        },
+                Component.translatable("yacl.restart.title").withStyle(ChatFormatting.RED, ChatFormatting.BOLD),
+                Component.translatable("yacl.restart.message"),
+                Component.translatable("yacl.restart.yes"),
+                Component.translatable("yacl.restart.no")
+        );
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/SearchFieldWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/SearchFieldWidget.java
new file mode 100644
index 0000000..a666886
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/SearchFieldWidget.java
@@ -0,0 +1,61 @@
+package dev.isxander.yacl3.gui;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Consumer;
+
+public class SearchFieldWidget extends EditBox {
+    private Component emptyText;
+    private final YACLScreen yaclScreen;
+    private final Font font;
+    private final Consumer<String> updateConsumer;
+
+    private boolean isEmpty = true;
+
+    public SearchFieldWidget(YACLScreen yaclScreen, Font font, int x, int y, int width, int height, Component text, Component emptyText, Consumer<String> updateConsumer) {
+        super(font, x, y, width, height, text);
+        setResponder(this::update);
+        setFilter(string -> !string.endsWith("  ") && !string.startsWith(" "));
+        this.yaclScreen = yaclScreen;
+        this.font = font;
+        this.emptyText = emptyText;
+        this.updateConsumer = updateConsumer;
+    }
+
+    @Override
+    public void renderWidget(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        super.renderWidget(graphics, mouseX, mouseY, delta);
+        if (isVisible() && isEmpty()) {
+            graphics.drawString(font, emptyText, getX() + 4, this.getY() + (this.height - 8) / 2, 0x707070, true);
+        }
+    }
+
+    private void update(String query) {
+        boolean wasEmpty = isEmpty;
+        isEmpty = query.isEmpty();
+
+        if (isEmpty && wasEmpty)
+            return;
+
+        updateConsumer.accept(query);
+    }
+
+    public String getQuery() {
+        return getValue().toLowerCase();
+    }
+
+    public boolean isEmpty() {
+        return isEmpty;
+    }
+
+    public Component getEmptyText() {
+        return emptyText;
+    }
+
+    public void setEmptyText(Component emptyText) {
+        this.emptyText = emptyText;
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/TextScaledButtonWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/TextScaledButtonWidget.java
new file mode 100644
index 0000000..6ad0d1c
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/TextScaledButtonWidget.java
@@ -0,0 +1,34 @@
+package dev.isxander.yacl3.gui;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+
+public class TextScaledButtonWidget extends TooltipButtonWidget {
+    public float textScale;
+
+    public TextScaledButtonWidget(Screen screen, int x, int y, int width, int height, float textScale, Component message, Component tooltip, OnPress onPress) {
+        super(screen, x, y, width, height, message, tooltip, onPress);
+        this.textScale = textScale;
+    }
+
+    public TextScaledButtonWidget(Screen screen, int x, int y, int width, int height, float textScale, Component message, OnPress onPress) {
+        this(screen, x, y, width, height, textScale, message, null, onPress);
+    }
+
+    @Override
+    public void renderString(GuiGraphics graphics, Font textRenderer, int color) {
+        Font font = Minecraft.getInstance().font;
+        PoseStack pose = graphics.pose();
+
+        pose.pushPose();
+        pose.translate(((this.getX() + this.width / 2f) - font.width(getMessage()) * textScale / 2), (float)this.getY() + (this.height - 8 * textScale) / 2f / textScale, 0);
+        pose.scale(textScale, textScale, 1);
+        graphics.drawString(font, getMessage(), 0, 0, color | Mth.ceil(this.alpha * 255.0F) << 24, true);
+        pose.popPose();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/TooltipButtonWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/TooltipButtonWidget.java
new file mode 100644
index 0000000..396f20b
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/TooltipButtonWidget.java
@@ -0,0 +1,25 @@
+package dev.isxander.yacl3.gui;
+
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.Tooltip;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipPositioner;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.NotNull;
+
+public class TooltipButtonWidget extends Button {
+
+    protected final Screen screen;
+
+    public TooltipButtonWidget(Screen screen, int x, int y, int width, int height, Component message, Component tooltip, OnPress onPress) {
+        super(x, y, width, height, message, onPress, DEFAULT_NARRATION);
+        this.screen = screen;
+        if (tooltip != null)
+            setTooltip(Tooltip.create(tooltip));
+    }
+
+    @Override
+    protected @NotNull ClientTooltipPositioner createTooltipPositioner() {
+        return new YACLTooltipPositioner(this);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/YACLScreen.java b/common/src/main/java/dev/isxander/yacl3/gui/YACLScreen.java
new file mode 100644
index 0000000..5d40a07
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/YACLScreen.java
@@ -0,0 +1,358 @@
+package dev.isxander.yacl3.gui;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.*;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.api.utils.MutableDimension;
+import dev.isxander.yacl3.api.utils.OptionUtils;
+import dev.isxander.yacl3.gui.tab.ScrollableNavigationBar;
+import dev.isxander.yacl3.gui.tab.ListHolderWidget;
+import dev.isxander.yacl3.gui.tab.TabExt;
+import dev.isxander.yacl3.gui.utils.GuiUtils;
+import dev.isxander.yacl3.impl.utils.YACLConstants;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.MultiLineLabel;
+import net.minecraft.client.gui.components.Tooltip;
+import net.minecraft.client.gui.components.tabs.Tab;
+import net.minecraft.client.gui.components.tabs.TabManager;
+import net.minecraft.client.gui.components.tabs.TabNavigationBar;
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.tooltip.TooltipRenderUtil;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
+
+public class YACLScreen extends Screen {
+    public final YetAnotherConfigLib config;
+
+    private final Screen parent;
+
+    public final TabManager tabManager = new TabManager(this::addRenderableWidget, this::removeWidget);
+    public TabNavigationBar tabNavigationBar;
+    public Tab[] tabs;
+    public ScreenRectangle tabArea;
+
+    public Component saveButtonMessage, saveButtonTooltipMessage;
+    private int saveButtonMessageTime;
+
+    public YACLScreen(YetAnotherConfigLib config, Screen parent) {
+        super(config.title());
+        this.config = config;
+        this.parent = parent;
+    }
+
+    @Override
+    protected void init() {
+        tabNavigationBar = new ScrollableNavigationBar(this.width, tabManager, config.categories()
+                .stream()
+                .map(category -> {
+                    if (category instanceof PlaceholderCategory placeholder)
+                        return new PlaceholderTab(placeholder);
+                    return new CategoryTab(category);
+                }).toList());
+        tabNavigationBar.selectTab(0, false);
+        tabNavigationBar.arrangeElements();
+        ScreenRectangle navBarArea = tabNavigationBar.getRectangle();
+        tabArea = new ScreenRectangle(0, navBarArea.height() - 1, this.width, this.height - navBarArea.height() + 1);
+        tabManager.setTabArea(tabArea);
+        addRenderableWidget(tabNavigationBar);
+
+        config.initConsumer().accept(this);
+    }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        renderDirtBackground(graphics);
+        super.render(graphics, mouseX, mouseY, delta);
+    }
+
+    protected void finishOrSave() {
+        saveButtonMessage = null;
+
+        if (pendingChanges()) {
+            Set<OptionFlag> flags = new HashSet<>();
+            OptionUtils.forEachOptions(config, option -> {
+                if (option.applyValue()) {
+                    flags.addAll(option.flags());
+                }
+            });
+            OptionUtils.forEachOptions(config, option -> {
+                if (option.changed()) {
+                    // if still changed after applying, reset to the current value from binding
+                    // as something has gone wrong.
+                    option.forgetPendingValue();
+                    YACLConstants.LOGGER.error("Option '{}' value mismatch after applying! Reset to binding's getter.", option.name().getString());
+                }
+            });
+            config.saveFunction().run();
+
+            flags.forEach(flag -> flag.accept(minecraft));
+        } else onClose();
+    }
+
+    protected void cancelOrReset() {
+        if (pendingChanges()) { // if pending changes, button acts as a cancel button
+            OptionUtils.forEachOptions(config, Option::forgetPendingValue);
+            onClose();
+        } else { // if not, button acts as a reset button
+            OptionUtils.forEachOptions(config, Option::requestSetDefault);
+        }
+    }
+
+    protected void undo() {
+        OptionUtils.forEachOptions(config, Option::forgetPendingValue);
+    }
+
+    @Override
+    public void tick() {
+        tabManager.tickCurrent();
+
+        if (saveButtonMessage != null) {
+            if (saveButtonMessageTime > 140) {
+                saveButtonMessage = null;
+                saveButtonTooltipMessage = null;
+                saveButtonMessageTime = 0;
+            } else {
+                saveButtonMessageTime++;
+                //finishedSaveButton.setMessage(saveButtonMessage);
+                if (saveButtonTooltipMessage != null) {
+                    //finishedSaveButton.setTooltip(saveButtonTooltipMessage);
+                }
+            }
+        }
+    }
+
+    private void setSaveButtonMessage(Component message, Component tooltip) {
+        saveButtonMessage = message;
+        saveButtonTooltipMessage = tooltip;
+        saveButtonMessageTime = 0;
+    }
+
+    private boolean pendingChanges() {
+        AtomicBoolean pendingChanges = new AtomicBoolean(false);
+        OptionUtils.consumeOptions(config, (option) -> {
+            if (option.changed()) {
+                pendingChanges.set(true);
+                return true;
+            }
+            return false;
+        });
+
+        return pendingChanges.get();
+    }
+
+    @Override
+    public boolean shouldCloseOnEsc() {
+        if (pendingChanges()) {
+            setSaveButtonMessage(Component.translatable("yacl.gui.save_before_exit").withStyle(ChatFormatting.RED), Component.translatable("yacl.gui.save_before_exit.tooltip"));
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public void onClose() {
+        minecraft.setScreen(parent);
+    }
+
+    public static void renderMultilineTooltip(GuiGraphics graphics, Font font, MultiLineLabel text, int centerX, int yAbove, int yBelow, int screenWidth, int screenHeight) {
+        if (text.getLineCount() > 0) {
+            int maxWidth = text.getWidth();
+            int lineHeight = font.lineHeight + 1;
+            int height = text.getLineCount() * lineHeight - 1;
+
+            int belowY = yBelow + 12;
+            int aboveY = yAbove - height + 12;
+            int maxBelow = screenHeight - (belowY + height);
+            int minAbove = aboveY - height;
+            int y = aboveY;
+            if (minAbove < 8)
+                y = maxBelow > minAbove ? belowY : aboveY;
+
+            int x = Math.max(centerX - text.getWidth() / 2 - 12, -6);
+
+            int drawX = x + 12;
+            int drawY = y - 12;
+
+            graphics.pose().pushPose();
+            Tesselator tesselator = Tesselator.getInstance();
+            BufferBuilder bufferBuilder = tesselator.getBuilder();
+            RenderSystem.setShader(GameRenderer::getPositionColorShader);
+            bufferBuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+            TooltipRenderUtil.renderTooltipBackground(
+                    graphics,
+                    drawX,
+                    drawY,
+                    maxWidth,
+                    height,
+                    400
+            );
+            RenderSystem.enableDepthTest();
+            RenderSystem.enableBlend();
+            RenderSystem.defaultBlendFunc();
+            BufferUploader.drawWithShader(bufferBuilder.end());
+            RenderSystem.disableBlend();
+            graphics.pose().translate(0.0, 0.0, 400.0);
+
+            text.renderLeftAligned(graphics, drawX, drawY, lineHeight, -1);
+
+            graphics.pose().popPose();
+        }
+    }
+
+    public class CategoryTab implements TabExt {
+        private final ConfigCategory category;
+        private final Tooltip tooltip;
+
+        private ListHolderWidget<OptionListWidget> optionList;
+        private final Button saveFinishedButton;
+        private final Button cancelResetButton;
+        private final Button undoButton;
+        private final SearchFieldWidget searchField;
+        private OptionDescriptionWidget descriptionWidget;
+
+        public CategoryTab(ConfigCategory category) {
+            this.category = category;
+            this.tooltip = Tooltip.create(category.tooltip());
+
+            int columnWidth = width / 3;
+            int padding = columnWidth / 20;
+            columnWidth = Math.min(columnWidth, 400);
+            int paddedWidth = columnWidth - padding * 2;
+            MutableDimension<Integer> actionDim = Dimension.ofInt(width / 3 * 2 + width / 6, height - padding - 20, paddedWidth, 20);
+
+            saveFinishedButton = Button.builder(Component.literal("Done"), btn -> finishOrSave())
+                    .pos(actionDim.x() - actionDim.width() / 2, actionDim.y())
+                    .size(actionDim.width(), actionDim.height())
+                    .build();
+
+            actionDim.expand(-actionDim.width() / 2 - 2, 0).move(-actionDim.width() / 2 - 2, -22);
+            cancelResetButton = Button.builder(Component.literal("Cancel"), btn -> cancelOrReset())
+                    .pos(actionDim.x() - actionDim.width() / 2, actionDim.y())
+                    .size(actionDim.width(), actionDim.height())
+                    .build();
+
+            actionDim.move(actionDim.width() + 4, 0);
+            undoButton = Button.builder(Component.translatable("yacl.gui.undo"), btn -> undo())
+                    .pos(actionDim.x() - actionDim.width() / 2, actionDim.y())
+                    .size(actionDim.width(), actionDim.height())
+                    .tooltip(Tooltip.create(Component.translatable("yacl.gui.undo.tooltip")))
+                    .build();
+
+            searchField = new SearchFieldWidget(
+                    YACLScreen.this,
+                    font,
+                    width / 3 * 2 + width / 6 - paddedWidth / 2 + 1,
+                    undoButton.getY() - 22,
+                    paddedWidth - 2, 18,
+                    Component.translatable("gui.recipebook.search_hint"),
+                    Component.translatable("gui.recipebook.search_hint"),
+                    searchQuery -> optionList.getList().updateSearchQuery(searchQuery)
+            );
+
+            this.optionList = new ListHolderWidget<>(
+                    () -> new ScreenRectangle(tabArea.position(), tabArea.width() / 3 * 2 + 1, tabArea.height()),
+                    new OptionListWidget(YACLScreen.this, category, minecraft, 0, 0, width / 3 * 2 + 1, height, desc -> {
+                        descriptionWidget.setOptionDescription(desc);
+                    })
+            );
+
+            descriptionWidget = new OptionDescriptionWidget(
+                    () -> new ScreenRectangle(
+                            width / 3 * 2 + padding,
+                            tabArea.top() + padding,
+                            paddedWidth,
+                            searchField.getY() - 1 - tabArea.top() - padding * 2
+                    ),
+                    null
+            );
+
+            updateButtons();
+        }
+
+        @Override
+        public Component getTabTitle() {
+            return category.name();
+        }
+
+        @Override
+        public void visitChildren(Consumer<AbstractWidget> consumer) {
+            consumer.accept(optionList);
+            consumer.accept(saveFinishedButton);
+            consumer.accept(cancelResetButton);
+            consumer.accept(undoButton);
+            consumer.accept(searchField);
+            consumer.accept(descriptionWidget);
+        }
+
+        @Override
+        public void doLayout(ScreenRectangle screenRectangle) {
+
+        }
+
+        @Override
+        public void tick() {
+            updateButtons();
+            searchField.tick();
+            descriptionWidget.tick();
+        }
+
+        @Nullable
+        @Override
+        public Tooltip getTooltip() {
+            return tooltip;
+        }
+
+        private void updateButtons() {
+            boolean pendingChanges = pendingChanges();
+
+            undoButton.active = pendingChanges;
+            saveFinishedButton.setMessage(pendingChanges ? Component.translatable("yacl.gui.save") : GuiUtils.translatableFallback("yacl.gui.done", CommonComponents.GUI_DONE));
+            saveFinishedButton.setTooltip(Tooltip.create(pendingChanges ? Component.translatable("yacl.gui.save.tooltip") : Component.translatable("yacl.gui.finished.tooltip")));
+            cancelResetButton.setMessage(pendingChanges ? GuiUtils.translatableFallback("yacl.gui.cancel", CommonComponents.GUI_CANCEL) : Component.translatable("controls.reset"));
+            cancelResetButton.setTooltip(Tooltip.create(pendingChanges ? Component.translatable("yacl.gui.cancel.tooltip") : Component.translatable("yacl.gui.reset.tooltip")));
+        }
+    }
+
+    public class PlaceholderTab implements TabExt {
+        private final PlaceholderCategory category;
+        private final Tooltip tooltip;
+
+        public PlaceholderTab(PlaceholderCategory category) {
+            this.category = category;
+            this.tooltip = Tooltip.create(category.tooltip());
+        }
+
+        @Override
+        public Component getTabTitle() {
+            return category.name();
+        }
+
+        @Override
+        public void visitChildren(Consumer<AbstractWidget> consumer) {
+
+        }
+
+        @Override
+        public void doLayout(ScreenRectangle screenRectangle) {
+            minecraft.setScreen(category.screen().apply(minecraft, YACLScreen.this));
+        }
+
+        @Override
+        public @Nullable Tooltip getTooltip() {
+            return this.tooltip;
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/YACLTooltipPositioner.java b/common/src/main/java/dev/isxander/yacl3/gui/YACLTooltipPositioner.java
new file mode 100644
index 0000000..bb87170
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/YACLTooltipPositioner.java
@@ -0,0 +1,48 @@
+package dev.isxander.yacl3.gui;
+
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipPositioner;
+import net.minecraft.util.Mth;
+import org.joml.Vector2i;
+import org.joml.Vector2ic;
+
+import java.util.function.Supplier;
+
+public class YACLTooltipPositioner implements ClientTooltipPositioner {
+    private final Supplier<ScreenRectangle> buttonDimensions;
+
+    public YACLTooltipPositioner(net.minecraft.client.gui.components.AbstractWidget widget) {
+        this.buttonDimensions = widget::getRectangle;
+    }
+
+    public YACLTooltipPositioner(dev.isxander.yacl3.gui.AbstractWidget widget) {
+        this.buttonDimensions = () -> {
+            var dim = widget.getDimension();
+            return new ScreenRectangle(dim.x(), dim.y(), dim.width(), dim.height());
+        };
+    }
+
+    public YACLTooltipPositioner(Supplier<ScreenRectangle> buttonDimensions) {
+        this.buttonDimensions = buttonDimensions;
+    }
+
+    @Override
+    public Vector2ic positionTooltip(int guiWidth, int guiHeight, int x, int y, int width, int height) {
+        ScreenRectangle buttonDimensions = this.buttonDimensions.get();
+
+        int centerX = buttonDimensions.left() + buttonDimensions.width() / 2;
+        int aboveY = buttonDimensions.top() - height - 4;
+        int belowY = buttonDimensions.top() + buttonDimensions.height() + 4;
+
+        int maxBelow = guiHeight - (belowY + height);
+        int minAbove = aboveY - height;
+
+        int yResult = aboveY;
+        if (minAbove < 8)
+            yResult = maxBelow > minAbove ? belowY : aboveY;
+
+        int xResult = Mth.clamp(centerX - width / 2, -4, guiWidth - width - 4);
+
+        return new Vector2i(xResult, yResult);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java
new file mode 100644
index 0000000..77938f6
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java
@@ -0,0 +1,120 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.isxander.yacl3.api.ButtonOption;
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.BiConsumer;
+
+/**
+ * Simple controller that simply runs the button action on press
+ * and renders a {@link} Text on the right.
+ */
+public class ActionController implements Controller<BiConsumer<YACLScreen, ButtonOption>> {
+    public static final Component DEFAULT_TEXT = Component.translatable("yacl.control.action.execute");
+
+    private final ButtonOption option;
+    private final Component text;
+
+    /**
+     * Constructs an action controller
+     * with the default formatter of {@link ActionController#DEFAULT_TEXT}
+     *
+     * @param option bound option
+     */
+    public ActionController(ButtonOption option) {
+        this(option, DEFAULT_TEXT);
+    }
+
+    /**
+     * Constructs an action controller
+     *
+     * @param option bound option
+     * @param text text to display
+     */
+    public ActionController(ButtonOption option, Component text) {
+        this.option = option;
+        this.text = text;
+
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public ButtonOption option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return text;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new ActionControllerElement(this, screen, widgetDimension);
+    }
+
+    public static class ActionControllerElement extends ControllerWidget<ActionController> {
+        private final String buttonString;
+
+        public ActionControllerElement(ActionController control, YACLScreen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+            buttonString = control.formatValue().getString().toLowerCase();
+        }
+
+        public void executeAction() {
+            playDownSound();
+            control.option().action().accept(screen, control.option());
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (isMouseOver(mouseX, mouseY) && isAvailable()) {
+                executeAction();
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+            if (!focused) {
+                return false;
+            }
+
+            if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_SPACE || keyCode == InputConstants.KEY_NUMPADENTER) {
+                executeAction();
+                return true;
+            }
+
+            return false;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return getUnhoveredControlWidth();
+        }
+
+        @Override
+        public boolean canReset() {
+            return false;
+        }
+
+        @Override
+        public boolean matchesSearch(String query) {
+            return super.matchesSearch(query) || buttonString.contains(query);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java
new file mode 100644
index 0000000..9f21755
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java
@@ -0,0 +1,157 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+/**
+ * This controller renders a simple formatted {@link Component}
+ */
+public class BooleanController implements Controller<Boolean> {
+
+    public static final Function<Boolean, Component> ON_OFF_FORMATTER = (state) ->
+            state
+                    ? CommonComponents.OPTION_ON
+                    : CommonComponents.OPTION_OFF;
+
+    public static final Function<Boolean, Component> TRUE_FALSE_FORMATTER = (state) ->
+            state
+                    ? Component.translatable("yacl.control.boolean.true")
+                    : Component.translatable("yacl.control.boolean.false");
+
+    public static final Function<Boolean, Component> YES_NO_FORMATTER = (state) ->
+            state
+                    ? CommonComponents.GUI_YES
+                    : CommonComponents.GUI_NO;
+
+    private final Option<Boolean> option;
+    private final Function<Boolean, Component> valueFormatter;
+    private final boolean coloured;
+
+    /**
+     * Constructs a tickbox controller
+     * with the default value formatter of {@link BooleanController#ON_OFF_FORMATTER}
+     *
+     * @param option bound option
+     */
+    public BooleanController(Option<Boolean> option) {
+        this(option, ON_OFF_FORMATTER, false);
+    }
+
+    /**
+     * Constructs a tickbox controller
+     * with the default value formatter of {@link BooleanController#ON_OFF_FORMATTER}
+     *
+     * @param option bound option
+     * @param coloured value format is green or red depending on the state
+     */
+    public BooleanController(Option<Boolean> option, boolean coloured) {
+        this(option, ON_OFF_FORMATTER, coloured);
+    }
+
+    /**
+     * Constructs a tickbox controller
+     *
+     * @param option bound option
+     * @param valueFormatter format value into any {@link Component}
+     * @param coloured value format is green or red depending on the state
+     */
+    public BooleanController(Option<Boolean> option, Function<Boolean, Component> valueFormatter, boolean coloured) {
+        this.option = option;
+        this.valueFormatter = valueFormatter;
+        this.coloured = coloured;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Boolean> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    /**
+     * Value format is green or red depending on the state
+     */
+    public boolean coloured() {
+        return coloured;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new BooleanControllerElement(this, screen, widgetDimension);
+    }
+
+    public static class BooleanControllerElement extends ControllerWidget<BooleanController> {
+        public BooleanControllerElement(BooleanController control, YACLScreen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+        }
+
+        @Override
+        protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY) || !isAvailable())
+                return false;
+
+            toggleSetting();
+            return true;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return getUnhoveredControlWidth();
+        }
+
+        public void toggleSetting() {
+            control.option().requestSet(!control.option().pendingValue());
+            playDownSound();
+        }
+
+        @Override
+        protected Component getValueText() {
+            if (control.coloured()) {
+                return super.getValueText().copy().withStyle(control.option().pendingValue() ? ChatFormatting.GREEN : ChatFormatting.RED);
+            }
+
+            return super.getValueText();
+        }
+
+        @Override
+        public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+            if (!isFocused()) {
+                return false;
+            }
+
+            if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_SPACE || keyCode == InputConstants.KEY_NUMPADENTER) {
+                toggleSetting();
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java
new file mode 100644
index 0000000..56e6d30
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java
@@ -0,0 +1,220 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.api.utils.MutableDimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.controllers.string.IStringController;
+import dev.isxander.yacl3.gui.controllers.string.StringControllerElement;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+
+import java.awt.*;
+import java.util.List;
+
+/**
+ * A color controller that uses a hex color field as input.
+ */
+public class ColorController implements IStringController<Color> {
+    private final Option<Color> option;
+    private final boolean allowAlpha;
+
+    /**
+     * Constructs a color controller with {@link ColorController#allowAlpha()} defaulting to false
+     *
+     * @param option bound option
+     */
+    public ColorController(Option<Color> option) {
+        this(option, false);
+    }
+
+    /**
+     * Constructs a color controller
+     *
+     * @param option bound option
+     * @param allowAlpha allows the color input to accept alpha values
+     */
+    public ColorController(Option<Color> option, boolean allowAlpha) {
+        this.option = option;
+        this.allowAlpha = allowAlpha;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Color> option() {
+        return option;
+    }
+
+    public boolean allowAlpha() {
+        return allowAlpha;
+    }
+
+    @Override
+    public String getString() {
+        return formatValue().getString();
+    }
+
+    @Override
+    public Component formatValue() {
+        MutableComponent text = Component.literal("#");
+        text.append(Component.literal(toHex(option().pendingValue().getRed())).withStyle(ChatFormatting.RED));
+        text.append(Component.literal(toHex(option().pendingValue().getGreen())).withStyle(ChatFormatting.GREEN));
+        text.append(Component.literal(toHex(option().pendingValue().getBlue())).withStyle(ChatFormatting.BLUE));
+        if (allowAlpha()) text.append(toHex(option().pendingValue().getAlpha()));
+        return text;
+    }
+
+    private String toHex(int value) {
+        String hex = Integer.toString(value, 16).toUpperCase();
+        if (hex.length() == 1)
+            hex = "0" + hex;
+        return hex;
+    }
+
+    @Override
+    public void setFromString(String value) {
+        if (value.startsWith("#"))
+            value = value.substring(1);
+
+        int red = Integer.parseInt(value.substring(0, 2), 16);
+        int green = Integer.parseInt(value.substring(2, 4), 16);
+        int blue = Integer.parseInt(value.substring(4, 6), 16);
+
+        if (allowAlpha()) {
+            int alpha = Integer.parseInt(value.substring(6, 8), 16);
+            option().requestSet(new Color(red, green, blue, alpha));
+        } else {
+            option().requestSet(new Color(red, green, blue));
+        }
+    }
+
+    @Override
+    public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new ColorControllerElement(this, screen, widgetDimension);
+    }
+
+    public static class ColorControllerElement extends StringControllerElement {
+        private final ColorController colorController;
+
+        protected MutableDimension<Integer> colorPreviewDim;
+
+        private final List<Character> allowedChars;
+
+        public ColorControllerElement(ColorController control, YACLScreen screen, Dimension<Integer> dim) {
+            super(control, screen, dim, true);
+            this.colorController = control;
+            this.allowedChars = ImmutableList.of('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
+        }
+
+        @Override
+        protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+            if (isHovered()) {
+                colorPreviewDim.move(-inputFieldBounds.width() - 5, 0);
+                super.drawValueText(graphics, mouseX, mouseY, delta);
+            }
+
+            graphics.fill(colorPreviewDim.x(), colorPreviewDim.y(), colorPreviewDim.xLimit(), colorPreviewDim.yLimit(), colorController.option().pendingValue().getRGB());
+            drawOutline(graphics, colorPreviewDim.x(), colorPreviewDim.y(), colorPreviewDim.xLimit(), colorPreviewDim.yLimit(), 1, 0xFF000000);
+        }
+
+        @Override
+        public void write(String string) {
+            if (string.startsWith("0x")) string = string.substring(2);
+            for (char chr : string.toCharArray()) {
+                if (!allowedChars.contains(Character.toLowerCase(chr))) {
+                    return;
+                }
+            }
+
+            if (caretPos == 0)
+                return;
+
+            String trimmed = string.substring(0, Math.min(inputField.length() - caretPos, string.length()));
+
+            if (modifyInput(builder -> builder.replace(caretPos, caretPos + trimmed.length(), trimmed))) {
+                caretPos += trimmed.length();
+                setSelectionLength();
+                updateControl();
+            }
+        }
+
+        @Override
+        protected void doBackspace() {
+            if (caretPos > 1) {
+                if (modifyInput(builder -> builder.setCharAt(caretPos - 1, '0'))) {
+                    caretPos--;
+                    updateControl();
+                }
+            }
+        }
+
+        @Override
+        protected void doDelete() {
+            if (caretPos >= 1) {
+                if (modifyInput(builder -> builder.setCharAt(caretPos, '0'))) {
+                    updateControl();
+                }
+            }
+        }
+
+        @Override
+        protected boolean doCut() {
+            return false;
+        }
+
+        @Override
+        protected boolean doCopy() {
+            return false;
+        }
+
+        @Override
+        protected boolean doSelectAll() {
+            return false;
+        }
+
+        protected void setSelectionLength() {
+            selectionLength = caretPos < inputField.length() && caretPos > 0 ? 1 : 0;
+        }
+
+        @Override
+        protected int getDefaultCaretPos() {
+            return colorController.allowAlpha() ? 3 : 1;
+        }
+
+        @Override
+        public void setDimension(Dimension<Integer> dim) {
+            super.setDimension(dim);
+
+            int previewSize = (dim.height() - getYPadding() * 2) / 2;
+            colorPreviewDim = Dimension.ofInt(dim.xLimit() - getXPadding() - previewSize, dim.centerY() - previewSize / 2, previewSize, previewSize);
+        }
+
+        @Override
+        public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+            int prevSelectionLength = selectionLength;
+            selectionLength = 0;
+            if (super.keyPressed(keyCode, scanCode, modifiers)) {
+                caretPos = Math.max(1, caretPos);
+                setSelectionLength();
+                return true;
+            } else selectionLength = prevSelectionLength;
+            return false;
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (super.mouseClicked(mouseX, mouseY, button)) {
+                caretPos = Math.max(1, caretPos);
+                setSelectionLength();
+                return true;
+            }
+            return false;
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java
new file mode 100644
index 0000000..cf7d0dc
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java
@@ -0,0 +1,157 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.utils.GuiUtils;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.ComponentPath;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.MultiLineLabel;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.navigation.FocusNavigationEvent;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class ControllerWidget<T extends Controller<?>> extends AbstractWidget {
+    protected final T control;
+    protected MultiLineLabel wrappedTooltip;
+    protected final YACLScreen screen;
+
+    protected boolean focused = false;
+    protected boolean hovered = false;
+
+    protected final Component modifiedOptionName;
+    protected final String optionNameString;
+
+    public ControllerWidget(T control, YACLScreen screen, Dimension<Integer> dim) {
+        super(dim);
+        this.control = control;
+        this.screen = screen;
+        control.option().addListener((opt, pending) -> updateTooltip());
+        updateTooltip();
+        this.modifiedOptionName = control.option().name().copy().withStyle(ChatFormatting.ITALIC);
+        this.optionNameString = control.option().name().getString().toLowerCase();
+    }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        hovered = isMouseOver(mouseX, mouseY);
+
+        Component name = control.option().changed() ? modifiedOptionName : control.option().name();
+        Component shortenedName = Component.literal(GuiUtils.shortenString(name.getString(), textRenderer, getDimension().width() - getControlWidth() - getXPadding() - 7, "...")).setStyle(name.getStyle());
+
+        drawButtonRect(graphics, getDimension().x(), getDimension().y(), getDimension().xLimit(), getDimension().yLimit(), isHovered(), isAvailable());
+        graphics.drawString(textRenderer, shortenedName, getDimension().x() + getXPadding(), getTextY(), getValueColor(), true);
+
+
+        drawValueText(graphics, mouseX, mouseY, delta);
+        if (isHovered()) {
+            drawHoveredControl(graphics, mouseX, mouseY, delta);
+        }
+    }
+
+    protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+
+    }
+
+    protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        Component valueText = getValueText();
+        graphics.drawString(textRenderer, valueText, getDimension().xLimit() - textRenderer.width(valueText) - getXPadding(), getTextY(), getValueColor(), true);
+    }
+
+    private void updateTooltip() {
+        this.wrappedTooltip = MultiLineLabel.create(textRenderer, control.option().tooltip(), screen.width / 3 * 2 - 10);
+    }
+
+    protected int getControlWidth() {
+        return isHovered() ? getHoveredControlWidth() : getUnhoveredControlWidth();
+    }
+
+    public boolean isHovered() {
+        return isAvailable() && (hovered || focused);
+    }
+
+    protected abstract int getHoveredControlWidth();
+
+    protected int getUnhoveredControlWidth() {
+        return textRenderer.width(getValueText());
+    }
+
+    protected int getXPadding() {
+        return 5;
+    }
+
+    protected int getYPadding() {
+        return 2;
+    }
+
+    protected Component getValueText() {
+        return control.formatValue();
+    }
+
+    protected boolean isAvailable() {
+        return control.option().available();
+    }
+
+    protected int getValueColor() {
+        return isAvailable() ? -1 : inactiveColor;
+    }
+
+    @Override
+    public boolean canReset() {
+        return true;
+    }
+
+    protected void drawOutline(GuiGraphics graphics, int x1, int y1, int x2, int y2, int width, int color) {
+        graphics.fill(x1, y1, x2, y1 + width, color);
+        graphics.fill(x2, y1, x2 - width, y2, color);
+        graphics.fill(x1, y2, x2, y2 - width, color);
+        graphics.fill(x1, y1, x1 + width, y2, color);
+    }
+
+    protected int getTextY() {
+        return (int)(getDimension().y() + getDimension().height() / 2f - textRenderer.lineHeight / 2f);
+    }
+
+    @Nullable
+    @Override
+    public ComponentPath nextFocusPath(FocusNavigationEvent focusNavigationEvent) {
+        if (!this.isAvailable())
+            return null;
+        return !this.isFocused() ? ComponentPath.leaf(this) : null;
+    }
+
+    @Override
+    public boolean isFocused() {
+        return focused;
+    }
+
+    @Override
+    public void setFocused(boolean focused) {
+        this.focused = focused;
+    }
+
+    @Override
+    public void unfocus() {
+        this.focused = false;
+    }
+
+    @Override
+    public boolean matchesSearch(String query) {
+        return optionNameString.contains(query.toLowerCase());
+    }
+
+    @Override
+    public NarrationPriority narrationPriority() {
+        return focused ? NarrationPriority.FOCUSED : isHovered() ? NarrationPriority.HOVERED : NarrationPriority.NONE;
+    }
+
+    @Override
+    public void updateNarration(NarrationElementOutput builder) {
+        builder.add(NarratedElementType.TITLE, control.option().name());
+        builder.add(NarratedElementType.HINT, control.option().tooltip());
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java
new file mode 100644
index 0000000..fee6c19
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java
@@ -0,0 +1,193 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.client.gui.ComponentPath;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.MultiLineLabel;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.navigation.FocusNavigationEvent;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.HoverEvent;
+import net.minecraft.network.chat.Style;
+import net.minecraft.util.FormattedCharSequence;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * Simply renders some text as a label.
+ */
+public class LabelController implements Controller<Component> {
+    private final Option<Component> option;
+    /**
+     * Constructs a label controller
+     *
+     * @param option bound option
+     */
+    public LabelController(Option<Component> option) {
+        this.option = option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Component> option() {
+        return option;
+    }
+
+    @Override
+    public Component formatValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new LabelControllerElement(screen, widgetDimension);
+    }
+
+    public class LabelControllerElement extends AbstractWidget {
+        private List<FormattedCharSequence> wrappedText;
+        protected MultiLineLabel wrappedTooltip;
+        protected boolean focused;
+
+        protected final YACLScreen screen;
+
+        public LabelControllerElement(YACLScreen screen, Dimension<Integer> dim) {
+            super(dim);
+            this.screen = screen;
+            option().addListener((opt, pending) -> updateTooltip());
+            updateTooltip();
+            updateText();
+        }
+
+        @Override
+        public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+            updateText();
+
+            int y = getDimension().y();
+            for (FormattedCharSequence text : wrappedText) {
+                graphics.drawString(textRenderer, text, getDimension().x() + getXPadding(), y + getYPadding(), option().available() ? -1 : 0xFFA0A0A0, true);
+                y += textRenderer.lineHeight;
+            }
+
+            if (isFocused()) {
+                graphics.fill(getDimension().x() - 1, getDimension().y() - 1, getDimension().xLimit() + 1, getDimension().y(), -1);
+                graphics.fill(getDimension().x() - 1, getDimension().y() - 1, getDimension().x(), getDimension().yLimit() + 1, -1);
+                graphics.fill(getDimension().x() - 1, getDimension().yLimit(), getDimension().xLimit() + 1, getDimension().yLimit() + 1, -1);
+                graphics.fill(getDimension().xLimit(), getDimension().y() - 1, getDimension().xLimit() + 1, getDimension().yLimit() + 1, -1);
+            }
+
+            graphics.pose().pushPose();
+            graphics.pose().translate(0, 0, 100);
+            if (isMouseOver(mouseX, mouseY)) {
+                YACLScreen.renderMultilineTooltip(graphics, textRenderer, wrappedTooltip, getDimension().centerX(), getDimension().y() - 5, getDimension().yLimit() + 5, screen.width, screen.height);
+
+                Style style = getStyle(mouseX, mouseY);
+                if (style != null && style.getHoverEvent() != null) {
+                    HoverEvent hoverEvent = style.getHoverEvent();
+                    HoverEvent.ItemStackInfo itemStackContent = hoverEvent.getValue(HoverEvent.Action.SHOW_ITEM);
+                    if (itemStackContent != null) {
+                        ItemStack stack = itemStackContent.getItemStack();
+                        graphics.renderTooltip(textRenderer, Screen.getTooltipFromItem(client, stack), stack.getTooltipImage(), mouseX, mouseY);
+                    } else {
+                        HoverEvent.EntityTooltipInfo entityContent = hoverEvent.getValue(HoverEvent.Action.SHOW_ENTITY);
+                        if (entityContent != null) {
+                            if (this.client.options.advancedItemTooltips) {
+                                graphics.renderComponentTooltip(textRenderer, entityContent.getTooltipLines(), mouseX, mouseY);
+                            }
+                        } else {
+                            Component text = hoverEvent.getValue(HoverEvent.Action.SHOW_TEXT);
+                            if (text != null) {
+                                MultiLineLabel multilineText = MultiLineLabel.create(textRenderer, text, getDimension().width());
+                                YACLScreen.renderMultilineTooltip(graphics, textRenderer, multilineText, getDimension().centerX(), getDimension().y(), getDimension().yLimit(), screen.width, screen.height);
+                            }
+                        }
+                    }
+                }
+            }
+            graphics.pose().popPose();
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY))
+                return false;
+
+            Style style = getStyle((int) mouseX, (int) mouseY);
+            return screen.handleComponentClicked(style);
+        }
+
+        protected Style getStyle(int mouseX, int mouseY) {
+            if (!getDimension().isPointInside(mouseX, mouseY))
+                return null;
+
+            int x = mouseX - getDimension().x();
+            int y = mouseY - getDimension().y() - getYPadding();
+            int line = y / textRenderer.lineHeight;
+
+            if (x < 0 || x > getDimension().xLimit()) return null;
+            if (y < 0 || y > getDimension().yLimit()) return null;
+            if (line < 0 || line >= wrappedText.size()) return null;
+
+            return textRenderer.getSplitter().componentStyleAtWidth(wrappedText.get(line), x);
+        }
+
+        private int getXPadding() {
+            return 4;
+        }
+
+        private int getYPadding() {
+            return 3;
+        }
+
+        private void updateText() {
+            wrappedText = textRenderer.split(formatValue(), getDimension().width() - getXPadding() * 2);
+            setDimension(getDimension().withHeight(wrappedText.size() * textRenderer.lineHeight + getYPadding() * 2));
+        }
+
+        private void updateTooltip() {
+            this.wrappedTooltip = MultiLineLabel.create(textRenderer, option().tooltip(), screen.width / 3 * 2 - 10);
+        }
+
+        @Override
+        public boolean matchesSearch(String query) {
+            return formatValue().getString().toLowerCase().contains(query.toLowerCase());
+        }
+
+        @Nullable
+        @Override
+        public ComponentPath nextFocusPath(FocusNavigationEvent focusNavigationEvent) {
+            if (!option().available())
+                return null;
+            return !this.isFocused() ? ComponentPath.leaf(this) : null;
+        }
+
+        @Override
+        public boolean isFocused() {
+            return focused;
+        }
+
+        @Override
+        public void setFocused(boolean focused) {
+            this.focused = focused;
+        }
+
+        @Override
+        public void updateNarration(NarrationElementOutput builder) {
+            builder.add(NarratedElementType.TITLE, formatValue());
+        }
+
+        @Override
+        public NarrationPriority narrationPriority() {
+            return NarrationPriority.FOCUSED;
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java
new file mode 100644
index 0000000..15deff2
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java
@@ -0,0 +1,128 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.ListOption;
+import dev.isxander.yacl3.api.ListOptionEntry;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.TooltipButtonWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.events.ContainerEventHandler;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class ListEntryWidget extends AbstractWidget implements ContainerEventHandler {
+    private final TooltipButtonWidget removeButton, moveUpButton, moveDownButton;
+    private final AbstractWidget entryWidget;
+
+    private final ListOption<?> listOption;
+    private final ListOptionEntry<?> listOptionEntry;
+
+    private final String optionNameString;
+
+    private GuiEventListener focused;
+    private boolean dragging;
+
+    public ListEntryWidget(YACLScreen screen, ListOptionEntry<?> listOptionEntry, AbstractWidget entryWidget) {
+        super(entryWidget.getDimension().withHeight(Math.max(entryWidget.getDimension().height(), 20) - ((listOptionEntry.parentGroup().indexOf(listOptionEntry) == listOptionEntry.parentGroup().options().size() - 1) ? 0 : 2))); // -2 to remove the padding
+        this.listOptionEntry = listOptionEntry;
+        this.listOption = listOptionEntry.parentGroup();
+        this.optionNameString = listOptionEntry.name().getString().toLowerCase();
+        this.entryWidget = entryWidget;
+
+        Dimension<Integer> dim = entryWidget.getDimension();
+        entryWidget.setDimension(dim.clone().move(20 * 2, 0).expand(-20 * 3, 0));
+
+        removeButton = new TooltipButtonWidget(screen, dim.xLimit() - 20, dim.y(), 20, 20, Component.literal("\u274c"), Component.translatable("yacl.list.remove"), btn -> {
+            listOption.removeEntry(listOptionEntry);
+            updateButtonStates();
+        });
+
+        moveUpButton = new TooltipButtonWidget(screen, dim.x(), dim.y(), 20, 20, Component.literal("\u2191"), Component.translatable("yacl.list.move_up"), btn -> {
+            int index = listOption.indexOf(listOptionEntry) - 1;
+            if (index >= 0) {
+                listOption.removeEntry(listOptionEntry);
+                listOption.insertEntry(index, listOptionEntry);
+                updateButtonStates();
+            }
+        });
+
+        moveDownButton = new TooltipButtonWidget(screen, dim.x() + 20, dim.y(), 20, 20, Component.literal("\u2193"), Component.translatable("yacl.list.move_down"), btn -> {
+            int index = listOption.indexOf(listOptionEntry) + 1;
+            if (index < listOption.options().size()) {
+                listOption.removeEntry(listOptionEntry);
+                listOption.insertEntry(index, listOptionEntry);
+                updateButtonStates();
+            }
+        });
+
+        updateButtonStates();
+    }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        updateButtonStates(); // update every render in case option becomes available/unavailable
+
+        removeButton.setY(getDimension().y());
+        moveUpButton.setY(getDimension().y());
+        moveDownButton.setY(getDimension().y());
+        entryWidget.setDimension(entryWidget.getDimension().withY(getDimension().y()));
+
+        removeButton.render(graphics, mouseX, mouseY, delta);
+        moveUpButton.render(graphics, mouseX, mouseY, delta);
+        moveDownButton.render(graphics, mouseX, mouseY, delta);
+        entryWidget.render(graphics, mouseX, mouseY, delta);
+    }
+
+    protected void updateButtonStates() {
+        removeButton.active = listOption.available();
+        moveUpButton.active = listOption.indexOf(listOptionEntry) > 0 && listOption.available();
+        moveDownButton.active = listOption.indexOf(listOptionEntry) < listOption.options().size() - 1 && listOption.available();
+    }
+
+    @Override
+    public void unfocus() {
+        entryWidget.unfocus();
+    }
+
+    @Override
+    public void updateNarration(NarrationElementOutput builder) {
+        entryWidget.updateNarration(builder);
+    }
+
+    @Override
+    public boolean matchesSearch(String query) {
+        return optionNameString.contains(query.toLowerCase());
+    }
+
+    @Override
+    public List<? extends GuiEventListener> children() {
+        return ImmutableList.of(moveUpButton, moveDownButton, entryWidget, removeButton);
+    }
+
+    @Override
+    public boolean isDragging() {
+        return dragging;
+    }
+
+    @Override
+    public void setDragging(boolean dragging) {
+        this.dragging = dragging;
+    }
+
+    @Nullable
+    @Override
+    public GuiEventListener getFocused() {
+        return focused;
+    }
+
+    @Override
+    public void setFocused(@Nullable GuiEventListener focused) {
+        this.focused = focused;
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java
new file mode 100644
index 0000000..de19c14
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java
@@ -0,0 +1,119 @@
+package dev.isxander.yacl3.gui.controllers;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+
+/**
+ * This controller renders a tickbox
+ */
+public class TickBoxController implements Controller<Boolean> {
+    private final Option<Boolean> option;
+
+    /**
+     * Constructs a tickbox controller
+     *
+     * @param option bound option
+     */
+    public TickBoxController(Option<Boolean> option) {
+        this.option = option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Boolean> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return Component.empty();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new TickBoxControllerElement(this, screen, widgetDimension);
+    }
+
+    public static class TickBoxControllerElement extends ControllerWidget<TickBoxController> {
+        public TickBoxControllerElement(TickBoxController control, YACLScreen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+        }
+
+        @Override
+        protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+            int outlineSize = 10;
+            int outlineX1 = getDimension().xLimit() - getXPadding() - outlineSize;
+            int outlineY1 = getDimension().centerY() - outlineSize / 2;
+            int outlineX2 = getDimension().xLimit() - getXPadding();
+            int outlineY2 = getDimension().centerY() + outlineSize / 2;
+
+            int color = getValueColor();
+            int shadowColor = multiplyColor(color, 0.25f);
+
+            drawOutline(graphics, outlineX1 + 1, outlineY1 + 1, outlineX2 + 1, outlineY2 + 1, 1, shadowColor);
+            drawOutline(graphics, outlineX1, outlineY1, outlineX2, outlineY2, 1, color);
+            if (control.option().pendingValue()) {
+                graphics.fill(outlineX1 + 3, outlineY1 + 3, outlineX2 - 1, outlineY2 - 1, shadowColor);
+                graphics.fill(outlineX1 + 2, outlineY1 + 2, outlineX2 - 2, outlineY2 - 2, color);
+            }
+        }
+
+        @Override
+        protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+            if (!isHovered())
+                drawHoveredControl(graphics, mouseX, mouseY, delta);
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY) || !isAvailable())
+                return false;
+
+            toggleSetting();
+            return true;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return 10;
+        }
+
+        @Override
+        protected int getUnhoveredControlWidth() {
+            return 10;
+        }
+
+        public void toggleSetting() {
+            control.option().requestSet(!control.option().pendingValue());
+            playDownSound();
+        }
+
+        @Override
+        public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+            if (!focused) {
+                return false;
+            }
+
+            if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_SPACE || keyCode == InputConstants.KEY_NUMPADENTER) {
+                toggleSetting();
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java
new file mode 100644
index 0000000..3d85afe
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java
@@ -0,0 +1,60 @@
+package dev.isxander.yacl3.gui.controllers.cycling;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.controllers.ControllerWidget;
+import net.minecraft.client.gui.screens.Screen;
+
+public class CyclingControllerElement extends ControllerWidget<ICyclingController<?>> {
+
+    public CyclingControllerElement(ICyclingController<?> control, YACLScreen screen, Dimension<Integer> dim) {
+        super(control, screen, dim);
+    }
+
+    public void cycleValue(int increment) {
+        int targetIdx = control.getPendingValue() + increment;
+        if (targetIdx >= control.getCycleLength()) {
+            targetIdx -= control.getCycleLength();
+        } else if (targetIdx < 0) {
+            targetIdx += control.getCycleLength();
+        }
+        control.setPendingValue(targetIdx);
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if (!isMouseOver(mouseX, mouseY) || (button != 0 && button != 1) || !isAvailable())
+            return false;
+
+        playDownSound();
+        cycleValue(button == 1 || Screen.hasShiftDown() || Screen.hasControlDown() ? -1 : 1);
+
+        return true;
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (!focused)
+            return false;
+
+        switch (keyCode) {
+            case InputConstants.KEY_LEFT ->
+                    cycleValue(-1);
+            case InputConstants.KEY_RIGHT ->
+                    cycleValue(1);
+            case InputConstants.KEY_RETURN, InputConstants.KEY_SPACE, InputConstants.KEY_NUMPADENTER ->
+                    cycleValue(Screen.hasControlDown() || Screen.hasShiftDown() ? -1 : 1);
+            default -> {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    protected int getHoveredControlWidth() {
+        return getUnhoveredControlWidth();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java
new file mode 100644
index 0000000..44fa765
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java
@@ -0,0 +1,79 @@
+package dev.isxander.yacl3.gui.controllers.cycling;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.Option;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+/**
+ * A controller where once clicked, cycles through elements
+ * in the provided list.
+ */
+public class CyclingListController<T> implements ICyclingController<T> {
+    private final Option<T> option;
+    private final Function<T, Component> valueFormatter;
+    private final ImmutableList<T> values;
+
+    /**
+     * Constructs a {@link CyclingListController}, with a default
+     * value formatter of {@link Object#toString()}.
+     * @param option option of which to bind the controller to
+     * @param values the values to cycle through
+     */
+    public CyclingListController(Option<T> option, Iterable<? extends T> values) {
+        this(option, values, value -> Component.literal(value.toString()));
+    }
+
+    /**
+     * Constructs a {@link CyclingListController}
+     * @param option option of which to bind the controller to
+     * @param values the values to cycle through
+     * @param valueFormatter function of how to convert each value to a string to display
+     */
+    public CyclingListController(Option<T> option, Iterable<? extends T> values, Function<T, Component> valueFormatter) {
+        this.option = option;
+        this.valueFormatter = valueFormatter;
+        this.values = ImmutableList.copyOf(values);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<T> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(int ordinal) {
+        option().requestSet(values.get(ordinal));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public int getPendingValue() {
+        return values.indexOf(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public int getCycleLength() {
+        return values.size();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java
new file mode 100644
index 0000000..d2df8f8
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java
@@ -0,0 +1,43 @@
+package dev.isxander.yacl3.gui.controllers.cycling;
+
+import dev.isxander.yacl3.api.NameableEnum;
+import dev.isxander.yacl3.api.Option;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.OptionEnum;
+
+import java.util.Arrays;
+import java.util.function.Function;
+
+/**
+ * Simple controller type that displays the enum on the right.
+ * <p>
+ * Cycles forward with left click, cycles backward with right click or when shift is held
+ *
+ * @param <T> enum type
+ */
+public class EnumController<T extends Enum<T>> extends CyclingListController<T> {
+    public static <T extends Enum<T>> Function<T, Component> getDefaultFormatter() {
+        return value -> {
+            if (value instanceof NameableEnum nameableEnum)
+                return nameableEnum.getDisplayName();
+            if (value instanceof OptionEnum translatableOption)
+                return translatableOption.getCaption();
+            return Component.literal(value.toString());
+        };
+    }
+
+    public EnumController(Option<T> option, Class<T> enumClass) {
+        this(option, getDefaultFormatter(), enumClass.getEnumConstants());
+    }
+
+    /**
+     * Constructs a cycling enum controller.
+     *
+     * @param option bound option
+     * @param valueFormatter format the enum into any {@link Component}
+     * @param availableValues all enum constants that can be cycled through
+     */
+    public EnumController(Option<T> option, Function<T, Component> valueFormatter, T[] availableValues) {
+        super(option, Arrays.asList(availableValues), valueFormatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java
new file mode 100644
index 0000000..cfddefa
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java
@@ -0,0 +1,38 @@
+package dev.isxander.yacl3.gui.controllers.cycling;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+
+/**
+ * This interface simply generifies setting and getting of
+ * the pending value, using an ordinal so elements can cycle through
+ * without knowing the content.
+ */
+public interface ICyclingController<T> extends Controller<T> {
+    /**
+     * Sets the pending value to whatever corresponds to the ordinal
+     * @param ordinal index of element to set
+     */
+    void setPendingValue(int ordinal);
+
+    /**
+     * Gets the pending ordinal that corresponds to the actual value
+     * @return ordinal
+     */
+    int getPendingValue();
+
+    /**
+     * Allows the element when it should wrap-around back to zeroth ordinal
+     */
+    int getCycleLength();
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new CyclingControllerElement(this, screen, widgetDimension);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/package-info.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/package-info.java
new file mode 100644
index 0000000..1819a64
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/package-info.java
@@ -0,0 +1,12 @@
+/**
+ * This package contains all {@link dev.isxander.yacl3.api.Controller} implementations
+ *
+ * <ul>
+ *     <li>For numbers: {@link dev.isxander.yacl3.gui.controllers.slider}</li>
+ *     <li>For booleans: {@link dev.isxander.yacl3.gui.controllers.TickBoxController}</li>
+ *     <li>For lists/enums: {@link dev.isxander.yacl3.gui.controllers.cycling}</li>
+ *     <li>For strings: {@link dev.isxander.yacl3.gui.controllers.string.StringController}</li>
+ *     <li>For {@link dev.isxander.yacl3.api.ButtonOption}: {@link dev.isxander.yacl3.gui.controllers.ActionController}</li>
+ * </ul>
+ */
+package dev.isxander.yacl3.gui.controllers;
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/DoubleSliderController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/DoubleSliderController.java
new file mode 100644
index 0000000..d2c0e2e
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/DoubleSliderController.java
@@ -0,0 +1,114 @@
+package dev.isxander.yacl3.gui.controllers.slider;
+
+import dev.isxander.yacl3.api.Option;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+/**
+ * {@link ISliderController} for doubles.
+ */
+public class DoubleSliderController implements ISliderController<Double> {
+    /**
+     * Formats doubles to two decimal places
+     */
+    public static final Function<Double, Component> DEFAULT_FORMATTER = value -> Component.literal(String.format("%,.2f", value).replaceAll("[\u00a0\u202F]", " "));
+
+    private final Option<Double> option;
+
+    private final double min, max, interval;
+
+    private final Function<Double, Component> valueFormatter;
+
+    /**
+     * Constructs a {@link ISliderController} for doubles
+     * using the default value formatter {@link DoubleSliderController#DEFAULT_FORMATTER}.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     */
+    public DoubleSliderController(Option<Double> option, double min, double max, double interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a {@link ISliderController} for doubles.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     * @param valueFormatter format the value into any {@link Component}
+     */
+    public DoubleSliderController(Option<Double> option, double min, double max, double interval, Function<Double, Component> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+        Validate.notNull(valueFormatter, "`valueFormatter` must not be null");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Double> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet(value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/FloatSliderController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/FloatSliderController.java
new file mode 100644
index 0000000..f9fa574
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/FloatSliderController.java
@@ -0,0 +1,114 @@
+package dev.isxander.yacl3.gui.controllers.slider;
+
+import dev.isxander.yacl3.api.Option;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+/**
+ * {@link ISliderController} for floats.
+ */
+public class FloatSliderController implements ISliderController<Float> {
+    /**
+     * Formats floats to one decimal place
+     */
+    public static final Function<Float, Component> DEFAULT_FORMATTER = value -> Component.literal(String.format("%,.1f", value).replaceAll("[\u00a0\u202F]", " "));
+
+    private final Option<Float> option;
+
+    private final float min, max, interval;
+
+    private final Function<Float, Component> valueFormatter;
+
+    /**
+     * Constructs a {@link ISliderController} for floats
+     * using the default value formatter {@link FloatSliderController#DEFAULT_FORMATTER}.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     */
+    public FloatSliderController(Option<Float> option, float min, float max, float interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a {@link ISliderController} for floats.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     * @param valueFormatter format the value into any {@link Component}
+     */
+    public FloatSliderController(Option<Float> option, float min, float max, float interval, Function<Float, Component> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+        Validate.notNull(valueFormatter, "`valueFormatter` must not be null");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Float> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((float) value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/ISliderController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/ISliderController.java
new file mode 100644
index 0000000..4a3f36b
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/ISliderController.java
@@ -0,0 +1,54 @@
+package dev.isxander.yacl3.gui.controllers.slider;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+
+/**
+ * Simple custom slider implementation that shifts the current value across when shown.
+ * <p>
+ * For simplicity, {@link SliderControllerElement} works in doubles so each
+ * {@link ISliderController} must cast to double. This is to get around re-writing the element for every type.
+ */
+public interface ISliderController<T extends Number> extends Controller<T> {
+    /**
+     * Gets the minimum value for the slider
+     */
+    double min();
+
+    /**
+     * Gets the maximum value for the slider
+     */
+    double max();
+
+    /**
+     * Gets the interval (or step size) for the slider.
+     */
+    double interval();
+
+    /**
+     * Gets the range of the slider.
+     */
+    default double range() {
+        return max() - min();
+    }
+
+    /**
+     * Sets the {@link dev.isxander.yacl3.api.Option}'s pending value
+     */
+    void setPendingValue(double value);
+
+    /**
+     * Gets the {@link dev.isxander.yacl3.api.Option}'s pending value
+     */
+    double pendingValue();
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new SliderControllerElement(this, screen, widgetDimension, min(), max(), interval());
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/IntegerSliderController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/IntegerSliderController.java
new file mode 100644
index 0000000..ea658ad
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/IntegerSliderController.java
@@ -0,0 +1,111 @@
+package dev.isxander.yacl3.gui.controllers.slider;
+
+import dev.isxander.yacl3.api.Option;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+/**
+ * {@link ISliderController} for integers.
+ */
+public class IntegerSliderController implements ISliderController<Integer> {
+    public static final Function<Integer, Component> DEFAULT_FORMATTER = value -> Component.literal(String.format("%,d", value).replaceAll("[\u00a0\u202F]", " "));
+
+    private final Option<Integer> option;
+
+    private final int min, max, interval;
+
+    private final Function<Integer, Component> valueFormatter;
+
+    /**
+     * Constructs a {@link ISliderController} for integers
+     * using the default value formatter {@link IntegerSliderController#DEFAULT_FORMATTER}.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     */
+    public IntegerSliderController(Option<Integer> option, int min, int max, int interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a {@link ISliderController} for integers.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     * @param valueFormatter format the value into any {@link Component}
+     */
+    public IntegerSliderController(Option<Integer> option, int min, int max, int interval, Function<Integer, Component> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+        Validate.notNull(valueFormatter, "`valueFormatter` must not be null");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Integer> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((int) value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/LongSliderController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/LongSliderController.java
new file mode 100644
index 0000000..336f064
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/LongSliderController.java
@@ -0,0 +1,111 @@
+package dev.isxander.yacl3.gui.controllers.slider;
+
+import dev.isxander.yacl3.api.Option;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+/**
+ * {@link ISliderController} for longs.
+ */
+public class LongSliderController implements ISliderController<Long> {
+    public static final Function<Long, Component> DEFAULT_FORMATTER = value -> Component.literal(String.format("%,d", value).replaceAll("[\u00a0\u202F]", " "));
+
+    private final Option<Long> option;
+
+    private final long min, max, interval;
+
+    private final Function<Long, Component> valueFormatter;
+
+    /**
+     * Constructs a {@link ISliderController} for longs
+     * using the default value formatter {@link LongSliderController#DEFAULT_FORMATTER}.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     */
+    public LongSliderController(Option<Long> option, long min, long max, long interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a {@link ISliderController} for longs.
+     *
+     * @param option bound option
+     * @param min minimum slider value
+     * @param max maximum slider value
+     * @param interval step size (or increments) for the slider
+     * @param valueFormatter format the value into any {@link Component}
+     */
+    public LongSliderController(Option<Long> option, long min, long max, long interval, Function<Long, Component> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+        Validate.notNull(valueFormatter, "`valueFormatter` must not be null");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<Long> option() {
+        return option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Component formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((long) value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/SliderControllerElement.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/SliderControllerElement.java
new file mode 100644
index 0000000..5590dbf
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/SliderControllerElement.java
@@ -0,0 +1,157 @@
+package dev.isxander.yacl3.gui.controllers.slider;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.controllers.ControllerWidget;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.util.Mth;
+
+public class SliderControllerElement extends ControllerWidget<ISliderController<?>> {
+    private final double min, max, interval;
+
+    private float interpolation;
+
+    private Dimension<Integer> sliderBounds;
+
+    private boolean mouseDown = false;
+
+    public SliderControllerElement(ISliderController<?> option, YACLScreen screen, Dimension<Integer> dim, double min, double max, double interval) {
+        super(option, screen, dim);
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        setDimension(dim);
+    }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        super.render(graphics, mouseX, mouseY, delta);
+
+        calculateInterpolation();
+    }
+
+    @Override
+    protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        // track
+        graphics.fill(sliderBounds.x(), sliderBounds.centerY() - 1, sliderBounds.xLimit(), sliderBounds.centerY(), -1);
+        // track shadow
+        graphics.fill(sliderBounds.x() + 1, sliderBounds.centerY(), sliderBounds.xLimit() + 1, sliderBounds.centerY() + 1, 0xFF404040);
+
+        // thumb shadow
+        graphics.fill(getThumbX() - getThumbWidth() / 2 + 1, sliderBounds.y() + 1, getThumbX() + getThumbWidth() / 2 + 1, sliderBounds.yLimit() + 1, 0xFF404040);
+        // thumb
+        graphics.fill(getThumbX() - getThumbWidth() / 2, sliderBounds.y(), getThumbX() + getThumbWidth() / 2, sliderBounds.yLimit(), -1);
+    }
+
+    @Override
+    protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        graphics.pose().pushPose();
+        if (isHovered())
+            graphics.pose().translate(-(sliderBounds.width() + 6 + getThumbWidth() / 2f), 0, 0);
+        super.drawValueText(graphics, mouseX, mouseY, delta);
+        graphics.pose().popPose();
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if (!isAvailable() || 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 (!isAvailable() || button != 0 || !mouseDown)
+            return false;
+
+        setValueFromMouse(mouseX);
+        return true;
+    }
+
+    public void incrementValue(double amount) {
+        control.setPendingValue(Mth.clamp(control.pendingValue() + interval * amount, min, max));
+        calculateInterpolation();
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        if (!isAvailable() || (!isMouseOver(mouseX, mouseY)) || (!Screen.hasShiftDown() && !Screen.hasControlDown()))
+            return false;
+
+        incrementValue(amount);
+        return true;
+    }
+
+    @Override
+    public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        if (isAvailable() && mouseDown)
+            playDownSound();
+        mouseDown = false;
+
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (!focused)
+            return false;
+
+        switch (keyCode) {
+            case InputConstants.KEY_LEFT -> incrementValue(-1);
+            case InputConstants.KEY_RIGHT -> incrementValue(1);
+            default -> {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean isMouseOver(double mouseX, double mouseY) {
+        return super.isMouseOver(mouseX, mouseY) || mouseDown;
+    }
+
+    protected void setValueFromMouse(double mouseX) {
+        double value = (mouseX - sliderBounds.x()) / sliderBounds.width() * control.range();
+        control.setPendingValue(roundToInterval(value));
+        calculateInterpolation();
+    }
+
+    protected double roundToInterval(double value) {
+        return Mth.clamp(min + (interval * Math.round(value / interval)), min, max); // extremely imprecise, requires clamping
+    }
+
+    @Override
+    protected int getHoveredControlWidth() {
+        return sliderBounds.width() + getUnhoveredControlWidth() + 6 + getThumbWidth() / 2;
+    }
+
+    protected void calculateInterpolation() {
+        interpolation = Mth.clamp((float) ((control.pendingValue() - control.min()) * 1 / control.range()), 0f, 1f);
+    }
+
+    @Override
+    public void setDimension(Dimension<Integer> dim) {
+        super.setDimension(dim);
+        int trackWidth = dim.width() / 3;
+        if (optionNameString.isEmpty())
+            trackWidth = dim.width() / 2;
+
+        sliderBounds = Dimension.ofInt(dim.xLimit() - getXPadding() - getThumbWidth() / 2 - trackWidth, dim.centerY() - 5, trackWidth, 10);
+    }
+
+    protected int getThumbX() {
+        return (int) (sliderBounds.x() + sliderBounds.width() * interpolation);
+    }
+
+    protected int getThumbWidth() {
+        return 4;
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/package-info.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/package-info.java
new file mode 100644
index 0000000..e2cb0e3
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/slider/package-info.java
@@ -0,0 +1,10 @@
+/**
+ * This package contains implementations of sliders for different number types
+ * <ul>
+ *     <li>For doubles: {@link dev.isxander.yacl3.gui.controllers.slider.DoubleSliderController}</li>
+ *     <li>For floats: {@link dev.isxander.yacl3.gui.controllers.slider.FloatSliderController}</li>
+ *     <li>For integers: {@link dev.isxander.yacl3.gui.controllers.slider.IntegerSliderController}</li>
+ *     <li>For longs: {@link dev.isxander.yacl3.gui.controllers.slider.LongSliderController}</li>
+ * </ul>
+ */
+package dev.isxander.yacl3.gui.controllers.slider;
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/IStringController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/IStringController.java
new file mode 100644
index 0000000..14d10dd
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/IStringController.java
@@ -0,0 +1,44 @@
+package dev.isxander.yacl3.gui.controllers.string;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.network.chat.Component;
+
+/**
+ * A controller that can be any type but can input and output a string.
+ */
+public interface IStringController<T> extends Controller<T> {
+    /**
+     * Gets the option's pending value as a string.
+     *
+     * @see Option#pendingValue()
+     */
+    String getString();
+
+    /**
+     * Sets the option's pending value from a string.
+     *
+     * @see Option#requestSet(Object)
+     */
+    void setFromString(String value);
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default Component formatValue() {
+        return Component.literal(getString());
+    }
+
+    default boolean isInputValid(String input) {
+        return true;
+    }
+
+    @Override
+    default AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new StringControllerElement(this, screen, widgetDimension, true);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/StringController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/StringController.java
new file mode 100644
index 0000000..4bafc0f
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/StringController.java
@@ -0,0 +1,37 @@
+package dev.isxander.yacl3.gui.controllers.string;
+
+import dev.isxander.yacl3.api.Option;
+
+/**
+ * A custom text field implementation for strings.
+ */
+public class StringController implements IStringController<String> {
+    private final Option<String> option;
+
+    /**
+     * Constructs a string controller
+     *
+     * @param option bound option
+     */
+    public StringController(Option<String> option) {
+        this.option = option;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Option<String> option() {
+        return option;
+    }
+
+    @Override
+    public String getString() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public void setFromString(String value) {
+        option().requestSet(value);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/StringControllerElement.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/StringControllerElement.java
new file mode 100644
index 0000000..a889a77
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/StringControllerElement.java
@@ -0,0 +1,403 @@
+package dev.isxander.yacl3.gui.controllers.string;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.controllers.ControllerWidget;
+import dev.isxander.yacl3.gui.utils.GuiUtils;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Consumer;
+
+public class StringControllerElement extends ControllerWidget<IStringController<?>> {
+    protected final boolean instantApply;
+
+    protected String inputField;
+    protected Dimension<Integer> inputFieldBounds;
+    protected boolean inputFieldFocused;
+
+    protected int caretPos;
+    protected int selectionLength;
+
+    protected int renderOffset;
+
+    protected float ticks;
+
+    private final Component emptyText;
+
+    public StringControllerElement(IStringController<?> control, YACLScreen screen, Dimension<Integer> dim, boolean instantApply) {
+        super(control, screen, dim);
+        this.instantApply = instantApply;
+        inputField = control.getString();
+        inputFieldFocused = false;
+        selectionLength = 0;
+        emptyText = Component.literal("Click to type...").withStyle(ChatFormatting.GRAY);
+        control.option().addListener((opt, val) -> inputField = control.getString());
+        setDimension(dim);
+    }
+
+    @Override
+    protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+
+    }
+
+    @Override
+    protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        Component valueText = getValueText();
+        if (!isHovered()) valueText = Component.literal(GuiUtils.shortenString(valueText.getString(), textRenderer, getMaxUnwrapLength(), "...")).setStyle(valueText.getStyle());
+
+        int textX = getDimension().xLimit() - textRenderer.width(valueText) + renderOffset - getXPadding();
+        graphics.enableScissor(inputFieldBounds.x(), inputFieldBounds.y() - 2, inputFieldBounds.width() + 1, inputFieldBounds.height() + 4);
+        graphics.drawString(textRenderer, valueText, textX, getTextY(), getValueColor(), true);
+
+        if (isHovered()) {
+            ticks += delta;
+
+            String text = getValueText().getString();
+
+            graphics.fill(inputFieldBounds.x(), inputFieldBounds.yLimit(), inputFieldBounds.xLimit(), inputFieldBounds.yLimit() + 1, -1);
+            graphics.fill(inputFieldBounds.x() + 1, inputFieldBounds.yLimit() + 1, inputFieldBounds.xLimit() + 1, inputFieldBounds.yLimit() + 2, 0xFF404040);
+
+            if (inputFieldFocused || focused) {
+                if (caretPos > text.length())
+                    caretPos = text.length();
+
+                int caretX = textX + textRenderer.width(text.substring(0, caretPos)) - 1;
+                if (text.isEmpty())
+                    caretX = inputFieldBounds.x() + inputFieldBounds.width() / 2;
+
+                if (ticks % 20 <= 10) {
+                    graphics.fill(caretX, inputFieldBounds.y(), caretX + 1, inputFieldBounds.yLimit(), -1);
+                }
+
+                if (selectionLength != 0) {
+                    int selectionX = textX + textRenderer.width(text.substring(0, caretPos + selectionLength));
+                    graphics.fill(caretX, inputFieldBounds.y() - 1, selectionX, inputFieldBounds.yLimit(), 0x803030FF);
+                }
+            }
+        }
+        graphics.disableScissor();
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if (isAvailable() && getDimension().isPointInside((int) mouseX, (int) mouseY)) {
+            inputFieldFocused = true;
+
+            if (!inputFieldBounds.isPointInside((int) mouseX, (int) mouseY)) {
+                caretPos = getDefaultCaretPos();
+            } else {
+                // gets the appropriate caret position for where you click
+                int textX = (int) mouseX - (inputFieldBounds.xLimit() - textRenderer.width(getValueText()));
+                int pos = -1;
+                int currentWidth = 0;
+                for (char ch : inputField.toCharArray()) {
+                    pos++;
+                    int charLength = textRenderer.width(String.valueOf(ch));
+                    if (currentWidth + charLength / 2 > textX) { // if more than halfway past the characters select in front of that char
+                        caretPos = pos;
+                        break;
+                    } else if (pos == inputField.length() - 1) {
+                        // if we have reached the end and no matches, it must be the second half of the char so the last position
+                        caretPos = pos + 1;
+                    }
+                    currentWidth += charLength;
+                }
+
+                selectionLength = 0;
+            }
+            return true;
+        } else {
+            inputFieldFocused = false;
+        }
+
+        return false;
+    }
+
+    protected int getDefaultCaretPos() {
+        return inputField.length();
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (!inputFieldFocused)
+            return false;
+
+        switch (keyCode) {
+            case InputConstants.KEY_ESCAPE, InputConstants.KEY_RETURN -> {
+                unfocus();
+                return true;
+            }
+            case InputConstants.KEY_LEFT -> {
+                if (Screen.hasShiftDown()) {
+                    if (Screen.hasControlDown()) {
+                        int spaceChar = findSpaceIndex(true);
+                        selectionLength += caretPos - spaceChar;
+                        caretPos = spaceChar;
+                    } else if (caretPos > 0) {
+                        caretPos--;
+                        selectionLength += 1;
+                    }
+                    checkRenderOffset();
+                } else {
+                    if (caretPos > 0) {
+                        if (selectionLength != 0)
+                            caretPos += Math.min(selectionLength, 0);
+                        else
+                            caretPos--;
+                    }
+                    checkRenderOffset();
+                    selectionLength = 0;
+                }
+
+                return true;
+            }
+            case InputConstants.KEY_RIGHT -> {
+                if (Screen.hasShiftDown()) {
+                    if (Screen.hasControlDown()) {
+                        int spaceChar = findSpaceIndex(false);
+                        selectionLength -= spaceChar - caretPos;
+                        caretPos = spaceChar;
+                    } else if (caretPos < inputField.length()) {
+                        caretPos++;
+                        selectionLength -= 1;
+                    }
+                    checkRenderOffset();
+                } else {
+                    if (caretPos < inputField.length()) {
+                        if (selectionLength != 0)
+                            caretPos += Math.max(selectionLength, 0);
+                        else
+                            caretPos++;
+                        checkRenderOffset();
+                    }
+                    selectionLength = 0;
+                }
+
+                return true;
+            }
+            case InputConstants.KEY_BACKSPACE -> {
+                doBackspace();
+                return true;
+            }
+            case InputConstants.KEY_DELETE -> {
+                doDelete();
+                return true;
+            }
+        }
+
+        if (Screen.isPaste(keyCode)) {
+            return doPaste();
+        } else if (Screen.isCopy(keyCode)) {
+            return  doCopy();
+        } else if (Screen.isCut(keyCode)) {
+            return doCut();
+        } else if (Screen.isSelectAll(keyCode)) {
+            return doSelectAll();
+        }
+
+        return false;
+    }
+
+    protected boolean doPaste() {
+        this.write(client.keyboardHandler.getClipboard());
+        return true;
+    }
+
+    protected boolean doCopy() {
+        if (selectionLength != 0) {
+            client.keyboardHandler.setClipboard(getSelection());
+            return true;
+        }
+        return false;
+    }
+
+    protected boolean doCut() {
+        if (selectionLength != 0) {
+            client.keyboardHandler.setClipboard(getSelection());
+            this.write("");
+            return true;
+        }
+        return false;
+    }
+
+    protected boolean doSelectAll() {
+        caretPos = inputField.length();
+        checkRenderOffset();
+        selectionLength = -caretPos;
+        return true;
+    }
+
+    protected void checkRenderOffset() {
+        if (textRenderer.width(inputField) < getUnshiftedLength()) {
+            renderOffset = 0;
+            return;
+        }
+
+        int textX = getDimension().xLimit() - textRenderer.width(inputField) - getXPadding();
+        int caretX = textX + textRenderer.width(inputField.substring(0, caretPos)) - 1;
+
+        int minX = getDimension().xLimit() - getXPadding() - getUnshiftedLength();
+        int maxX = minX + getUnshiftedLength();
+
+        if (caretX + renderOffset < minX) {
+            renderOffset = minX - caretX;
+        } else if (caretX + renderOffset > maxX) {
+            renderOffset = maxX - caretX;
+        }
+    }
+
+    @Override
+    public boolean charTyped(char chr, int modifiers) {
+        if (!inputFieldFocused)
+            return false;
+
+        write(Character.toString(chr));
+
+        return true;
+    }
+
+    protected void doBackspace() {
+        if (selectionLength != 0) {
+            write("");
+        } else if (caretPos > 0) {
+            if (modifyInput(builder -> builder.deleteCharAt(caretPos - 1))) {
+                caretPos--;
+                checkRenderOffset();
+            }
+        }
+    }
+
+    protected void doDelete() {
+        if (selectionLength != 0) {
+            write("");
+        } else if (caretPos < inputField.length()) {
+            modifyInput(builder -> builder.deleteCharAt(caretPos));
+        }
+    }
+
+    public void write(String string) {
+        if (selectionLength == 0) {
+            if (modifyInput(builder -> builder.insert(caretPos, string))) {
+                caretPos += string.length();
+                checkRenderOffset();
+            }
+        } else {
+            int start = getSelectionStart();
+            int end = getSelectionEnd();
+
+            if (modifyInput(builder -> builder.replace(start, end, string))) {
+                caretPos = start + string.length();
+                selectionLength = 0;
+                checkRenderOffset();
+            }
+        }
+    }
+
+    public boolean modifyInput(Consumer<StringBuilder> consumer) {
+        StringBuilder temp = new StringBuilder(inputField);
+        consumer.accept(temp);
+        if (!control.isInputValid(temp.toString()))
+            return false;
+        inputField = temp.toString();
+        if (instantApply)
+            updateControl();
+        return true;
+    }
+
+    public int getUnshiftedLength() {
+        if (optionNameString.isEmpty())
+            return getDimension().width() - getXPadding() * 2;
+        return getDimension().width() / 8 * 5;
+    }
+
+    public int getMaxUnwrapLength() {
+        if (optionNameString.isEmpty())
+            return getDimension().width() - getXPadding() * 2;
+        return getDimension().width() / 2;
+    }
+
+    public int getSelectionStart() {
+        return Math.min(caretPos, caretPos + selectionLength);
+    }
+
+    public int getSelectionEnd() {
+        return Math.max(caretPos, caretPos + selectionLength);
+    }
+
+    protected String getSelection() {
+        return inputField.substring(getSelectionStart(), getSelectionEnd());
+    }
+
+    protected int findSpaceIndex(boolean reverse) {
+        int i;
+        int fromIndex = caretPos;
+        if (reverse) {
+            if (caretPos > 0)
+                fromIndex -= 1;
+            i = this.inputField.lastIndexOf(" ", fromIndex);
+
+            if (i == -1) i = 0;
+        } else {
+            if (caretPos < inputField.length())
+                fromIndex += 1;
+            i = this.inputField.indexOf(" ", fromIndex);
+
+            if (i == -1) i = inputField.length();
+        }
+
+        return i;
+    }
+
+    @Override
+    public void setFocused(boolean focused) {
+        super.setFocused(focused);
+        inputFieldFocused = focused;
+    }
+
+    @Override
+    public void unfocus() {
+        super.unfocus();
+        inputFieldFocused = false;
+        renderOffset = 0;
+        if (!instantApply) updateControl();
+    }
+
+    @Override
+    public void setDimension(Dimension<Integer> dim) {
+        super.setDimension(dim);
+
+        int width = Math.max(6, Math.min(textRenderer.width(getValueText()), getUnshiftedLength()));
+        inputFieldBounds = Dimension.ofInt(dim.xLimit() - getXPadding() - width, dim.centerY() - textRenderer.lineHeight / 2, width, textRenderer.lineHeight);
+    }
+
+    @Override
+    public boolean isHovered() {
+        return super.isHovered() || inputFieldFocused;
+    }
+
+    protected void updateControl() {
+        control.setFromString(inputField);
+    }
+
+    @Override
+    protected int getUnhoveredControlWidth() {
+        return !isHovered() ? Math.min(getHoveredControlWidth(), getMaxUnwrapLength()) : getHoveredControlWidth();
+    }
+
+    @Override
+    protected int getHoveredControlWidth() {
+        return Math.min(textRenderer.width(getValueText()), getUnshiftedLength());
+    }
+
+    @Override
+    protected Component getValueText() {
+        if (!inputFieldFocused && inputField.isEmpty())
+            return emptyText;
+
+        return instantApply || !inputFieldFocused ? control.formatValue() : Component.literal(inputField);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/DoubleFieldController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/DoubleFieldController.java
new file mode 100644
index 0000000..3f70a12
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/DoubleFieldController.java
@@ -0,0 +1,104 @@
+package dev.isxander.yacl3.gui.controllers.string.number;
+
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.gui.controllers.slider.DoubleSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+/**
+ * {@inheritDoc}
+ */
+public class DoubleFieldController extends NumberFieldController<Double> {
+    private final double min, max;
+
+    /**
+     * Constructs a double field controller
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     * @param formatter display text, not used whilst editing
+     */
+    public DoubleFieldController(Option<Double> option, double min, double max, Function<Double, Component> formatter) {
+        super(option, formatter);
+        this.min = min;
+        this.max = max;
+    }
+
+    /**
+     * Constructs a double field controller.
+     * Uses {@link DoubleSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     */
+    public DoubleFieldController(Option<Double> option, double min, double max) {
+        this(option, min, max, DoubleSliderController.DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a double field controller.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     * @param formatter display text, not used whilst editing
+     */
+    public DoubleFieldController(Option<Double> option, Function<Double, Component> formatter) {
+        this(option, -Double.MAX_VALUE, Double.MAX_VALUE, formatter);
+    }
+
+    /**
+     * Constructs a double field controller.
+     * Uses {@link DoubleSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     */
+    public DoubleFieldController(Option<Double> option) {
+        this(option, -Double.MAX_VALUE, Double.MAX_VALUE, DoubleSliderController.DEFAULT_FORMATTER);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return this.min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return this.max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getString() {
+        return String.valueOf(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet(value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/FloatFieldController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/FloatFieldController.java
new file mode 100644
index 0000000..57737f7
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/FloatFieldController.java
@@ -0,0 +1,104 @@
+package dev.isxander.yacl3.gui.controllers.string.number;
+
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.gui.controllers.slider.FloatSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+/**
+ * {@inheritDoc}
+ */
+public class FloatFieldController extends NumberFieldController<Float> {
+    private final float min, max;
+
+    /**
+     * Constructs a float field controller
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     * @param formatter display text, not used whilst editing
+     */
+    public FloatFieldController(Option<Float> option, float min, float max, Function<Float, Component> formatter) {
+        super(option, formatter);
+        this.min = min;
+        this.max = max;
+    }
+
+    /**
+     * Constructs a float field controller.
+     * Uses {@link FloatSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     */
+    public FloatFieldController(Option<Float> option, float min, float max) {
+        this(option, min, max, FloatSliderController.DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a float field controller.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     * @param formatter display text, not used whilst editing
+     */
+    public FloatFieldController(Option<Float> option, Function<Float, Component> formatter) {
+        this(option, -Float.MAX_VALUE, Float.MAX_VALUE, formatter);
+    }
+
+    /**
+     * Constructs a float field controller.
+     * Uses {@link FloatSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     */
+    public FloatFieldController(Option<Float> option) {
+        this(option, -Float.MAX_VALUE, Float.MAX_VALUE, FloatSliderController.DEFAULT_FORMATTER);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return this.min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return this.max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getString() {
+        return String.valueOf(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((float) value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/IntegerFieldController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/IntegerFieldController.java
new file mode 100644
index 0000000..5c15a2e
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/IntegerFieldController.java
@@ -0,0 +1,109 @@
+package dev.isxander.yacl3.gui.controllers.string.number;
+
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.gui.controllers.slider.IntegerSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+/**
+ * {@inheritDoc}
+ */
+public class IntegerFieldController extends NumberFieldController<Integer> {
+    private final int min, max;
+
+    /**
+     * Constructs a integer field controller
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     * @param formatter display text, not used whilst editing
+     */
+    public IntegerFieldController(Option<Integer> option, int min, int max, Function<Integer, Component> formatter) {
+        super(option, formatter);
+        this.min = min;
+        this.max = max;
+    }
+
+    /**
+     * Constructs a integer field controller.
+     * Uses {@link IntegerSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     */
+    public IntegerFieldController(Option<Integer> option, int min, int max) {
+        this(option, min, max, IntegerSliderController.DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a integer field controller.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     * @param formatter display text, not used whilst editing
+     */
+    public IntegerFieldController(Option<Integer> option, Function<Integer, Component> formatter) {
+        this(option, -Integer.MAX_VALUE, Integer.MAX_VALUE, formatter);
+    }
+
+    /**
+     * Constructs a integer field controller.
+     * Uses {@link IntegerSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     */
+    public IntegerFieldController(Option<Integer> option) {
+        this(option, -Integer.MAX_VALUE, Integer.MAX_VALUE, IntegerSliderController.DEFAULT_FORMATTER);
+    }
+
+    @Override
+    public boolean isInputValid(String input) {
+        return input.matches("\\d+|-|");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return this.min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return this.max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getString() {
+        return String.valueOf(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((int) value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/LongFieldController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/LongFieldController.java
new file mode 100644
index 0000000..b36b0f3
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/LongFieldController.java
@@ -0,0 +1,109 @@
+package dev.isxander.yacl3.gui.controllers.string.number;
+
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.gui.controllers.slider.LongSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+/**
+ * {@inheritDoc}
+ */
+public class LongFieldController extends NumberFieldController<Long> {
+    private final long min, max;
+
+    /**
+     * Constructs a long field controller
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     * @param formatter display text, not used whilst editing
+     */
+    public LongFieldController(Option<Long> option, long min, long max, Function<Long, Component> formatter) {
+        super(option, formatter);
+        this.min = min;
+        this.max = max;
+    }
+
+    /**
+     * Constructs a long field controller.
+     * Uses {@link LongSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     *
+     * @param option option to bind controller to
+     * @param min minimum allowed value (clamped on apply)
+     * @param max maximum allowed value (clamped on apply)
+     */
+    public LongFieldController(Option<Long> option, long min, long max) {
+        this(option, min, max, LongSliderController.DEFAULT_FORMATTER);
+    }
+
+    /**
+     * Constructs a long field controller.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     * @param formatter display text, not used whilst editing
+     */
+    public LongFieldController(Option<Long> option, Function<Long, Component> formatter) {
+        this(option, -Long.MAX_VALUE, Long.MAX_VALUE, formatter);
+    }
+
+    /**
+     * Constructs a long field controller.
+     * Uses {@link LongSliderController#DEFAULT_FORMATTER} as display text,
+     * not used whilst editing.
+     * Does not have a minimum or a maximum range.
+     *
+     * @param option option to bind controller to
+     */
+    public LongFieldController(Option<Long> option) {
+        this(option, -Long.MAX_VALUE, Long.MAX_VALUE, LongSliderController.DEFAULT_FORMATTER);
+    }
+
+    @Override
+    public boolean isInputValid(String input) {
+        return input.matches("\\d+|-|");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double min() {
+        return this.min;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double max() {
+        return this.max;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getString() {
+        return String.valueOf(option().pendingValue());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((long) value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/NumberFieldController.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/NumberFieldController.java
new file mode 100644
index 0000000..f484aad
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/NumberFieldController.java
@@ -0,0 +1,69 @@
+package dev.isxander.yacl3.gui.controllers.string.number;
+
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.gui.AbstractWidget;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.controllers.slider.ISliderController;
+import dev.isxander.yacl3.gui.controllers.string.IStringController;
+import dev.isxander.yacl3.gui.controllers.string.StringControllerElement;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+
+import java.text.DecimalFormatSymbols;
+import java.util.function.Function;
+
+/**
+ * Controller that allows you to enter in numbers using a text field.
+ *
+ * @param <T> number type
+ */
+public abstract class NumberFieldController<T extends Number> implements ISliderController<T>, IStringController<T> {
+    private final Option<T> option;
+    private final Function<T, Component> displayFormatter;
+
+    public NumberFieldController(Option<T> option, Function<T, Component> displayFormatter) {
+        this.option = option;
+        this.displayFormatter = displayFormatter;
+    }
+
+    @Override
+    public Option<T> option() {
+        return this.option;
+    }
+
+    @Override
+    public void setFromString(String value) {
+        if (value.isEmpty() || value.equals(".") || value.equals("-")) value = "0";
+        setPendingValue(Mth.clamp(Double.parseDouble(cleanupNumberString(value)), min(), max()));
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue().doubleValue();
+    }
+
+    @Override
+    public boolean isInputValid(String input) {
+        return input.matches("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)|[.]||-");
+    }
+
+    @Override
+    public Component formatValue() {
+        return displayFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+        return new StringControllerElement(this, screen, widgetDimension, false);
+    }
+
+    protected String cleanupNumberString(String number) {
+        return number.replace(String.valueOf(DecimalFormatSymbols.getInstance().getGroupingSeparator()), "");
+    }
+
+    @Override
+    public double interval() {
+        return -1;
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/package-info.java b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/package-info.java
new file mode 100644
index 0000000..4d8bbc2
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/controllers/string/number/package-info.java
@@ -0,0 +1,10 @@
+/**
+ * This package contains implementations of input fields for different number types
+ * <ul>
+ *     <li>For doubles: {@link dev.isxander.yacl3.gui.controllers.string.number.DoubleFieldController}</li>
+ *     <li>For floats: {@link dev.isxander.yacl3.gui.controllers.string.number.FloatFieldController}</li>
+ *     <li>For integers: {@link dev.isxander.yacl3.gui.controllers.string.number.IntegerFieldController}</li>
+ *     <li>For longs: {@link dev.isxander.yacl3.gui.controllers.string.number.LongFieldController}</li>
+ * </ul>
+ */
+package dev.isxander.yacl3.gui.controllers.string.number;
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/tab/ListHolderWidget.java b/common/src/main/java/dev/isxander/yacl3/gui/tab/ListHolderWidget.java
new file mode 100644
index 0000000..5059874
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/tab/ListHolderWidget.java
@@ -0,0 +1,116 @@
+package dev.isxander.yacl3.gui.tab;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.gui.ElementListWidgetExt;
+import net.minecraft.client.gui.ComponentPath;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.events.ContainerEventHandler;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.client.gui.navigation.FocusNavigationEvent;
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraft.network.chat.CommonComponents;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+public class ListHolderWidget<T extends ElementListWidgetExt<?>> extends AbstractWidget implements ContainerEventHandler {
+    private final Supplier<ScreenRectangle> dimensions;
+    private final T list;
+
+    public ListHolderWidget(Supplier<ScreenRectangle> dimensions, T list) {
+        super(0, 0, 100, 0, CommonComponents.EMPTY);
+        this.dimensions = dimensions;
+        this.list = list;
+    }
+
+    @Override
+    public void renderWidget(GuiGraphics guiGraphics, int mouseX, int mouseY, float deltaTick) {
+        ScreenRectangle dimensions = this.dimensions.get();
+        this.setX(dimensions.left());
+        this.setY(dimensions.top());
+        this.width = dimensions.width();
+        this.height = dimensions.height();
+        this.list.updateDimensions(dimensions);
+        this.list.render(guiGraphics, mouseX, mouseY, deltaTick);
+    }
+
+    @Override
+    protected void updateWidgetNarration(NarrationElementOutput output) {
+        this.list.updateNarration(output);
+    }
+
+    @Override
+    public List<? extends GuiEventListener> children() {
+        return ImmutableList.of(this.list);
+    }
+
+    public T getList() {
+        return list;
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        return this.list.mouseClicked(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int button, double deltaX, double deltaY) {
+        return this.list.mouseDragged(mouseX, mouseY, button, deltaX, deltaY);
+    }
+
+    @Override
+    public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        return this.list.mouseReleased(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        return this.list.mouseScrolled(mouseX, mouseY, amount);
+    }
+
+    @Override
+    public boolean keyPressed(int i, int j, int k) {
+        return this.list.keyPressed(i, j, k);
+    }
+
+    @Override
+    public boolean charTyped(char c, int i) {
+        return this.list.charTyped(c, i);
+    }
+
+    @Override
+    public boolean isDragging() {
+        return this.list.isDragging();
+    }
+
+    @Override
+    public void setDragging(boolean dragging) {
+        this.list.setDragging(dragging);
+    }
+
+    @Nullable
+    @Override
+    public GuiEventListener getFocused() {
+        return this.list.getFocused();
+    }
+
+    @Override
+    public void setFocused(@Nullable GuiEventListener listener) {
+        this.list.setFocused(listener);
+    }
+
+    @Nullable
+    @Override
+    public ComponentPath nextFocusPath(FocusNavigationEvent event) {
+        return this.list.nextFocusPath(event);
+    }
+
+    @Nullable
+    @Override
+    public ComponentPath getCurrentFocusPath() {
+        return this.list.getCurrentFocusPath();
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/tab/ScrollableNavigationBar.java b/common/src/main/java/dev/isxander/yacl3/gui/tab/ScrollableNavigationBar.java
new file mode 100644
index 0000000..199845d
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/tab/ScrollableNavigationBar.java
@@ -0,0 +1,110 @@
+package dev.isxander.yacl3.gui.tab;
+
+import com.google.common.collect.ImmutableList;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.TabButton;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.components.tabs.Tab;
+import net.minecraft.client.gui.components.tabs.TabManager;
+import net.minecraft.client.gui.components.tabs.TabNavigationBar;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.Nullable;
+
+public class ScrollableNavigationBar extends TabNavigationBar {
+    private static final int NAVBAR_MARGIN = 28;
+
+    private static final Font font = Minecraft.getInstance().font;
+
+    private int scrollOffset;
+    private int maxScrollOffset;
+
+    public ScrollableNavigationBar(int width, TabManager tabManager, Iterable<? extends Tab> tabs) {
+        super(width, tabManager, ImmutableList.copyOf(tabs));
+
+        // add tab tooltips to the tab buttons
+        for (TabButton tabButton : this.tabButtons) {
+            if (tabButton.tab() instanceof TabExt tab) {
+                tabButton.setTooltip(tab.getTooltip());
+            }
+        }
+    }
+
+    @Override
+    public void arrangeElements() {
+        int noScrollWidth = this.width - NAVBAR_MARGIN*2;
+
+        // first pass: set the width of each tab button
+        for (TabButton tabButton : this.tabButtons) {
+            tabButton.setWidth(font.width(tabButton.getMessage()) + 10);
+        }
+
+        // second pass: redistribute remaining width evenly
+        for (TabButton tabButton : tabButtons) {
+            int totalWidth = tabButtons.stream().mapToInt(AbstractWidget::getWidth).sum();
+            int remainingWidth = noScrollWidth - totalWidth;
+            if (remainingWidth > 0) {
+                int extra = remainingWidth / tabButtons.size();
+                tabButton.setWidth(tabButton.getWidth() + extra);
+            }
+        }
+
+        this.layout.arrangeElements();
+        this.layout.setY(0);
+        this.scrollOffset = 0;
+
+        int allTabsWidth = this.tabButtons.stream().mapToInt(AbstractWidget::getWidth).sum();
+        this.layout.setX(Math.max((this.width - allTabsWidth) / 2, NAVBAR_MARGIN));
+        this.maxScrollOffset = Math.max(0, allTabsWidth - noScrollWidth);
+    }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        graphics.pose().pushPose();
+        // render option list BELOW the navbar without need to scissor
+        graphics.pose().translate(0, 0, 10);
+
+        super.render(graphics, mouseX, mouseY, delta);
+
+        graphics.pose().popPose();
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        this.setScrollOffset(this.scrollOffset - (int)(amount*10));
+        return true;
+    }
+
+    @Override
+    public boolean isMouseOver(double mouseX, double mouseY) {
+        return mouseY <= 24;
+    }
+
+    public void setScrollOffset(int scrollOffset) {
+        layout.setX(layout.getX() + this.scrollOffset);
+        this.scrollOffset = Mth.clamp(scrollOffset, 0, maxScrollOffset);
+        layout.setX(layout.getX() - this.scrollOffset);
+    }
+
+    public int getScrollOffset() {
+        return scrollOffset;
+    }
+
+    @Override
+    public void setFocused(@Nullable GuiEventListener child) {
+        super.setFocused(child);
+        if (child instanceof TabButton tabButton) {
+            this.ensureVisible(tabButton);
+        }
+    }
+
+    protected void ensureVisible(TabButton tabButton) {
+        if (tabButton.getX() < NAVBAR_MARGIN) {
+            this.setScrollOffset(this.scrollOffset - (NAVBAR_MARGIN - tabButton.getX()));
+        } else if (tabButton.getX() + tabButton.getWidth() > this.width - NAVBAR_MARGIN) {
+            this.setScrollOffset(this.scrollOffset + (tabButton.getX() + tabButton.getWidth() - (this.width - NAVBAR_MARGIN)));
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/tab/TabExt.java b/common/src/main/java/dev/isxander/yacl3/gui/tab/TabExt.java
new file mode 100644
index 0000000..3b29594
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/tab/TabExt.java
@@ -0,0 +1,9 @@
+package dev.isxander.yacl3.gui.tab;
+
+import net.minecraft.client.gui.components.Tooltip;
+import net.minecraft.client.gui.components.tabs.Tab;
+import org.jetbrains.annotations.Nullable;
+
+public interface TabExt extends Tab {
+    @Nullable Tooltip getTooltip();
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/gui/utils/GuiUtils.java b/common/src/main/java/dev/isxander/yacl3/gui/utils/GuiUtils.java
new file mode 100644
index 0000000..2910d0f
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/gui/utils/GuiUtils.java
@@ -0,0 +1,32 @@
+package dev.isxander.yacl3.gui.utils;
+
+import net.minecraft.client.gui.Font;
+import net.minecraft.locale.Language;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+
+public class GuiUtils {
+    public static MutableComponent translatableFallback(String key, Component fallback) {
+        if (Language.getInstance().has(key))
+            return Component.translatable(key);
+        return fallback.copy();
+    }
+
+    public static String shortenString(String string, Font font, int maxWidth, String suffix) {
+        if (string.isEmpty())
+            return string;
+
+        boolean firstIter = true;
+        while (font.width(string) > maxWidth) {
+            string = string.substring(0, Math.max(string.length() - 1 - (firstIter ? 1 : suffix.length() + 1), 0)).trim();
+            string += suffix;
+
+            if (string.equals(suffix))
+                break;
+
+            firstIter = false;
+        }
+
+        return string;
+    }
+}