Change package and modid to yacl3 and yet_another_config_lib_3 respectively

28 files changed, 2454 insertions, 0 deletions

diff --git a/common/src/main/java/dev/isxander/yacl3/impl/ButtonOptionImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/ButtonOptionImpl.java
new file mode 100644
index 0000000..99a6e83
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/ButtonOptionImpl.java
@@ -0,0 +1,195 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableSet;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.gui.controllers.ActionController;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+@ApiStatus.Internal
+public final class ButtonOptionImpl implements ButtonOption {
+    private final Component name;
+    private final OptionDescription description;
+    private final BiConsumer<YACLScreen, ButtonOption> action;
+    private boolean available;
+    private final Controller<BiConsumer<YACLScreen, ButtonOption>> controller;
+    private final Binding<BiConsumer<YACLScreen, ButtonOption>> binding;
+
+    public ButtonOptionImpl(
+            @NotNull Component name,
+            @Nullable OptionDescription description,
+            @NotNull BiConsumer<YACLScreen, ButtonOption> action,
+            boolean available
+    ) {
+        this.name = name;
+        this.description = description;
+        this.action = action;
+        this.available = available;
+        this.controller = new ActionController(this);
+        this.binding = new EmptyBinderImpl();
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return name;
+    }
+
+    @Override
+    public @NotNull OptionDescription description() {
+        return description;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return description().text();
+    }
+
+    @Override
+    public BiConsumer<YACLScreen, ButtonOption> action() {
+        return action;
+    }
+
+    @Override
+    public boolean available() {
+        return available;
+    }
+
+    @Override
+    public void setAvailable(boolean available) {
+        this.available = available;
+    }
+
+    @Override
+    public @NotNull Controller<BiConsumer<YACLScreen, ButtonOption>> controller() {
+        return controller;
+    }
+
+    @Override
+    public @NotNull Binding<BiConsumer<YACLScreen, ButtonOption>> binding() {
+        return binding;
+    }
+
+    @Override
+    public @NotNull ImmutableSet<OptionFlag> flags() {
+        return ImmutableSet.of();
+    }
+
+    @Override
+    public boolean changed() {
+        return false;
+    }
+
+    @Override
+    public @NotNull BiConsumer<YACLScreen, ButtonOption> pendingValue() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void requestSet(BiConsumer<YACLScreen, ButtonOption> value) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean applyValue() {
+        return false;
+    }
+
+    @Override
+    public void forgetPendingValue() {
+
+    }
+
+    @Override
+    public void requestSetDefault() {
+
+    }
+
+    @Override
+    public boolean isPendingValueDefault() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void addListener(BiConsumer<Option<BiConsumer<YACLScreen, ButtonOption>>, BiConsumer<YACLScreen, ButtonOption>> changedListener) {
+
+    }
+
+    private static class EmptyBinderImpl implements Binding<BiConsumer<YACLScreen, ButtonOption>> {
+        @Override
+        public void setValue(BiConsumer<YACLScreen, ButtonOption> value) {
+
+        }
+
+        @Override
+        public BiConsumer<YACLScreen, ButtonOption> getValue() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public BiConsumer<YACLScreen, ButtonOption> defaultValue() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl implements Builder {
+        private Component name;
+        private OptionDescription description = OptionDescription.EMPTY;
+        private boolean available = true;
+        private BiConsumer<YACLScreen, ButtonOption> action;
+
+        @Override
+        public Builder name(@NotNull Component name) {
+            Validate.notNull(name, "`name` cannot be null");
+
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder description(@NotNull OptionDescription description) {
+            Validate.notNull(description, "`description` cannot be null");
+
+            this.description = description;
+            return this;
+        }
+
+        @Override
+        public Builder action(@NotNull BiConsumer<YACLScreen, ButtonOption> action) {
+            Validate.notNull(action, "`action` cannot be null");
+
+            this.action = action;
+            return this;
+        }
+
+        @Override
+        @Deprecated
+        public Builder action(@NotNull Consumer<YACLScreen> action) {
+            Validate.notNull(action, "`action` cannot be null");
+
+            this.action = (screen, button) -> action.accept(screen);
+            return this;
+        }
+
+        @Override
+        public Builder available(boolean available) {
+            this.available = available;
+            return this;
+        }
+
+        @Override
+        public ButtonOption build() {
+            Validate.notNull(name, "`name` must not be null when building `ButtonOption`");
+            Validate.notNull(action, "`action` must not be null when building `ButtonOption`");
+
+            return new ButtonOptionImpl(name, description, action, available);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/ConfigCategoryImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/ConfigCategoryImpl.java
new file mode 100644
index 0000000..195f6d7
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/ConfigCategoryImpl.java
@@ -0,0 +1,135 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.impl.utils.YACLConstants;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.ComponentContents;
+import net.minecraft.network.chat.MutableComponent;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+@ApiStatus.Internal
+public final class ConfigCategoryImpl implements ConfigCategory {
+    private final Component name;
+    private final ImmutableList<OptionGroup> groups;
+    private final Component tooltip;
+
+    public ConfigCategoryImpl(Component name, ImmutableList<OptionGroup> groups, Component tooltip) {
+        this.name = name;
+        this.groups = groups;
+        this.tooltip = tooltip;
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return name;
+    }
+
+    @Override
+    public @NotNull ImmutableList<OptionGroup> groups() {
+        return groups;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return tooltip;
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl implements Builder {
+        private Component name;
+
+        private final List<Option<?>> rootOptions = new ArrayList<>();
+        private final List<OptionGroup> groups = new ArrayList<>();
+
+        private final List<Component> tooltipLines = new ArrayList<>();
+
+        @Override
+        public Builder name(@NotNull Component name) {
+            Validate.notNull(name, "`name` cannot be null");
+
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder option(@NotNull Option<?> option) {
+            Validate.notNull(option, "`option` must not be null");
+
+            if (option instanceof ListOption<?> listOption) {
+                YACLConstants.LOGGER.warn("Adding list option as an option is not supported! Rerouting to group!");
+                return group(listOption);
+            }
+
+            this.rootOptions.add(option);
+            return this;
+        }
+
+        @Override
+        public Builder options(@NotNull Collection<? extends Option<?>> options) {
+            Validate.notNull(options, "`options` must not be null");
+
+            if (options.stream().anyMatch(ListOption.class::isInstance))
+                throw new UnsupportedOperationException("List options must not be added as an option but a group!");
+
+            this.rootOptions.addAll(options);
+            return this;
+        }
+
+        @Override
+        public Builder group(@NotNull OptionGroup group) {
+            Validate.notNull(group, "`group` must not be null");
+
+            this.groups.add(group);
+            return this;
+        }
+
+        @Override
+        public Builder groups(@NotNull Collection<OptionGroup> groups) {
+            Validate.notEmpty(groups, "`groups` must not be empty");
+
+            this.groups.addAll(groups);
+            return this;
+        }
+
+        @Override
+        public Builder tooltip(@NotNull Component... tooltips) {
+            Validate.notEmpty(tooltips, "`tooltips` cannot be empty");
+
+            tooltipLines.addAll(List.of(tooltips));
+            return this;
+        }
+
+        @Override
+        public ConfigCategory build() {
+            Validate.notNull(name, "`name` must not be null to build `ConfigCategory`");
+
+            List<OptionGroup> combinedGroups = new ArrayList<>();
+            combinedGroups.add(new OptionGroupImpl(CommonComponents.EMPTY, OptionDescription.EMPTY, ImmutableList.copyOf(rootOptions), false, true));
+            combinedGroups.addAll(groups);
+
+            Validate.notEmpty(combinedGroups, "at least one option must be added to build `ConfigCategory`");
+
+            MutableComponent concatenatedTooltip = Component.empty();
+            boolean first = true;
+            for (Component line : tooltipLines) {
+                if (line.getContents() == ComponentContents.EMPTY)
+                    continue;
+
+                if (!first) concatenatedTooltip.append("\n");
+                first = false;
+
+                concatenatedTooltip.append(line);
+            }
+
+            return new ConfigCategoryImpl(name, ImmutableList.copyOf(combinedGroups), concatenatedTooltip);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/GenericBindingImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/GenericBindingImpl.java
new file mode 100644
index 0000000..972c891
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/GenericBindingImpl.java
@@ -0,0 +1,35 @@
+package dev.isxander.yacl3.impl;
+
+import dev.isxander.yacl3.api.Binding;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public final class GenericBindingImpl<T> implements Binding<T> {
+    private final T def;
+    private final Supplier<T> getter;
+    private final Consumer<T> setter;
+
+    public GenericBindingImpl(T def, Supplier<T> getter, Consumer<T> setting) {
+        this.def = def;
+        this.getter = getter;
+        this.setter = setting;
+    }
+
+
+    @Override
+    public void setValue(T value) {
+        setter.accept(value);
+    }
+
+    @Override
+    public T getValue() {
+        return getter.get();
+    }
+
+    @Override
+    public T defaultValue() {
+        return def;
+    }
+
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/LabelOptionImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/LabelOptionImpl.java
new file mode 100644
index 0000000..c8287bd
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/LabelOptionImpl.java
@@ -0,0 +1,158 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableSet;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.gui.controllers.LabelController;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.BiConsumer;
+
+@ApiStatus.Internal
+public final class LabelOptionImpl implements LabelOption {
+    private final Component label;
+    private final Component name = Component.literal("Label Option");
+    private final OptionDescription description;
+    private final Component tooltip = Component.empty();
+    private final LabelController labelController;
+    private final Binding<Component> binding;
+
+    public LabelOptionImpl(Component label) {
+        this.label = label;
+        this.labelController = new LabelController(this);
+        this.binding = Binding.immutable(label);
+        this.description = OptionDescription.createBuilder()
+                .text(this.label)
+                .build();
+    }
+
+    @Override
+    public @NotNull Component label() {
+        return label;
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return name;
+    }
+
+    @Override
+    public @NotNull OptionDescription description() {
+        return description;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return tooltip;
+    }
+
+    @Override
+    public @NotNull Controller<Component> controller() {
+        return labelController;
+    }
+
+    @Override
+    public @NotNull Binding<Component> binding() {
+        return binding;
+    }
+
+    @Override
+    public boolean available() {
+        return true;
+    }
+
+    @Override
+    public void setAvailable(boolean available) {
+        throw new UnsupportedOperationException("Label options cannot be disabled.");
+    }
+
+    @Override
+    public @NotNull ImmutableSet<OptionFlag> flags() {
+        return ImmutableSet.of();
+    }
+
+    @Override
+    public boolean changed() {
+        return false;
+    }
+
+    @Override
+    public @NotNull Component pendingValue() {
+        return label;
+    }
+
+    @Override
+    public void requestSet(Component value) {
+
+    }
+
+    @Override
+    public boolean applyValue() {
+        return false;
+    }
+
+    @Override
+    public void forgetPendingValue() {
+
+    }
+
+    @Override
+    public void requestSetDefault() {
+
+    }
+
+    @Override
+    public boolean isPendingValueDefault() {
+        return true;
+    }
+
+    @Override
+    public boolean canResetToDefault() {
+        return false;
+    }
+
+    @Override
+    public void addListener(BiConsumer<Option<Component>, Component> changedListener) {
+
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl implements Builder {
+        private final List<Component> lines = new ArrayList<>();
+
+        @Override
+        public Builder line(@NotNull Component line) {
+            Validate.notNull(line, "`line` must not be null");
+
+            this.lines.add(line);
+            return this;
+        }
+
+        @Override
+        public Builder lines(@NotNull Collection<? extends Component> lines) {
+            this.lines.addAll(lines);
+            return this;
+        }
+
+        @Override
+        public LabelOption build() {
+            MutableComponent text = Component.empty();
+            Iterator<Component> iterator = lines.iterator();
+            while (iterator.hasNext()) {
+                text.append(iterator.next());
+
+                if (iterator.hasNext())
+                    text.append("\n");
+            }
+
+            return new LabelOptionImpl(text);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/ListOptionEntryImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/ListOptionEntryImpl.java
new file mode 100644
index 0000000..0c74976
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/ListOptionEntryImpl.java
@@ -0,0 +1,154 @@
+package dev.isxander.yacl3.impl;
+
+import dev.isxander.yacl3.api.*;
+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.ListEntryWidget;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+@ApiStatus.Internal
+public final class ListOptionEntryImpl<T> implements ListOptionEntry<T> {
+    private final ListOptionImpl<T> group;
+
+    private T value;
+
+    private final Binding<T> binding;
+    private final Controller<T> controller;
+
+    ListOptionEntryImpl(ListOptionImpl<T> group, T initialValue, @NotNull Function<ListOptionEntry<T>, Controller<T>> controlGetter) {
+        this.group = group;
+        this.value = initialValue;
+        this.binding = new EntryBinding();
+        this.controller = new EntryController<>(controlGetter.apply(this), this);
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return Component.empty();
+    }
+
+    @Override
+    public @NotNull OptionDescription description() {
+        return group.description();
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return Component.empty();
+    }
+
+    @Override
+    public @NotNull Controller<T> controller() {
+        return controller;
+    }
+
+    @Override
+    public @NotNull Binding<T> binding() {
+        return binding;
+    }
+
+    @Override
+    public boolean available() {
+        return parentGroup().available();
+    }
+
+    @Override
+    public void setAvailable(boolean available) {
+
+    }
+
+    @Override
+    public ListOption<T> parentGroup() {
+        return group;
+    }
+
+    @Override
+    public boolean changed() {
+        return false;
+    }
+
+    @Override
+    public @NotNull T pendingValue() {
+        return value;
+    }
+
+    @Override
+    public void requestSet(T value) {
+        binding.setValue(value);
+    }
+
+    @Override
+    public boolean applyValue() {
+        return false;
+    }
+
+    @Override
+    public void forgetPendingValue() {
+
+    }
+
+    @Override
+    public void requestSetDefault() {
+
+    }
+
+    @Override
+    public boolean isPendingValueDefault() {
+        return false;
+    }
+
+    @Override
+    public boolean canResetToDefault() {
+        return false;
+    }
+
+    @Override
+    public void addListener(BiConsumer<Option<T>, T> changedListener) {
+
+    }
+
+    /**
+     * Open in case mods need to find the real controller type.
+     */
+    @ApiStatus.Internal
+    public record EntryController<T>(Controller<T> controller, ListOptionEntryImpl<T> entry) implements Controller<T> {
+        @Override
+        public Option<T> option() {
+            return controller.option();
+        }
+
+        @Override
+        public Component formatValue() {
+            return controller.formatValue();
+        }
+
+        @Override
+        public AbstractWidget provideWidget(YACLScreen screen, Dimension<Integer> widgetDimension) {
+            return new ListEntryWidget(screen, entry, controller.provideWidget(screen, widgetDimension));
+        }
+    }
+
+    private class EntryBinding implements Binding<T> {
+        @Override
+        public void setValue(T newValue) {
+            value = newValue;
+            group.callListeners();
+        }
+
+        @Override
+        public T getValue() {
+            return value;
+        }
+
+        @Override
+        public T defaultValue() {
+            throw new UnsupportedOperationException();
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/ListOptionImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/ListOptionImpl.java
new file mode 100644
index 0000000..82f5576
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/ListOptionImpl.java
@@ -0,0 +1,325 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.api.controller.ControllerBuilder;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+@ApiStatus.Internal
+public final class ListOptionImpl<T> implements ListOption<T> {
+    private final Component name;
+    private final OptionDescription description;
+    private final Binding<List<T>> binding;
+    private final T initialValue;
+    private final List<ListOptionEntry<T>> entries;
+    private final boolean collapsed;
+    private boolean available;
+    private final ImmutableSet<OptionFlag> flags;
+    private final EntryFactory entryFactory;
+    private final List<BiConsumer<Option<List<T>>, List<T>>> listeners;
+    private final List<Runnable> refreshListeners;
+
+    public ListOptionImpl(@NotNull Component name, @NotNull OptionDescription description, @NotNull Binding<List<T>> binding, @NotNull T initialValue, @NotNull Function<ListOptionEntry<T>, Controller<T>> controllerFunction, ImmutableSet<OptionFlag> flags, boolean collapsed, boolean available, Collection<BiConsumer<Option<List<T>>, List<T>>> listeners) {
+        this.name = name;
+        this.description = description;
+        this.binding = binding;
+        this.initialValue = initialValue;
+        this.entryFactory = new EntryFactory(controllerFunction);
+        this.entries = createEntries(binding().getValue());
+        this.collapsed = collapsed;
+        this.flags = flags;
+        this.available = available;
+        this.listeners = new ArrayList<>();
+        this.listeners.addAll(listeners);
+        this.refreshListeners = new ArrayList<>();
+        callListeners();
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return this.name;
+    }
+
+    @Override
+    public @NotNull OptionDescription description() {
+        return this.description;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return description().text();
+    }
+
+    @Override
+    public @NotNull ImmutableList<ListOptionEntry<T>> options() {
+        return ImmutableList.copyOf(entries);
+    }
+
+    @Override
+    public @NotNull Controller<List<T>> controller() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public @NotNull Binding<List<T>> binding() {
+        return binding;
+    }
+
+    @Override
+    public boolean collapsed() {
+        return collapsed;
+    }
+
+    @Override
+    public @NotNull ImmutableSet<OptionFlag> flags() {
+        return flags;
+    }
+
+    @Override
+    public @NotNull ImmutableList<T> pendingValue() {
+        return ImmutableList.copyOf(entries.stream().map(Option::pendingValue).toList());
+    }
+
+    @Override
+    public void insertEntry(int index, ListOptionEntry<?> entry) {
+        entries.add(index, (ListOptionEntry<T>) entry);
+        onRefresh();
+    }
+
+    @Override
+    public ListOptionEntry<T> insertNewEntryToTop() {
+        ListOptionEntry<T> newEntry = entryFactory.create(initialValue);
+        entries.add(0, newEntry);
+        onRefresh();
+        return newEntry;
+    }
+
+    @Override
+    public void removeEntry(ListOptionEntry<?> entry) {
+        if (entries.remove(entry))
+            onRefresh();
+    }
+
+    @Override
+    public int indexOf(ListOptionEntry<?> entry) {
+        return entries.indexOf(entry);
+    }
+
+    @Override
+    public void requestSet(List<T> value) {
+        entries.clear();
+        entries.addAll(createEntries(value));
+        onRefresh();
+    }
+
+    @Override
+    public boolean changed() {
+        return !binding().getValue().equals(pendingValue());
+    }
+
+    @Override
+    public boolean applyValue() {
+        if (changed()) {
+            binding().setValue(pendingValue());
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void forgetPendingValue() {
+        requestSet(binding().getValue());
+    }
+
+    @Override
+    public void requestSetDefault() {
+        requestSet(binding().defaultValue());
+    }
+
+    @Override
+    public boolean isPendingValueDefault() {
+        return binding().defaultValue().equals(pendingValue());
+    }
+
+    @Override
+    public boolean available() {
+        return available;
+    }
+
+    @Override
+    public void setAvailable(boolean available) {
+        this.available = available;
+    }
+
+    @Override
+    public void addListener(BiConsumer<Option<List<T>>, List<T>> changedListener) {
+        this.listeners.add(changedListener);
+    }
+
+    @Override
+    public void addRefreshListener(Runnable changedListener) {
+        this.refreshListeners.add(changedListener);
+    }
+
+    @Override
+    public boolean isRoot() {
+        return false;
+    }
+
+    private List<ListOptionEntry<T>> createEntries(Collection<T> values) {
+        return values.stream().map(entryFactory::create).collect(Collectors.toList());
+    }
+
+    void callListeners() {
+        List<T> pendingValue = pendingValue();
+        this.listeners.forEach(listener -> listener.accept(this, pendingValue));
+    }
+
+    private void onRefresh() {
+        refreshListeners.forEach(Runnable::run);
+        callListeners();
+    }
+
+    private class EntryFactory {
+        private final Function<ListOptionEntry<T>, Controller<T>> controllerFunction;
+
+        private EntryFactory(Function<ListOptionEntry<T>, Controller<T>> controllerFunction) {
+            this.controllerFunction = controllerFunction;
+        }
+
+        public ListOptionEntry<T> create(T initialValue) {
+            return new ListOptionEntryImpl<>(ListOptionImpl.this, initialValue, controllerFunction);
+        }
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl<T> implements Builder<T> {
+        private Component name = Component.empty();
+        private OptionDescription description = OptionDescription.EMPTY;
+        private Function<ListOptionEntry<T>, Controller<T>> controllerFunction;
+        private Binding<List<T>> binding = null;
+        private final Set<OptionFlag> flags = new HashSet<>();
+        private T initialValue;
+        private boolean collapsed = false;
+        private boolean available = true;
+        private final List<BiConsumer<Option<List<T>>, List<T>>> listeners = new ArrayList<>();
+
+        @Override
+        public Builder<T> name(@NotNull Component name) {
+            Validate.notNull(name, "`name` must not be null");
+
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder<T> description(@NotNull OptionDescription description) {
+            Validate.notNull(description, "`description` must not be null");
+
+            this.description = description;
+            return this;
+        }
+
+        @Override
+        public Builder<T> initial(@NotNull T initialValue) {
+            Validate.notNull(initialValue, "`initialValue` cannot be empty");
+
+            this.initialValue = initialValue;
+            return this;
+        }
+
+        @Override
+        public Builder<T> controller(@NotNull Function<Option<T>, ControllerBuilder<T>> controller) {
+            Validate.notNull(controller, "`controller` cannot be null");
+
+            this.controllerFunction = opt -> controller.apply(opt).build();
+            return this;
+        }
+
+        @Override
+        public Builder<T> customController(@NotNull Function<ListOptionEntry<T>, Controller<T>> control) {
+            Validate.notNull(control, "`control` cannot be null");
+
+            this.controllerFunction = control;
+            return this;
+        }
+
+        @Override
+        public Builder<T> binding(@NotNull Binding<List<T>> binding) {
+            Validate.notNull(binding, "`binding` cannot be null");
+
+            this.binding = binding;
+            return this;
+        }
+
+        @Override
+        public Builder<T> binding(@NotNull List<T> def, @NotNull Supplier<@NotNull List<T>> getter, @NotNull Consumer<@NotNull List<T>> setter) {
+            Validate.notNull(def, "`def` must not be null");
+            Validate.notNull(getter, "`getter` must not be null");
+            Validate.notNull(setter, "`setter` must not be null");
+
+            this.binding = Binding.generic(def, getter, setter);
+            return this;
+        }
+
+        @Override
+        public Builder<T> available(boolean available) {
+            this.available = available;
+            return this;
+        }
+
+        @Override
+        public Builder<T> flag(@NotNull OptionFlag... flag) {
+            Validate.notNull(flag, "`flag` must not be null");
+
+            this.flags.addAll(Arrays.asList(flag));
+            return this;
+        }
+
+        @Override
+        public Builder<T> flags(@NotNull Collection<OptionFlag> flags) {
+            Validate.notNull(flags, "`flags` must not be null");
+
+            this.flags.addAll(flags);
+            return this;
+        }
+
+        @Override
+        public Builder<T> collapsed(boolean collapsible) {
+            this.collapsed = collapsible;
+            return this;
+        }
+
+        @Override
+        public Builder<T> listener(@NotNull BiConsumer<Option<List<T>>, List<T>> listener) {
+            this.listeners.add(listener);
+            return this;
+        }
+
+        @Override
+        public Builder<T> listeners(@NotNull Collection<BiConsumer<Option<List<T>>, List<T>>> listeners) {
+            this.listeners.addAll(listeners);
+            return this;
+        }
+
+        @Override
+        public ListOption<T> build() {
+            Validate.notNull(controllerFunction, "`controller` must not be null");
+            Validate.notNull(binding, "`binding` must not be null");
+            Validate.notNull(initialValue, "`initialValue` must not be null");
+
+            return new ListOptionImpl<>(name, description, binding, initialValue, controllerFunction, ImmutableSet.copyOf(flags), collapsed, available, listeners);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/OptionDescriptionImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/OptionDescriptionImpl.java
new file mode 100644
index 0000000..9ea9456
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/OptionDescriptionImpl.java
@@ -0,0 +1,146 @@
+package dev.isxander.yacl3.impl;
+
+import dev.isxander.yacl3.api.OptionDescription;
+import dev.isxander.yacl3.gui.ImageRenderer;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.resources.ResourceLocation;
+import org.apache.commons.lang3.Validate;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+public record OptionDescriptionImpl(Component text, CompletableFuture<Optional<ImageRenderer>> image) implements OptionDescription {
+    public static class BuilderImpl implements Builder {
+        private final List<Component> descriptionLines = new ArrayList<>();
+        private CompletableFuture<Optional<ImageRenderer>> image = CompletableFuture.completedFuture(Optional.empty());
+        private boolean imageUnset = true;
+
+        @Override
+        public Builder text(Component... description) {
+            this.descriptionLines.addAll(Arrays.asList(description));
+            return this;
+        }
+
+        @Override
+        public Builder text(Collection<? extends Component> lines) {
+            this.descriptionLines.addAll(lines);
+            return this;
+        }
+
+        @Override
+        public Builder image(ResourceLocation image, int width, int height) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            Validate.isTrue(width > 0, "Width must be greater than 0!");
+            Validate.isTrue(height > 0, "Height must be greater than 0!");
+
+            this.image = ImageRenderer.getOrMakeSync(image, () -> Optional.of(new ImageRenderer.TextureBacked(image, 0, 0, width, height, width, height)));
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder image(ResourceLocation image, float u, float v, int width, int height, int textureWidth, int textureHeight) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            Validate.isTrue(width > 0, "Width must be greater than 0!");
+            Validate.isTrue(height > 0, "Height must be greater than 0!");
+
+            this.image = ImageRenderer.getOrMakeSync(image, () -> Optional.of(new ImageRenderer.TextureBacked(image, u, v, width, height, textureWidth, textureHeight)));
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder image(Path path, ResourceLocation uniqueLocation) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            this.image = ImageRenderer.getOrMakeAsync(uniqueLocation, () -> ImageRenderer.NativeImageBacked.createFromPath(path, uniqueLocation));
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder gifImage(ResourceLocation image) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            this.image = ImageRenderer.getOrMakeAsync(image, () -> {
+                try {
+                    return Optional.of(ImageRenderer.AnimatedNativeImageBacked.createGIFFromTexture(image));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    return Optional.empty();
+                }
+            });
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder gifImage(Path path, ResourceLocation uniqueLocation) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            this.image = ImageRenderer.getOrMakeAsync(uniqueLocation, () -> {
+                try {
+                    return Optional.of(ImageRenderer.AnimatedNativeImageBacked.createGIF(new FileInputStream(path.toFile()), uniqueLocation));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    return Optional.empty();
+                }
+            });
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder webpImage(ResourceLocation image) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            this.image = ImageRenderer.getOrMakeAsync(image, () -> {
+                try {
+                    return Optional.of(ImageRenderer.AnimatedNativeImageBacked.createWEBPFromTexture(image));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    return Optional.empty();
+                }
+            });
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder webpImage(Path path, ResourceLocation uniqueLocation) {
+            Validate.isTrue(imageUnset, "Image already set!");
+            this.image = ImageRenderer.getOrMakeAsync(uniqueLocation, () -> {
+                try {
+                    return Optional.of(ImageRenderer.AnimatedNativeImageBacked.createWEBP(new FileInputStream(path.toFile()), uniqueLocation));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    return Optional.empty();
+                }
+            });
+            imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public Builder customImage(CompletableFuture<Optional<ImageRenderer>> image) {
+            Validate.notNull(image, "Image cannot be null!");
+            Validate.isTrue(imageUnset, "Image already set!");
+
+            this.image = image;
+            this.imageUnset = false;
+            return this;
+        }
+
+        @Override
+        public OptionDescription build() {
+            MutableComponent concatenatedDescription = Component.empty();
+            Iterator<Component> iter = descriptionLines.iterator();
+            while (iter.hasNext()) {
+                concatenatedDescription.append(iter.next());
+                if (iter.hasNext()) concatenatedDescription.append("\n");
+            }
+
+            return new OptionDescriptionImpl(concatenatedDescription, image);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/OptionGroupImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/OptionGroupImpl.java
new file mode 100644
index 0000000..7805b29
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/OptionGroupImpl.java
@@ -0,0 +1,121 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.ListOption;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.OptionDescription;
+import dev.isxander.yacl3.api.OptionGroup;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+@ApiStatus.Internal
+public final class OptionGroupImpl implements OptionGroup {
+    private final @NotNull Component name;
+    private final @NotNull OptionDescription description;
+    private final ImmutableList<? extends Option<?>> options;
+    private final boolean collapsed;
+    private final boolean isRoot;
+
+    public OptionGroupImpl(@NotNull Component name, @NotNull OptionDescription description, ImmutableList<? extends Option<?>> options, boolean collapsed, boolean isRoot) {
+        this.name = name;
+        this.description = description;
+        this.options = options;
+        this.collapsed = collapsed;
+        this.isRoot = isRoot;
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return name;
+    }
+
+    @Override
+    public OptionDescription description() {
+        return description;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return description.text();
+    }
+
+    @Override
+    public @NotNull ImmutableList<? extends Option<?>> options() {
+        return options;
+    }
+
+    @Override
+    public boolean collapsed() {
+        return collapsed;
+    }
+
+    @Override
+    public boolean isRoot() {
+        return isRoot;
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl implements Builder {
+        private Component name = Component.empty();
+        private OptionDescription description = OptionDescription.EMPTY;
+        private final List<Option<?>> options = new ArrayList<>();
+        private boolean collapsed = false;
+
+        @Override
+        public Builder name(@NotNull Component name) {
+            Validate.notNull(name, "`name` must not be null");
+
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder description(@NotNull OptionDescription description) {
+            Validate.notNull(description, "`description` must not be null");
+
+            this.description = description;
+            return this;
+        }
+
+        @Override
+        public Builder option(@NotNull Option<?> option) {
+            Validate.notNull(option, "`option` must not be null");
+
+            if (option instanceof ListOption<?>)
+                throw new UnsupportedOperationException("List options must not be added as an option but a group!");
+
+            this.options.add(option);
+            return this;
+        }
+
+        @Override
+        public Builder options(@NotNull Collection<? extends Option<?>> options) {
+            Validate.notEmpty(options, "`options` must not be empty");
+
+            if (options.stream().anyMatch(ListOption.class::isInstance))
+                throw new UnsupportedOperationException("List options must not be added as an option but a group!");
+
+            this.options.addAll(options);
+            return this;
+        }
+
+        @Override
+        public Builder collapsed(boolean collapsible) {
+            this.collapsed = collapsible;
+            return this;
+        }
+
+        @Override
+        public OptionGroup build() {
+            Validate.notEmpty(options, "`options` must not be empty to build `OptionGroup`");
+
+            return new OptionGroupImpl(name, description, ImmutableList.copyOf(options), collapsed, false);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/OptionImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/OptionImpl.java
new file mode 100644
index 0000000..9b3a613
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/OptionImpl.java
@@ -0,0 +1,257 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableSet;
+import dev.isxander.yacl3.api.*;
+import dev.isxander.yacl3.api.controller.ControllerBuilder;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+@ApiStatus.Internal
+public final class OptionImpl<T> implements Option<T> {
+    private final Component name;
+    private OptionDescription description;
+    private final Controller<T> controller;
+    private final Binding<T> binding;
+    private boolean available;
+
+    private final ImmutableSet<OptionFlag> flags;
+
+    private T pendingValue;
+
+    private final List<BiConsumer<Option<T>, T>> listeners;
+
+    public OptionImpl(
+            @NotNull Component name,
+            @NotNull Function<T, OptionDescription> descriptionFunction,
+            @NotNull Function<Option<T>, Controller<T>> controlGetter,
+            @NotNull Binding<T> binding,
+            boolean available,
+            ImmutableSet<OptionFlag> flags,
+            @NotNull Collection<BiConsumer<Option<T>, T>> listeners
+    ) {
+        this.name = name;
+        this.binding = binding;
+        this.available = available;
+        this.flags = flags;
+        this.listeners = new ArrayList<>(listeners);
+        this.controller = controlGetter.apply(this);
+
+        addListener((opt, pending) -> description = descriptionFunction.apply(pending));
+
+        requestSet(binding().getValue());
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return name;
+    }
+
+    @Override
+    public @NotNull OptionDescription description() {
+        return this.description;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return description.text();
+    }
+
+    @Override
+    public @NotNull Controller<T> controller() {
+        return controller;
+    }
+
+    @Override
+    public @NotNull Binding<T> binding() {
+        return binding;
+    }
+
+    @Override
+    public boolean available() {
+        return available;
+    }
+
+    @Override
+    public void setAvailable(boolean available) {
+        this.available = available;
+    }
+
+    @Override
+    public @NotNull ImmutableSet<OptionFlag> flags() {
+        return flags;
+    }
+
+    @Override
+    public boolean changed() {
+        return !binding().getValue().equals(pendingValue);
+    }
+
+    @Override
+    public @NotNull T pendingValue() {
+        return pendingValue;
+    }
+
+    @Override
+    public void requestSet(T value) {
+        pendingValue = value;
+        listeners.forEach(listener -> listener.accept(this, pendingValue));
+    }
+
+    @Override
+    public boolean applyValue() {
+        if (changed()) {
+            binding().setValue(pendingValue);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void forgetPendingValue() {
+        requestSet(binding().getValue());
+    }
+
+    @Override
+    public void requestSetDefault() {
+        requestSet(binding().defaultValue());
+    }
+
+    @Override
+    public boolean isPendingValueDefault() {
+        return binding().defaultValue().equals(pendingValue());
+    }
+
+    @Override
+    public void addListener(BiConsumer<Option<T>, T> changedListener) {
+        this.listeners.add(changedListener);
+    }
+
+    @ApiStatus.Internal
+    public static class BuilderImpl<T> implements Builder<T> {
+        private Component name = Component.literal("Name not specified!").withStyle(ChatFormatting.RED);
+
+        private Function<T, OptionDescription> descriptionFunction = pending -> OptionDescription.EMPTY;
+
+        private Function<Option<T>, Controller<T>> controlGetter;
+
+        private Binding<T> binding;
+
+        private boolean available = true;
+
+        private boolean instant = false;
+
+        private final Set<OptionFlag> flags = new HashSet<>();
+
+        private final List<BiConsumer<Option<T>, T>> listeners = new ArrayList<>();
+
+        @Override
+        public Builder<T> name(@NotNull Component name) {
+            Validate.notNull(name, "`name` cannot be null");
+
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder<T> description(@NotNull OptionDescription description) {
+            return description(opt -> description);
+        }
+
+        @Override
+        public Builder<T> description(@NotNull Function<T, OptionDescription> descriptionFunction) {
+            this.descriptionFunction = descriptionFunction;
+            return this;
+        }
+
+        @Override
+        public Builder<T> controller(@NotNull Function<Option<T>, ControllerBuilder<T>> controllerBuilder) {
+            Validate.notNull(controllerBuilder, "`controllerBuilder` cannot be null");
+
+            return customController(opt -> controllerBuilder.apply(opt).build());
+        }
+
+        @Override
+        public Builder<T> customController(@NotNull Function<Option<T>, Controller<T>> control) {
+            Validate.notNull(control, "`control` cannot be null");
+
+            this.controlGetter = control;
+            return this;
+        }
+
+        @Override
+        public Builder<T> binding(@NotNull Binding<T> binding) {
+            Validate.notNull(binding, "`binding` cannot be null");
+
+            this.binding = binding;
+            return this;
+        }
+
+        @Override
+        public Builder<T> binding(@NotNull T def, @NotNull Supplier<@NotNull T> getter, @NotNull Consumer<@NotNull T> setter) {
+            Validate.notNull(def, "`def` must not be null");
+            Validate.notNull(getter, "`getter` must not be null");
+            Validate.notNull(setter, "`setter` must not be null");
+
+            this.binding = Binding.generic(def, getter, setter);
+            return this;
+        }
+
+        @Override
+        public Builder<T> available(boolean available) {
+            this.available = available;
+            return this;
+        }
+
+        @Override
+        public Builder<T> flag(@NotNull OptionFlag... flag) {
+            Validate.notNull(flag, "`flag` must not be null");
+
+            this.flags.addAll(Arrays.asList(flag));
+            return this;
+        }
+
+        @Override
+        public Builder<T> flags(@NotNull Collection<? extends OptionFlag> flags) {
+            Validate.notNull(flags, "`flags` must not be null");
+
+            this.flags.addAll(flags);
+            return this;
+        }
+
+        @Override
+        public Builder<T> instant(boolean instant) {
+            this.instant = instant;
+            return this;
+        }
+
+        @Override
+        public Builder<T> listener(@NotNull BiConsumer<Option<T>, T> listener) {
+            this.listeners.add(listener);
+            return this;
+        }
+
+        @Override
+        public Builder<T> listeners(@NotNull Collection<BiConsumer<Option<T>, T>> listeners) {
+            this.listeners.addAll(listeners);
+            return this;
+        }
+
+        @Override
+        public Option<T> build() {
+            Validate.notNull(controlGetter, "`control` must not be null when building `Option`");
+            Validate.notNull(binding, "`binding` must not be null when building `Option`");
+            Validate.isTrue(!instant || flags.isEmpty(), "instant application does not support option flags");
+
+            return new OptionImpl<>(name, descriptionFunction, controlGetter, binding, available, ImmutableSet.copyOf(flags), listeners);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/PlaceholderCategoryImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/PlaceholderCategoryImpl.java
new file mode 100644
index 0000000..5e836a3
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/PlaceholderCategoryImpl.java
@@ -0,0 +1,99 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.OptionGroup;
+import dev.isxander.yacl3.api.PlaceholderCategory;
+import dev.isxander.yacl3.gui.YACLScreen;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+
+@ApiStatus.Internal
+public final class PlaceholderCategoryImpl implements PlaceholderCategory {
+    private final Component name;
+    private final BiFunction<Minecraft, YACLScreen, Screen> screen;
+    private final Component tooltip;
+
+    public PlaceholderCategoryImpl(Component name, BiFunction<Minecraft, YACLScreen, Screen> screen, Component tooltip) {
+        this.name = name;
+        this.screen = screen;
+        this.tooltip = tooltip;
+    }
+
+    @Override
+    public @NotNull ImmutableList<OptionGroup> groups() {
+        return ImmutableList.of();
+    }
+
+    @Override
+    public @NotNull Component name() {
+        return name;
+    }
+
+    @Override
+    public BiFunction<Minecraft, YACLScreen, Screen> screen() {
+        return screen;
+    }
+
+    @Override
+    public @NotNull Component tooltip() {
+        return tooltip;
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl implements Builder {
+        private Component name;
+
+        private final List<Component> tooltipLines = new ArrayList<>();
+
+        private BiFunction<Minecraft, YACLScreen, Screen> screenFunction;
+
+        @Override
+        public Builder name(@NotNull Component name) {
+            Validate.notNull(name, "`name` cannot be null");
+
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder tooltip(@NotNull Component... tooltips) {
+            Validate.notEmpty(tooltips, "`tooltips` cannot be empty");
+
+            tooltipLines.addAll(List.of(tooltips));
+            return this;
+        }
+
+        @Override
+        public Builder screen(@NotNull BiFunction<Minecraft, YACLScreen, Screen> screenFunction) {
+            Validate.notNull(screenFunction, "`screenFunction` cannot be null");
+
+            this.screenFunction = screenFunction;
+            return this;
+        }
+
+        @Override
+        public PlaceholderCategory build() {
+            Validate.notNull(name, "`name` must not be null to build `ConfigCategory`");
+
+            MutableComponent concatenatedTooltip = Component.empty();
+            boolean first = true;
+            for (Component line : tooltipLines) {
+                if (!first) concatenatedTooltip.append("\n");
+                first = false;
+
+                concatenatedTooltip.append(line);
+            }
+
+            return new PlaceholderCategoryImpl(name, screenFunction, concatenatedTooltip);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/YetAnotherConfigLibImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/YetAnotherConfigLibImpl.java
new file mode 100644
index 0000000..0be02a7
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/YetAnotherConfigLibImpl.java
@@ -0,0 +1,122 @@
+package dev.isxander.yacl3.impl;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.ConfigCategory;
+import dev.isxander.yacl3.api.PlaceholderCategory;
+import dev.isxander.yacl3.api.YetAnotherConfigLib;
+import dev.isxander.yacl3.gui.YACLScreen;
+import dev.isxander.yacl3.impl.utils.YACLConstants;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
+
+@ApiStatus.Internal
+public final class YetAnotherConfigLibImpl implements YetAnotherConfigLib {
+    private final Component title;
+    private final ImmutableList<ConfigCategory> categories;
+    private final Runnable saveFunction;
+    private final Consumer<YACLScreen> initConsumer;
+
+    private boolean generated = false;
+
+    public YetAnotherConfigLibImpl(Component title, ImmutableList<ConfigCategory> categories, Runnable saveFunction, Consumer<YACLScreen> initConsumer) {
+        this.title = title;
+        this.categories = categories;
+        this.saveFunction = saveFunction;
+        this.initConsumer = initConsumer;
+    }
+
+    @Override
+    public Screen generateScreen(Screen parent) {
+        if (generated)
+            throw new UnsupportedOperationException("To prevent memory leaks, you should only generate a Screen once per instance. Please re-build the instance to generate another GUI.");
+
+        YACLConstants.LOGGER.info("Generating YACL screen");
+        generated = true;
+        return new YACLScreen(this, parent);
+    }
+
+    @Override
+    public Component title() {
+        return title;
+    }
+
+    @Override
+    public ImmutableList<ConfigCategory> categories() {
+        return categories;
+    }
+
+    @Override
+    public Runnable saveFunction() {
+        return saveFunction;
+    }
+
+    @Override
+    public Consumer<YACLScreen> initConsumer() {
+        return initConsumer;
+    }
+
+    @ApiStatus.Internal
+    public static final class BuilderImpl implements Builder {
+        private Component title;
+        private final List<ConfigCategory> categories = new ArrayList<>();
+        private Runnable saveFunction = () -> {};
+        private Consumer<YACLScreen> initConsumer = screen -> {};
+
+        @Override
+        public Builder title(@NotNull Component title) {
+            Validate.notNull(title, "`title` cannot be null");
+
+            this.title = title;
+            return this;
+        }
+
+        @Override
+        public Builder category(@NotNull ConfigCategory category) {
+            Validate.notNull(category, "`category` cannot be null");
+
+            this.categories.add(category);
+            return this;
+        }
+
+        @Override
+        public Builder categories(@NotNull Collection<? extends ConfigCategory> categories) {
+            Validate.notNull(categories, "`categories` cannot be null");
+
+            this.categories.addAll(categories);
+            return this;
+        }
+
+        @Override
+        public Builder save(@NotNull Runnable saveFunction) {
+            Validate.notNull(saveFunction, "`saveFunction` cannot be null");
+
+            this.saveFunction = saveFunction;
+            return this;
+        }
+
+        @Override
+        public Builder screenInit(@NotNull Consumer<YACLScreen> initConsumer) {
+            Validate.notNull(initConsumer, "`initConsumer` cannot be null");
+
+            this.initConsumer = initConsumer;
+            return this;
+        }
+
+        @Override
+        public YetAnotherConfigLib build() {
+            Validate.notNull(title, "`title must not be null to build `YetAnotherConfigLib`");
+            Validate.notEmpty(categories, "`categories` must not be empty to build `YetAnotherConfigLib`");
+            Validate.isTrue(!categories.stream().allMatch(category -> category instanceof PlaceholderCategory), "At least one regular category is required to build `YetAnotherConfigLib`");
+
+            return new YetAnotherConfigLibImpl(title, ImmutableList.copyOf(categories), saveFunction, initConsumer);
+        }
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/AbstractControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/AbstractControllerBuilderImpl.java
new file mode 100644
index 0000000..66c025a
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/AbstractControllerBuilderImpl.java
@@ -0,0 +1,12 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.ControllerBuilder;
+
+public abstract class AbstractControllerBuilderImpl<T> implements ControllerBuilder<T> {
+    protected final Option<T> option;
+
+    protected AbstractControllerBuilderImpl(Option<T> option) {
+        this.option = option;
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/BooleanControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/BooleanControllerBuilderImpl.java
new file mode 100644
index 0000000..208f78e
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/BooleanControllerBuilderImpl.java
@@ -0,0 +1,56 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.BooleanControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.BooleanController;
+import net.minecraft.network.chat.Component;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class BooleanControllerBuilderImpl extends AbstractControllerBuilderImpl<Boolean> implements BooleanControllerBuilder {
+    private boolean coloured = false;
+    private Function<Boolean, Component> formatter = BooleanController.ON_OFF_FORMATTER;
+
+    public BooleanControllerBuilderImpl(Option<Boolean> option) {
+        super(option);
+    }
+
+    @Override
+    public BooleanControllerBuilder coloured(boolean coloured) {
+        this.coloured = coloured;
+        return this;
+    }
+
+    @Override
+    public BooleanControllerBuilder valueFormatter(Function<Boolean, Component> formatter) {
+        Validate.notNull(formatter);
+
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public BooleanControllerBuilder onOffFormatter() {
+        this.formatter = BooleanController.ON_OFF_FORMATTER;
+        return this;
+    }
+
+    @Override
+    public BooleanControllerBuilder yesNoFormatter() {
+        this.formatter = BooleanController.YES_NO_FORMATTER;
+        return this;
+    }
+
+    @Override
+    public BooleanControllerBuilder trueFalseFormatter() {
+        this.formatter = BooleanController.TRUE_FALSE_FORMATTER;
+        return this;
+    }
+
+    @Override
+    public Controller<Boolean> build() {
+        return new BooleanController(option, formatter, coloured);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/ColorControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/ColorControllerBuilderImpl.java
new file mode 100644
index 0000000..9412165
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/ColorControllerBuilderImpl.java
@@ -0,0 +1,27 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.ColorControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.ColorController;
+
+import java.awt.Color;
+
+public class ColorControllerBuilderImpl extends AbstractControllerBuilderImpl<Color> implements ColorControllerBuilder {
+    private boolean allowAlpha = false;
+
+    public ColorControllerBuilderImpl(Option<Color> option) {
+        super(option);
+    }
+
+    @Override
+    public ColorControllerBuilder allowAlpha(boolean allowAlpha) {
+        this.allowAlpha = allowAlpha;
+        return this;
+    }
+
+    @Override
+    public Controller<Color> build() {
+        return new ColorController(option, allowAlpha);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/CyclingListControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/CyclingListControllerBuilderImpl.java
new file mode 100644
index 0000000..63045f2
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/CyclingListControllerBuilderImpl.java
@@ -0,0 +1,43 @@
+package dev.isxander.yacl3.impl.controller;
+
+import com.google.common.collect.ImmutableList;
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.CyclingListControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.cycling.CyclingListController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public final class CyclingListControllerBuilderImpl<T> extends AbstractControllerBuilderImpl<T> implements CyclingListControllerBuilder<T> {
+    private Iterable<? extends T> values;
+    private Function<T, Component> formatter = null;
+
+    public CyclingListControllerBuilderImpl(Option<T> option) {
+        super(option);
+    }
+
+    @Override
+    public CyclingListControllerBuilder<T> values(Iterable<? extends T> values) {
+        this.values = values;
+        return this;
+    }
+
+    @SafeVarargs
+    @Override
+    public final CyclingListControllerBuilder<T> values(T... values) {
+        this.values = ImmutableList.copyOf(values);
+        return this;
+    }
+
+    @Override
+    public CyclingListControllerBuilder<T> valueFormatter(Function<T, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<T> build() {
+        return new CyclingListController<>(option, values, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/DoubleFieldControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/DoubleFieldControllerBuilderImpl.java
new file mode 100644
index 0000000..56e1d44
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/DoubleFieldControllerBuilderImpl.java
@@ -0,0 +1,50 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.DoubleFieldControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.DoubleSliderController;
+import dev.isxander.yacl3.gui.controllers.string.number.DoubleFieldController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class DoubleFieldControllerBuilderImpl extends AbstractControllerBuilderImpl<Double> implements DoubleFieldControllerBuilder {
+    private double min = Double.MIN_VALUE;
+    private double max = Double.MAX_VALUE;
+    private Function<Double, Component> formatter = DoubleSliderController.DEFAULT_FORMATTER;
+
+    public DoubleFieldControllerBuilderImpl(Option<Double> option) {
+        super(option);
+    }
+
+    @Override
+    public DoubleFieldControllerBuilder min(Double min) {
+        this.min = min;
+        return this;
+    }
+
+    @Override
+    public DoubleFieldControllerBuilder max(Double max) {
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public DoubleFieldControllerBuilder range(Double min, Double max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public DoubleFieldControllerBuilder valueFormatter(Function<Double, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Double> build() {
+        return new DoubleFieldController(option, min, max, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/DoubleSliderControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/DoubleSliderControllerBuilderImpl.java
new file mode 100644
index 0000000..a636abf
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/DoubleSliderControllerBuilderImpl.java
@@ -0,0 +1,43 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.DoubleSliderControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.DoubleSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class DoubleSliderControllerBuilderImpl extends AbstractControllerBuilderImpl<Double> implements DoubleSliderControllerBuilder {
+    private double min, max;
+    private double step;
+    private Function<Double, Component> formatter = DoubleSliderController.DEFAULT_FORMATTER;
+
+    public DoubleSliderControllerBuilderImpl(Option<Double> option) {
+        super(option);
+    }
+
+    @Override
+    public DoubleSliderControllerBuilder range(Double min, Double max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public DoubleSliderControllerBuilder step(Double step) {
+        this.step = step;
+        return this;
+    }
+
+    @Override
+    public DoubleSliderControllerBuilder valueFormatter(Function<Double, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Double> build() {
+        return new DoubleSliderController(option, min, max, step, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/EnumControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/EnumControllerBuilderImpl.java
new file mode 100644
index 0000000..3237dbf
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/EnumControllerBuilderImpl.java
@@ -0,0 +1,35 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.EnumControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.cycling.EnumController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class EnumControllerBuilderImpl<T extends Enum<T>> extends AbstractControllerBuilderImpl<T> implements EnumControllerBuilder<T> {
+    private Class<T> enumClass;
+    private Function<T, Component> formatter = EnumController.getDefaultFormatter();
+
+    public EnumControllerBuilderImpl(Option<T> option) {
+        super(option);
+    }
+
+    @Override
+    public EnumControllerBuilder<T> enumClass(Class<T> enumClass) {
+        this.enumClass = enumClass;
+        return this;
+    }
+
+    @Override
+    public EnumControllerBuilder<T> valueFormatter(Function<T, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<T> build() {
+        return new EnumController<>(option, formatter, enumClass.getEnumConstants());
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/FloatFieldControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/FloatFieldControllerBuilderImpl.java
new file mode 100644
index 0000000..09dbce0
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/FloatFieldControllerBuilderImpl.java
@@ -0,0 +1,50 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.FloatFieldControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.FloatSliderController;
+import dev.isxander.yacl3.gui.controllers.string.number.FloatFieldController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class FloatFieldControllerBuilderImpl extends AbstractControllerBuilderImpl<Float> implements FloatFieldControllerBuilder {
+    private float min = Float.MIN_VALUE;
+    private float max = Float.MAX_VALUE;
+    private Function<Float, Component> formatter = FloatSliderController.DEFAULT_FORMATTER;
+
+    public FloatFieldControllerBuilderImpl(Option<Float> option) {
+        super(option);
+    }
+
+    @Override
+    public FloatFieldControllerBuilder min(Float min) {
+        this.min = min;
+        return this;
+    }
+
+    @Override
+    public FloatFieldControllerBuilder max(Float max) {
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public FloatFieldControllerBuilder range(Float min, Float max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public FloatFieldControllerBuilder valueFormatter(Function<Float, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Float> build() {
+        return new FloatFieldController(option, min, max, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/FloatSliderControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/FloatSliderControllerBuilderImpl.java
new file mode 100644
index 0000000..c9699fb
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/FloatSliderControllerBuilderImpl.java
@@ -0,0 +1,43 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.FloatSliderControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.FloatSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class FloatSliderControllerBuilderImpl extends AbstractControllerBuilderImpl<Float> implements FloatSliderControllerBuilder {
+    private float min, max;
+    private float step;
+    private Function<Float, Component> formatter = FloatSliderController.DEFAULT_FORMATTER;
+
+    public FloatSliderControllerBuilderImpl(Option<Float> option) {
+        super(option);
+    }
+
+    @Override
+    public FloatSliderControllerBuilder range(Float min, Float max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public FloatSliderControllerBuilder step(Float step) {
+        this.step = step;
+        return this;
+    }
+
+    @Override
+    public FloatSliderControllerBuilder valueFormatter(Function<Float, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Float> build() {
+        return new FloatSliderController(option, min, max, step, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/IntegerFieldControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/IntegerFieldControllerBuilderImpl.java
new file mode 100644
index 0000000..73b51a0
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/IntegerFieldControllerBuilderImpl.java
@@ -0,0 +1,50 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.IntegerFieldControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.IntegerSliderController;
+import dev.isxander.yacl3.gui.controllers.string.number.IntegerFieldController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class IntegerFieldControllerBuilderImpl extends AbstractControllerBuilderImpl<Integer> implements IntegerFieldControllerBuilder {
+    private int min = Integer.MIN_VALUE;
+    private int max = Integer.MAX_VALUE;
+    private Function<Integer, Component> formatter = IntegerSliderController.DEFAULT_FORMATTER;
+
+    public IntegerFieldControllerBuilderImpl(Option<Integer> option) {
+        super(option);
+    }
+
+    @Override
+    public IntegerFieldControllerBuilder min(Integer min) {
+        this.min = min;
+        return this;
+    }
+
+    @Override
+    public IntegerFieldControllerBuilder max(Integer max) {
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public IntegerFieldControllerBuilder range(Integer min, Integer max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public IntegerFieldControllerBuilder valueFormatter(Function<Integer, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Integer> build() {
+        return new IntegerFieldController(option, min, max, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/IntegerSliderControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/IntegerSliderControllerBuilderImpl.java
new file mode 100644
index 0000000..106c22a
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/IntegerSliderControllerBuilderImpl.java
@@ -0,0 +1,43 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.IntegerSliderControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.IntegerSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class IntegerSliderControllerBuilderImpl extends AbstractControllerBuilderImpl<Integer> implements IntegerSliderControllerBuilder {
+    private int min, max;
+    private int step;
+    private Function<Integer, Component> formatter = IntegerSliderController.DEFAULT_FORMATTER;
+
+    public IntegerSliderControllerBuilderImpl(Option<Integer> option) {
+        super(option);
+    }
+
+    @Override
+    public IntegerSliderControllerBuilder range(Integer min, Integer max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public IntegerSliderControllerBuilder step(Integer step) {
+        this.step = step;
+        return this;
+    }
+
+    @Override
+    public IntegerSliderControllerBuilder valueFormatter(Function<Integer, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Integer> build() {
+        return new IntegerSliderController(option, min, max, step, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/LongFieldControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/LongFieldControllerBuilderImpl.java
new file mode 100644
index 0000000..88cb610
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/LongFieldControllerBuilderImpl.java
@@ -0,0 +1,50 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.LongFieldControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.LongSliderController;
+import dev.isxander.yacl3.gui.controllers.string.number.LongFieldController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class LongFieldControllerBuilderImpl extends AbstractControllerBuilderImpl<Long> implements LongFieldControllerBuilder {
+    private long min = Long.MIN_VALUE;
+    private long max = Long.MAX_VALUE;
+    private Function<Long, Component> formatter = LongSliderController.DEFAULT_FORMATTER;
+
+    public LongFieldControllerBuilderImpl(Option<Long> option) {
+        super(option);
+    }
+
+    @Override
+    public LongFieldControllerBuilder min(Long min) {
+        this.min = min;
+        return this;
+    }
+
+    @Override
+    public LongFieldControllerBuilder max(Long max) {
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public LongFieldControllerBuilder range(Long min, Long max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public LongFieldControllerBuilder valueFormatter(Function<Long, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Long> build() {
+        return new LongFieldController(option, min, max, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/LongSliderControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/LongSliderControllerBuilderImpl.java
new file mode 100644
index 0000000..2bd932a
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/LongSliderControllerBuilderImpl.java
@@ -0,0 +1,43 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.LongSliderControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.slider.LongSliderController;
+import net.minecraft.network.chat.Component;
+
+import java.util.function.Function;
+
+public class LongSliderControllerBuilderImpl extends AbstractControllerBuilderImpl<Long> implements LongSliderControllerBuilder {
+    private long min, max;
+    private long step;
+    private Function<Long, Component> formatter = LongSliderController.DEFAULT_FORMATTER;
+
+    public LongSliderControllerBuilderImpl(Option<Long> option) {
+        super(option);
+    }
+
+    @Override
+    public LongSliderControllerBuilder range(Long min, Long max) {
+        this.min = min;
+        this.max = max;
+        return this;
+    }
+
+    @Override
+    public LongSliderControllerBuilder step(Long step) {
+        this.step = step;
+        return this;
+    }
+
+    @Override
+    public LongSliderControllerBuilder valueFormatter(Function<Long, Component> formatter) {
+        this.formatter = formatter;
+        return this;
+    }
+
+    @Override
+    public Controller<Long> build() {
+        return new LongSliderController(option, min, max, step, formatter);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/StringControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/StringControllerBuilderImpl.java
new file mode 100644
index 0000000..a0f51b9
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/StringControllerBuilderImpl.java
@@ -0,0 +1,17 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.StringControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.string.StringController;
+
+public class StringControllerBuilderImpl extends AbstractControllerBuilderImpl<String> implements StringControllerBuilder {
+    public StringControllerBuilderImpl(Option<String> option) {
+        super(option);
+    }
+
+    @Override
+    public Controller<String> build() {
+        return new StringController(option);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/controller/TickBoxControllerBuilderImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/controller/TickBoxControllerBuilderImpl.java
new file mode 100644
index 0000000..3b29719
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/controller/TickBoxControllerBuilderImpl.java
@@ -0,0 +1,17 @@
+package dev.isxander.yacl3.impl.controller;
+
+import dev.isxander.yacl3.api.Controller;
+import dev.isxander.yacl3.api.Option;
+import dev.isxander.yacl3.api.controller.TickBoxControllerBuilder;
+import dev.isxander.yacl3.gui.controllers.TickBoxController;
+
+public class TickBoxControllerBuilderImpl extends AbstractControllerBuilderImpl<Boolean> implements TickBoxControllerBuilder {
+    public TickBoxControllerBuilderImpl(Option<Boolean> option) {
+        super(option);
+    }
+
+    @Override
+    public Controller<Boolean> build() {
+        return new TickBoxController(option);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/utils/DimensionIntegerImpl.java b/common/src/main/java/dev/isxander/yacl3/impl/utils/DimensionIntegerImpl.java
new file mode 100644
index 0000000..7d29bbc
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/utils/DimensionIntegerImpl.java
@@ -0,0 +1,115 @@
+package dev.isxander.yacl3.impl.utils;
+
+import dev.isxander.yacl3.api.utils.Dimension;
+import dev.isxander.yacl3.api.utils.MutableDimension;
+
+public class DimensionIntegerImpl implements MutableDimension<Integer> {
+    private int x, y;
+    private int width, height;
+
+    public DimensionIntegerImpl(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public Integer x() {
+        return x;
+    }
+
+    @Override
+    public Integer y() {
+        return y;
+    }
+
+    @Override
+    public Integer width() {
+        return width;
+    }
+
+    @Override
+    public Integer height() {
+        return height;
+    }
+
+    @Override
+    public Integer xLimit() {
+        return x + width;
+    }
+
+    @Override
+    public Integer yLimit() {
+        return y + height;
+    }
+
+    @Override
+    public Integer centerX() {
+        return x + width / 2;
+    }
+
+    @Override
+    public Integer centerY() {
+        return y + height / 2;
+    }
+
+    @Override
+    public boolean isPointInside(Integer x, Integer y) {
+        return x >= x() && x <= xLimit() && y >= y() && y <= yLimit();
+    }
+
+    @Override
+    public MutableDimension<Integer> clone() {
+        return new DimensionIntegerImpl(x, y, width, height);
+    }
+
+    @Override public MutableDimension<Integer> setX(Integer x) { this.x = x; return this; }
+    @Override public MutableDimension<Integer> setY(Integer y) { this.y = y; return this; }
+    @Override public MutableDimension<Integer> setWidth(Integer width) { this.width = width; return this; }
+    @Override public MutableDimension<Integer> setHeight(Integer height) { this.height = height; return this; }
+
+    @Override
+    public Dimension<Integer> withX(Integer x) {
+        return clone().setX(x);
+    }
+
+    @Override
+    public Dimension<Integer> withY(Integer y) {
+        return clone().setY(y);
+    }
+
+    @Override
+    public Dimension<Integer> withWidth(Integer width) {
+        return clone().setWidth(width);
+    }
+
+    @Override
+    public Dimension<Integer> withHeight(Integer height) {
+        return clone().setHeight(height);
+    }
+
+    @Override
+    public MutableDimension<Integer> move(Integer x, Integer y) {
+        this.x += x;
+        this.y += y;
+        return this;
+    }
+
+    @Override
+    public MutableDimension<Integer> expand(Integer width, Integer height) {
+        this.width += width;
+        this.height += height;
+        return this;
+    }
+
+    @Override
+    public Dimension<Integer> moved(Integer x, Integer y) {
+        return clone().move(x, y);
+    }
+
+    @Override
+    public Dimension<Integer> expanded(Integer width, Integer height) {
+        return clone().expand(width, height);
+    }
+}
diff --git a/common/src/main/java/dev/isxander/yacl3/impl/utils/YACLConstants.java b/common/src/main/java/dev/isxander/yacl3/impl/utils/YACLConstants.java
new file mode 100644
index 0000000..9570b02
--- /dev/null
+++ b/common/src/main/java/dev/isxander/yacl3/impl/utils/YACLConstants.java
@@ -0,0 +1,13 @@
+package dev.isxander.yacl3.impl.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class YACLConstants {
+    public static final Logger LOGGER = LoggerFactory.getLogger("YetAnotherConfigLib");
+
+    public static final ExecutorService SINGLE_THREAD_EXECUTOR = Executors.newSingleThreadExecutor();
+}