diff --git a/PathfinderAPI/Event/Options/CustomOptionsLoadEvent.cs b/PathfinderAPI/Event/Options/CustomOptionsLoadEvent.cs
new file mode 100644
index 00000000..2def3a90
--- /dev/null
+++ b/PathfinderAPI/Event/Options/CustomOptionsLoadEvent.cs
@@ -0,0 +1,6 @@
+namespace Pathfinder.Event.Options;
+
+public class CustomOptionsLoadEvent : PathfinderEvent
+{
+    public CustomOptionsLoadEvent() { }
+}
\ No newline at end of file
diff --git a/PathfinderAPI/Meta/Load/HacknetPluginExtensions.cs b/PathfinderAPI/Meta/Load/HacknetPluginExtensions.cs
index ff5949ca..4dba1d90 100644
--- a/PathfinderAPI/Meta/Load/HacknetPluginExtensions.cs
+++ b/PathfinderAPI/Meta/Load/HacknetPluginExtensions.cs
@@ -6,13 +6,13 @@ public static class HacknetPluginExtensions
 {
     public static string GetOptionsTag(this HacknetPlugin plugin)
     {
-        if(!OptionsTabAttribute.pluginToOptionsTag.TryGetValue(plugin, out var tag))
+        if(!OptionsTabAttribute.pluginToOptTabAttribute.TryGetValue(plugin, out var attr))
             return null;
-        return tag;
+        return attr.TabName;
     }
 
     public static bool HasOptionsTag(this HacknetPlugin plugin)
     {
-        return OptionsTabAttribute.pluginToOptionsTag.ContainsKey(plugin);
+        return OptionsTabAttribute.pluginToOptTabAttribute.ContainsKey(plugin);
     }
 }
\ No newline at end of file
diff --git a/PathfinderAPI/Meta/Load/OptionAttribute.cs b/PathfinderAPI/Meta/Load/OptionAttribute.cs
index 3c594577..66a0d23a 100644
--- a/PathfinderAPI/Meta/Load/OptionAttribute.cs
+++ b/PathfinderAPI/Meta/Load/OptionAttribute.cs
@@ -7,48 +7,55 @@ namespace Pathfinder.Meta.Load;
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public class OptionAttribute : BaseAttribute
 {
-    public string Tag { get; set; }
+    [Obsolete("Use TabName")]
+    public string Tag { get => TabName; set => TabName = value; }
+    public string TabName { get; set; }
+    public string TabId { get; set; }
 
-    public OptionAttribute(string tag = null)
+    public OptionAttribute(string tag = null, string tabId = null)
     {
-        this.Tag = tag;
+        TabName = tag;
+        TabId = tabId;
     }
 
     public OptionAttribute(Type pluginType)
     {
-        this.Tag = pluginType.GetCustomAttribute<OptionsTabAttribute>()?.Tag;
+        var tabAttr = pluginType.GetCustomAttribute<OptionsTabAttribute>();
+        TabName = tabAttr.TabName;
+        TabId = tabAttr.TabId;
     }
 
     protected internal override void CallOn(HacknetPlugin plugin, MemberInfo targettedInfo)
     {
-        if(Tag == null)
+        if(TabName == null)
         {
-            Tag = plugin.GetOptionsTag();
-            if(Tag == null)
+            if(!OptionsTabAttribute.pluginToOptTabAttribute.TryGetValue(plugin, out var tab))
                 throw new InvalidOperationException($"Could not find Pathfinder.Meta.Load.OptionsTabAttribute for {targettedInfo.DeclaringType.FullName}");
+            TabName = tab.TabName;
+            TabId = tab.TabId;
         }
 
         if(targettedInfo.DeclaringType != plugin.GetType())
             throw new InvalidOperationException($"Pathfinder.Meta.Load.OptionAttribute is only valid in a class derived from BepInEx.Hacknet.HacknetPlugin");
 
-        Option option = null;
+        IPluginOption option = null;
         switch(targettedInfo)
         {
             case PropertyInfo propertyInfo:
-                if(!propertyInfo.PropertyType.IsSubclassOf(typeof(Option)))
-                    throw new InvalidOperationException($"Property {propertyInfo.Name}'s type does not derive from Pathfinder.Options.Option");
-                option = (Option)(propertyInfo.GetGetMethod()?.Invoke(plugin, null));
+                if(!typeof(IPluginOption).IsAssignableFrom(propertyInfo.PropertyType))
+                    throw new InvalidOperationException($"Property {propertyInfo.Name}'s type does not derive from Pathfinder.Options.IPluginOption");
+                option = (IPluginOption)(propertyInfo.GetGetMethod()?.Invoke(plugin, null));
                 break;
             case FieldInfo fieldInfo:
-                if(!fieldInfo.FieldType.IsSubclassOf(typeof(Option)))
-                    throw new InvalidOperationException($"Field {fieldInfo.Name}'s type does not derive from Pathfinder.Options.Option");
-                option = (Option)fieldInfo.GetValue(plugin);
+                if(!typeof(IPluginOption).IsAssignableFrom(fieldInfo.FieldType))
+                    throw new InvalidOperationException($"Field {fieldInfo.Name}'s type does not derive from Pathfinder.Options.IPluginOption");
+                option = (IPluginOption)fieldInfo.GetValue(plugin);
                 break;
         }
 
         if(option == null)
-            throw new InvalidOperationException($"Option not set to a default value, Option members should be set before HacknetPlugin.Load() is called");
+            throw new InvalidOperationException($"IPluginOption not set to a default value, IPluginOption members should be set before HacknetPlugin.Load() is called");
 
-        OptionsManager.AddOption(Tag, option);
+        OptionsManager.GetOrRegisterTab(plugin, TabName, TabId).AddOption(option);
     }
 }
\ No newline at end of file
diff --git a/PathfinderAPI/Meta/Load/OptionsTabAttribute.cs b/PathfinderAPI/Meta/Load/OptionsTabAttribute.cs
index e941e0e9..aac27212 100644
--- a/PathfinderAPI/Meta/Load/OptionsTabAttribute.cs
+++ b/PathfinderAPI/Meta/Load/OptionsTabAttribute.cs
@@ -6,17 +6,21 @@ namespace Pathfinder.Meta.Load;
 [AttributeUsage(AttributeTargets.Class)]
 public class OptionsTabAttribute : BaseAttribute
 {
-    internal static readonly Dictionary<HacknetPlugin, string> pluginToOptionsTag = new Dictionary<HacknetPlugin, string>();
+    internal static readonly Dictionary<HacknetPlugin, OptionsTabAttribute> pluginToOptTabAttribute = new Dictionary<HacknetPlugin, OptionsTabAttribute>();
 
-    public string Tag { get; }
+    [Obsolete("Use TabName")]
+    public string Tag { get => TabName; set => TabName = value; }
+    public string TabName { get; set; }
+    public string TabId { get; set; }
 
-    public OptionsTabAttribute(string tag)
+    public OptionsTabAttribute(string tag, string tabId = null)
     {
-        this.Tag = tag;
+        TabName = tag;
+        TabId = tabId;
     }
 
     protected internal override void CallOn(HacknetPlugin plugin, MemberInfo targettedInfo)
     {
-        pluginToOptionsTag.Add(plugin, Tag);
+        pluginToOptTabAttribute.Add(plugin, this);
     }
 }
\ No newline at end of file
diff --git a/PathfinderAPI/MiscPatches.cs b/PathfinderAPI/MiscPatches.cs
index 1d58d7cc..b5df43e5 100644
--- a/PathfinderAPI/MiscPatches.cs
+++ b/PathfinderAPI/MiscPatches.cs
@@ -51,7 +51,7 @@ private static void NoSteamErrorMessageIL(ILContext il)
         c.RemoveRange(3);
 
         c.Emit(OpCodes.Ldsfld, AccessTools.Field(typeof(PathfinderOptions), nameof(PathfinderOptions.DisableSteamCloudError)));
-        c.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(OptionCheckbox), nameof(OptionCheckbox.Value)));
+        c.Emit(OpCodes.Callvirt, AccessTools.Method(typeof(PluginCheckbox), $"get_{nameof(PluginCheckbox.Value)}"));
 
         c.GotoNext(MoveType.Before, x => x.MatchLdstr(out _));
         c.Next.Operand = "Steam Cloud saving disabled by Pathfinder";
diff --git a/PathfinderAPI/Options/BasePluginOption.cs b/PathfinderAPI/Options/BasePluginOption.cs
new file mode 100644
index 00000000..8890c5ad
--- /dev/null
+++ b/PathfinderAPI/Options/BasePluginOption.cs
@@ -0,0 +1,135 @@
+using BepInEx.Configuration;
+using Pathfinder.GUI;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Hacknet;
+
+namespace Pathfinder.Options;
+
+public interface IPluginOption
+{
+    PluginOptionTab Tab { get; set; }
+    public ConfigEntryBase ConfigEntry { get; }
+    string Id { get; }
+    Rectangle Rectangle { get; set; }
+    Vector2 Size { get; }
+    bool TrySetOffset(Vector2 offset);
+    void LoadContent();
+    void OnDraw(GameTime gameTime);
+}
+
+public abstract class BasePluginOption<ValueT> : IPluginOption
+{
+    public PluginOptionTab Tab { get; set; }
+    public virtual ConfigEntryBase ConfigEntry => TypedConfigEntry;
+    public virtual ConfigEntry<ValueT> TypedConfigEntry { get; protected set; }
+
+    public Rectangle Rectangle { get; set; }
+    public int HacknetGuiId { get; private set; }
+
+    public virtual ValueT Value
+    {
+        get
+        {
+            if(TypedConfigEntry == null)
+            {
+                if(Tab.Plugin.Config.TryGetEntry<ValueT>(Tab.Id, Id, out var entry))
+                    TypedConfigEntry = entry;
+                else
+                    TypedConfigEntry = Tab.Plugin.Config.Bind<ValueT>(Tab.Id, Id, DefaultValue, ConfigDescription ?? "");
+            }
+            return TypedConfigEntry.Value;
+        }
+        set
+        {
+            if(TypedConfigEntry == null)
+                TypedConfigEntry = Tab.Plugin.Config.Bind<ValueT>(Tab.Id, Id, DefaultValue, ConfigDescription ?? "");
+            TypedConfigEntry.Value = value;
+        }
+    }
+    public virtual ValueT DefaultValue { get; set; } = default;
+    public virtual string HeaderText { get; protected set; }
+    public virtual string DescriptionText { get; protected set; }
+    public virtual string ConfigDescription { get; protected set; }
+    public virtual string Id { get; }
+
+    public Color HeaderColor { get; set; } = Color.White;
+    public Color DescriptionColor { get; set; } = Color.White;
+
+    public SpriteFont HeaderFont { get; set; }
+    public SpriteFont DescriptionFont { get; set; }
+
+    public Vector2 HeaderTextSize => HeaderFont.MeasureString(HeaderText);
+    public Vector2 DescriptionTextSize => DescriptionFont.MeasureString(DescriptionText);
+
+    public virtual Vector2 Position => new Vector2(Rectangle.X + Offset.X, Rectangle.Y + Offset.Y);
+    public virtual Vector2 Offset { get; set; }
+
+    public Vector2 Size
+    {
+        get
+        {
+            var minsize = MinSize;
+            return new Vector2(Math.Max(Rectangle.Width, minsize.X), Math.Max(Rectangle.Height, minsize.Y));
+        }
+    }
+    public virtual Vector2 MinSize
+    {
+        get
+        {
+            var headerSize = HeaderTextSize;
+            var descSize = DescriptionTextSize;
+            return new Vector2(Math.Max(headerSize.X, descSize.X), headerSize.Y + descSize.Y);
+        }
+    }
+
+    protected static string MakeIdFrom(string name, string id)
+        => id ?? string.Concat(name.Where(c => !char.IsWhiteSpace(c) && c != '='));
+
+    protected BasePluginOption(string headerText, string descriptionText = null, ValueT defaultValue = default, string configDesc = null, string id = null)
+    {
+        HeaderText = headerText;
+        DescriptionText = descriptionText;
+        DefaultValue = defaultValue;
+        ConfigDescription = configDesc;
+        Id = MakeIdFrom(headerText, id);
+    }
+
+    public bool TrySetOffset(Vector2 offset)
+    {
+        Offset = offset;
+        return Offset == offset;
+    }
+
+    public bool TrySetHeaderText(string text)
+    {
+        HeaderText = text;
+        return HeaderText == text;
+    }
+
+    public bool TrySetDescriptionText(string text)
+    {
+        DescriptionText = text;
+        return DescriptionText == text;
+    }
+
+    public bool TrySetConfigDescription(string desc)
+    {
+        ConfigDescription = desc;
+        return ConfigDescription == desc;
+    }
+
+    public virtual void LoadContent()
+    {
+        HacknetGuiId = PFButton.GetNextID();
+        HeaderFont ??= GuiData.font;
+        DescriptionFont ??= GuiData.smallfont;
+    }
+
+    public abstract void OnDraw(GameTime gameTime);
+
+    protected void DrawString(Vector2 pos, string text, Color? color = null, SpriteFont font = null)
+    {
+        Tab.Batch.DrawString(font ?? GuiData.font, text, pos, color ?? Color.White);
+    }
+}
\ No newline at end of file
diff --git a/PathfinderAPI/Options/Options.cs b/PathfinderAPI/Options/Options.cs
index 95c6d630..68b3ce88 100644
--- a/PathfinderAPI/Options/Options.cs
+++ b/PathfinderAPI/Options/Options.cs
@@ -1,9 +1,12 @@
+#pragma warning disable 618
+
 using Hacknet.Gui;
 using Microsoft.Xna.Framework;
 using Pathfinder.GUI;
 
 namespace Pathfinder.Options;
 
+[Obsolete("Use BasePluginOption")]
 public abstract class Option
 {
     public string Name;
@@ -22,6 +25,7 @@ public Option(string name, string description="")
     public abstract void Draw(int x, int y);
 }
 
+[Obsolete("Use PluginCheckbox")]
 public class OptionCheckbox : Option
 {
     public bool Value;
diff --git a/PathfinderAPI/Options/OptionsManager.cs b/PathfinderAPI/Options/OptionsManager.cs
index 871861d5..e1a4f193 100644
--- a/PathfinderAPI/Options/OptionsManager.cs
+++ b/PathfinderAPI/Options/OptionsManager.cs
@@ -1,13 +1,135 @@
-using Pathfinder.GUI;
+using BepInEx.Configuration;
+using HarmonyLib;
+using Hacknet;
+using BepInEx.Hacknet;
+using System.Collections.ObjectModel;
+using BepInEx;
 
 namespace Pathfinder.Options;
 
+[HarmonyPatch]
 public static class OptionsManager
 {
+    [Obsolete("Use PluginTabs")]
     public readonly static Dictionary<string, OptionsTab> Tabs = new Dictionary<string, OptionsTab>();
+    private readonly static Dictionary<string, PluginOptionTab> _PluginTabs = new Dictionary<string, PluginOptionTab>();
+    private static ReadOnlyDictionary<string, PluginOptionTab> _readonlyPluginTabs;
+    public static ReadOnlyDictionary<string, PluginOptionTab> PluginTabs => _readonlyPluginTabs ??= new ReadOnlyDictionary<string, PluginOptionTab>(_PluginTabs);
 
-    static OptionsManager() { }
+    public const string PluginOptionTabIdPostfix = "Options";
+    public static (string Name, string Id) MakeTabDataFrom(HacknetPlugin plugin, string tabName)
+    {
+        var metadata = MetadataHelper.GetMetadata(plugin);
+        var pair = HacknetChainloader.Instance.Plugins.First(dataPair => dataPair.Value.Metadata.GUID == metadata.GUID);
+        return (tabName ?? pair.Value.Metadata.Name, pair.Value.Metadata.GUID+PluginOptionTabIdPostfix);
+    }
+
+    public static string GetIdFrom(HacknetPlugin plugin, string name, string id = null)
+        => id ?? (MakeTabDataFrom(plugin, name).Id);
+
+    public static bool TryGetTab<TabT>(string tabId, out TabT tab)
+        where TabT : PluginOptionTab
+    {
+        tab = null;
+        if(_PluginTabs.TryGetValue(tabId, out var possibleTab))
+            tab = possibleTab as TabT;
+        return tab != null;
+    }
+
+    public static PluginOptionTab GetTab<TabT>(string tabId, bool shouldThrow = false)
+        where TabT : PluginOptionTab
+    {
+        if(!TryGetTab(tabId, out TabT tab))
+            return tab;
+        if(shouldThrow)
+            throw new KeyNotFoundException($"The given key '{tabId}' was not present in the dictionary.");
+        return null;
+    }
+
+    public static PluginOptionTab RegisterTab(HacknetPlugin plugin = null, string tabName = null, string tabId = null)
+    {
+        var pair = MakeTabDataFrom(plugin, tabName);
+        tabName ??= pair.Name;
+        tabId ??= pair.Id;
+        if(GetTab<PluginOptionTab>(GetIdFrom(plugin, tabName, tabId)) != null)
+            ThrowDuplicateIdAttempt(tabId);
+        return RegisterTab(plugin, new PluginOptionTab(plugin, tabName, tabId));
+    }
+
+    public static TabT RegisterTab<TabT>(HacknetPlugin plugin, TabT tab)
+        where TabT : PluginOptionTab
+    {
+        if(GetTab<TabT>(tab.Id) != null)
+            ThrowDuplicateIdAttempt(tab.Id);
+        tab.Plugin = plugin;
+        _PluginTabs[tab.Id] = tab;
+        return tab;
+    }
+
+    public static TabT RegisterTab<TabT>(HacknetPlugin plugin)
+        where TabT : PluginOptionTab, new()
+        => RegisterTab<TabT>(plugin, new TabT());
+
+    public static PluginOptionTab GetOrRegisterTab(HacknetPlugin plugin, string tabName = null)
+    {
+        var pair = MakeTabDataFrom(plugin, tabName);
+        if(!TryGetTab(GetIdFrom(plugin, pair.Name, pair.Id), out PluginOptionTab tab))
+            tab = RegisterTab(plugin, pair.Name, pair.Id);
+        return tab;
+    }
+
+    public static PluginOptionTab GetOrRegisterTab(HacknetPlugin plugin, string tabName, string tabId = null)
+    {
+        if(!TryGetTab(GetIdFrom(plugin, tabName, tabId), out PluginOptionTab tab))
+            tab = RegisterTab(plugin, tabName, tabId);
+        return tab;
+    }
+
+    public static TabT GetOrRegisterTab<TabT>(HacknetPlugin plugin, string tabName, string tabId, Func<TabT> genFunc)
+        where TabT : PluginOptionTab
+    {
+        if(!TryGetTab(GetIdFrom(plugin, tabName, tabId), out TabT tab))
+            tab = RegisterTab(plugin, genFunc());
+        return tab;
+    }
+
+    public static TabT GetOrRegisterTab<TabT>(HacknetPlugin plugin, Func<TabT> genFunc)
+        where TabT : PluginOptionTab
+    {
+        var pair = MakeTabDataFrom(plugin, null);
+        return GetOrRegisterTab(plugin, pair.Name, pair.Id, genFunc);
+    }
+
+    public static T RegisterOption<T>(HacknetPlugin plugin, string tabName, string tabId, T option)
+        where T : IPluginOption
+    {
+        GetOrRegisterTab(plugin, tabName, tabId).AddOption(option);
+        return option;
+    }
+
+    public static T RegisterOption<T>(HacknetPlugin plugin, string tabName, T option)
+        where T : IPluginOption
+    {
+        return RegisterOption(plugin, tabName, null, option);
+    }
+
+    public static T RegisterOption<T>(HacknetPlugin plugin, string tabName, string tabId = null)
+        where T : IPluginOption, new()
+    {
+        return RegisterOption(plugin, tabName, tabId, (T)Activator.CreateInstance(typeof(T)));
+    }
+
+    public static void OnConfigSave(string tabId, ConfigFile config)
+    {
+        _PluginTabs.GetValueSafe(tabId)?.Save();
+    }
+
+    public static void OnConfigLoad(string tabId, ConfigFile config)
+    {
+        _PluginTabs.GetValueSafe(tabId)?.Load();
+    }
 
+    [Obsolete("Use RegisterOption or PluginOptionTab.AddOption")]
     public static void AddOption(string tag, Option opt)
     {
         if (!Tabs.TryGetValue(tag, out var tab)) {
@@ -16,17 +138,16 @@ public static void AddOption(string tag, Option opt)
         }
         tab.Options.Add(opt);
     }
-}
-
-public class OptionsTab
-{
-    public string Name;
 
-    public List<Option> Options = new List<Option>();
 
-    internal int ButtonID = PFButton.GetNextID();
+    private static InvalidOperationException ThrowDuplicateIdAttempt(string id)
+        => throw new InvalidOperationException($"Can not register tab '{id}', tab id was already registered.");
 
-    public OptionsTab(string name) {
-        Name = name;
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(Game1), nameof(Game1.LoadContent))]
+    private static void OnPostGame1LoadContent(Game1 __instance)
+    {
+        foreach(var tab in _PluginTabs)
+            tab.Value.LoadContent();
     }
-}
\ No newline at end of file
+}
diff --git a/PathfinderAPI/Options/OptionsTab.cs b/PathfinderAPI/Options/OptionsTab.cs
new file mode 100644
index 00000000..9ad5a214
--- /dev/null
+++ b/PathfinderAPI/Options/OptionsTab.cs
@@ -0,0 +1,17 @@
+using Pathfinder.GUI;
+
+namespace Pathfinder.Options;
+
+[Obsolete("Use PluginOptionTab")]
+public class OptionsTab
+{
+    public string Name;
+
+    public List<Option> Options = new List<Option>();
+
+    internal int ButtonID = PFButton.GetNextID();
+
+    public OptionsTab(string name) {
+        Name = name;
+    }
+}
diff --git a/PathfinderAPI/Options/PathfinderOptions.cs b/PathfinderAPI/Options/PathfinderOptions.cs
index 35640124..66d16e40 100644
--- a/PathfinderAPI/Options/PathfinderOptions.cs
+++ b/PathfinderAPI/Options/PathfinderOptions.cs
@@ -1,42 +1,18 @@
-using Pathfinder.Event;
-using Pathfinder.Event.Options;
-
 namespace Pathfinder.Options;
 
 internal static class PathfinderOptions
 {
-    private const string OPTION_TAG = "Pathfinder";
-
-    internal static OptionCheckbox PreloadAllThemes = new OptionCheckbox("Preload All Themes",
+    internal static PluginCheckbox PreloadAllThemes = new PluginCheckbox("Preload All Themes",
         "Preload all themes at extension start\nimproves performance at the cost of memory");
 
-    internal static OptionCheckbox DisableSteamCloudError = new OptionCheckbox("Disable Steam Cloud Message", 
+    internal static PluginCheckbox DisableSteamCloudError = new PluginCheckbox("Disable Steam Cloud Message",
         "Disables the Steam Cloud disabled message on the main menu");
-        
+
     [Util.Initialize]
     static void Initialize()
     {
-        OptionsManager.AddOption(OPTION_TAG, PreloadAllThemes);
-        OptionsManager.AddOption(OPTION_TAG, DisableSteamCloudError);
-        EventManager<CustomOptionsSaveEvent>.AddHandler(onOptionsSave);
-        initConfig();
-    }
-
-    private static void initConfig()
-    {
-        var preloadAllThemesDef = PathfinderAPIPlugin.Config.Bind<bool>("PathfinderAPI", "PreloadAllThemes", false);
-        var disableSteamCloudDef = PathfinderAPIPlugin.Config.Bind<bool>("PathfinderAPI", "DisableSteamCloudMessage", false);
-        PreloadAllThemes.Value = preloadAllThemesDef.Value;
-        DisableSteamCloudError.Value = disableSteamCloudDef.Value;
-    }
-
-    private static void onOptionsSave(CustomOptionsSaveEvent _)
-    {
-        PathfinderAPIPlugin.Config.TryGetEntry<bool>("PathfinderAPI", "PreloadAllThemes", out var preloadAllThemesVal);
-        PathfinderAPIPlugin.Config.TryGetEntry<bool>("PathfinderAPI", "DisableSteamCloudMessage", out var disableCloudMessage);
-            
-        preloadAllThemesVal.Value = PreloadAllThemes.Value;
-        disableCloudMessage.Value = DisableSteamCloudError.Value;
-        PathfinderAPIPlugin.Config.Save();
+        OptionsManager.GetOrRegisterTab(PathfinderAPIPlugin.Instance, "Pathfinder")
+        .AddOption(PreloadAllThemes)
+        .AddOption(DisableSteamCloudError);
     }
-}
\ No newline at end of file
+}
diff --git a/PathfinderAPI/Options/PathfinderOptionsMenu.cs b/PathfinderAPI/Options/PathfinderOptionsMenu.cs
index a9645cda..1474a65b 100644
--- a/PathfinderAPI/Options/PathfinderOptionsMenu.cs
+++ b/PathfinderAPI/Options/PathfinderOptionsMenu.cs
@@ -13,7 +13,38 @@ namespace Pathfinder.Options;
 internal static class PathfinderOptionsMenu
 {
     private static bool isInPathfinderMenu = false;
-    private static string currentTabName = null;
+    private static bool _canReloadMenu = true;
+    public static string CurrentTabId { get; private set; } = null;
+
+    public static void SetCurrentTab(string tabId)
+    {
+        #pragma warning disable 618
+        if(OptionsManager.PluginTabs.ContainsKey(tabId) || OptionsManager.Tabs.ContainsKey(tabId))
+        {
+            CurrentTabId = tabId;
+            return;
+        }
+        throw new InvalidOperationException($"Tab {tabId} not found in {typeof(OptionsManager).FullName}.{nameof(OptionsManager.PluginTabs)} or {typeof(OptionsManager).FullName}.{nameof(OptionsManager.Tabs)}");
+        #pragma warning restore 618
+    }
+
+    public static PluginOptionTab SetCurrentTab(PluginOptionTab tab)
+    {
+        if(!OptionsManager.PluginTabs.ContainsKey(tab.Id))
+            throw new InvalidOperationException($"Tab {tab.Id} not found in {typeof(OptionsManager).FullName}.{nameof(OptionsManager.PluginTabs)}");
+        CurrentTabId = tab.Id;
+        return tab;
+    }
+
+    #pragma warning disable 618
+    public static OptionsTab SetCurrentTab(OptionsTab tab)
+    {
+        if(!OptionsManager.Tabs.TryGetValue(tab.Name, out var newTab) || tab != newTab)
+            throw new InvalidOperationException($"Tab {tab.Name} not found in {typeof(OptionsManager).FullName}.{nameof(OptionsManager.Tabs)}");
+        CurrentTabId = tab.Name;
+        return tab;
+    }
+    #pragma warning restore 618
 
     private static PFButton ReturnButton = new PFButton(10, 10, 220, 54, "Back to Options", Color.Yellow);
 
@@ -21,42 +52,60 @@ internal static class PathfinderOptionsMenu
     [HarmonyPatch(typeof(OptionsMenu), nameof(OptionsMenu.Draw))]
     internal static bool Draw(ref OptionsMenu __instance, GameTime gameTime)
     {
-        if (!isInPathfinderMenu) 
+        if (!isInPathfinderMenu)
             return true;
-        
+
+        if(_canReloadMenu)
+        {
+            var loadEvent = new CustomOptionsLoadEvent();
+            EventManager<CustomOptionsLoadEvent>.InvokeAll(loadEvent);
+            _canReloadMenu = false;
+        }
+
         PostProcessor.begin();
         GuiData.startDraw();
         PatternDrawer.draw(new Rectangle(0, 0, __instance.ScreenManager.GraphicsDevice.Viewport.Width, __instance.ScreenManager.GraphicsDevice.Viewport.Height), 0.5f, Color.Black, new Color(2, 2, 2), GuiData.spriteBatch);
-            
+
         if (ReturnButton.Do())
         {
-            currentTabName = null;
+            CurrentTabId = null;
             isInPathfinderMenu = false;
             GuiData.endDraw();
             PostProcessor.end();
             var saveEvent = new CustomOptionsSaveEvent();
             EventManager<CustomOptionsSaveEvent>.InvokeAll(saveEvent);
+            _canReloadMenu = true;
             return false;
         }
 
+        #pragma warning disable 618
         var tabs = OptionsManager.Tabs;
-            
-        int tabX = 10;
+        #pragma warning restore 618
+
+        int tabX = 10, tabY = 70;
+
+        foreach (var pair in OptionsManager.PluginTabs)
+        {
+            var tab = pair.Value;
+            if(tab.TrySetButtonOffset(new Point(tabX, tabY)))
+                tabX += 10 + tab.ButtonRect.Width;
+            tab.OnDraw(gameTime);
+        }
 
         foreach (var tab in tabs.Values)
         {
-            if (currentTabName == null)
-                currentTabName = tab.Name;
-            var active = currentTabName == tab.Name;
+            if (CurrentTabId == null)
+                CurrentTabId = tab.Name;
+            var active = CurrentTabId == tab.Name;
             // Display tab button
-            if (Button.doButton(tab.ButtonID, tabX, 70, 128, 20, tab.Name, active ? Color.Green : Color.Gray))
+            if (Button.doButton(tab.ButtonID, tabX, tabY, 128, 20, tab.Name, active ? Color.Green : Color.Gray))
             {
-                currentTabName = tab.Name;
+                CurrentTabId = tab.Name;
                 break;
             }
             tabX += 128 + 10;
 
-            if (currentTabName != tab.Name)
+            if (CurrentTabId != tab.Name)
                 continue;
 
             // Display options
@@ -69,7 +118,7 @@ internal static bool Draw(ref OptionsMenu __instance, GameTime gameTime)
         }
 
         GuiData.endDraw();
-        PostProcessor.end();
+			PostProcessor.end();
         return false;
     }
 
@@ -80,7 +129,7 @@ internal static bool Draw(ref OptionsMenu __instance, GameTime gameTime)
     internal static void BeforeEndDrawOptions(ILContext il)
     {
         ILCursor c = new ILCursor(il);
-            
+
         c.GotoNext(MoveType.AfterLabel, x => x.MatchCallOrCallvirt(AccessTools.Method(typeof(GuiData), nameof(GuiData.endDraw))));
 
         c.EmitDelegate<System.Action>(() =>
@@ -91,4 +140,4 @@ internal static void BeforeEndDrawOptions(ILContext il)
             }
         });
     }
-}
\ No newline at end of file
+}
diff --git a/PathfinderAPI/Options/PluginCheckbox.cs b/PathfinderAPI/Options/PluginCheckbox.cs
new file mode 100644
index 00000000..4f3e2bec
--- /dev/null
+++ b/PathfinderAPI/Options/PluginCheckbox.cs
@@ -0,0 +1,34 @@
+using BepInEx.Configuration;
+using Hacknet;
+using Hacknet.Gui;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Pathfinder.Options;
+
+public class PluginCheckbox : BasePluginOption<bool>
+{
+    public Color SelectedColor { get; set; } = Color.White;
+
+    public PluginCheckbox(string headerText, string descriptionText = null, bool defaultValue = false, string configDesc = null, string id = null)
+        : base(headerText, descriptionText, defaultValue, configDesc, id)
+    {
+    }
+
+    public override Vector2 MinSize
+    {
+        get
+        {
+            var minsize = base.MinSize;
+            minsize.X = Math.Max(HeaderTextSize.X, DescriptionTextSize.X + 32);
+            return minsize;
+        }
+    }
+
+    public override void OnDraw(GameTime gameTime)
+    {
+        DrawString(Position, HeaderText, HeaderColor, HeaderFont);
+        Value = CheckBox.doCheckBox(HacknetGuiId, (int)Position.X, (int)Position.Y + 34, Value, SelectedColor);
+        DrawString(Position + new Vector2(32, 30), DescriptionText, DescriptionColor, DescriptionFont);
+    }
+}
diff --git a/PathfinderAPI/Options/PluginOptionTab.cs b/PathfinderAPI/Options/PluginOptionTab.cs
new file mode 100644
index 00000000..253523bf
--- /dev/null
+++ b/PathfinderAPI/Options/PluginOptionTab.cs
@@ -0,0 +1,146 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using BepInEx.Configuration;
+using BepInEx.Hacknet;
+using Hacknet;
+using Hacknet.Gui;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Pathfinder.GUI;
+
+namespace Pathfinder.Options;
+
+public class PluginOptionTab : IReadOnlyDictionary<string, IPluginOption>
+{
+    private IDictionary<string, IPluginOption> options = new Dictionary<string, IPluginOption>();
+    public HacknetPlugin Plugin { get; internal set; }
+    public string Id { get; private set; }
+    public string TabName { get; private set; }
+
+    public SpriteBatch Batch { get; internal set; }
+    public int HacknetGuiId { get; }
+    public bool IsLoaded { get; internal set; }
+    public Rectangle ButtonRect { get; set; } = new Rectangle
+    {
+        X = 0,
+        Y = 0,
+        Width = 128,
+        Height = 20
+    };
+
+    public Point ButtonPosition => ButtonRect.Location + ButtonOffset;
+    public Point ButtonOffset { get; protected set; }
+    public virtual bool TrySetButtonOffset(Point offset)
+    {
+        ButtonOffset = offset;
+        return ButtonOffset == offset;
+    }
+
+    public PluginOptionTab(HacknetPlugin plugin, string tabName, string tabId = null)
+    {
+        Plugin = plugin;
+        TabName = tabName;
+        Id = OptionsManager.GetIdFrom(plugin, tabName, tabId);
+        HacknetGuiId = PFButton.GetNextID();
+    }
+
+    public int Count => options.Count;
+    public IEnumerable<string> Keys => options.Keys;
+    public IEnumerable<IPluginOption> Values => options.Values;
+    public IPluginOption this[string key] => options[key];
+
+    public PluginOptionTab AddOption(IPluginOption option)
+    {
+        options.Add(option.Id, option);
+        option.Tab = this;
+        if(IsLoaded)
+        {
+            option.LoadContent();
+        }
+        return this;
+    }
+
+    public IPluginOption GetOption(string id)
+    {
+        if(TryGetValue(id, out var result))
+            return result;
+        return null;
+    }
+
+    public OptionT GetOption<OptionT>(string id) where OptionT : IPluginOption
+        => (OptionT)GetOption(id);
+
+    public OptionT GetOptionAs<OptionT>(string id) where OptionT : class, IPluginOption
+        => GetOption(id) as OptionT;
+
+    public bool RemoveOption(IPluginOption option)
+    {
+        return RemoveOption(option.Id);
+    }
+
+    public bool RemoveOption(string id)
+    {
+        return options.Remove(id);
+    }
+
+    public virtual void LoadContent()
+    {
+        Batch = GuiData.spriteBatch;
+        foreach(var opt in options)
+            opt.Value.LoadContent();
+        IsLoaded = true;
+    }
+
+    public virtual void Save()
+    {
+        Plugin.Config.Save();
+    }
+
+    public virtual void Load()
+    {
+    }
+
+    public virtual void OnDraw(GameTime gameTime)
+    {
+        if (PathfinderOptionsMenu.CurrentTabId == null)
+            PathfinderOptionsMenu.SetCurrentTab(this);
+        var active = PathfinderOptionsMenu.CurrentTabId == Id;
+        // Display tab button
+        if (Button.doButton(HacknetGuiId,
+            ButtonPosition.X,
+            ButtonPosition.Y,
+            ButtonRect.Width,
+            ButtonRect.Height,
+            TabName,
+            active ? Color.Green : Color.Gray))
+        {
+            PathfinderOptionsMenu.SetCurrentTab(this);
+            return;
+        }
+
+        if (PathfinderOptionsMenu.CurrentTabId != Id)
+            return;
+
+        // Display options
+        int defOptionXPos = 80, defOptionYPos = 110;
+        foreach (var option in this)
+        {
+            if(option.Value.TrySetOffset(new Vector2(defOptionXPos, defOptionYPos)))
+                defOptionYPos += 10 + (int)option.Value.Size.Y;
+            option.Value.OnDraw(gameTime);
+        }
+    }
+
+    public IEnumerator<KeyValuePair<string, IPluginOption>> GetEnumerator()
+        => options.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public bool ContainsKey(string key)
+        => options.ContainsKey(key);
+
+    public bool TryGetValue(string key, out IPluginOption value)
+        => options.TryGetValue(key, out value);
+}
\ No newline at end of file
diff --git a/PathfinderAPI/Options/PluginSlider.cs b/PathfinderAPI/Options/PluginSlider.cs
new file mode 100644
index 00000000..9c224172
--- /dev/null
+++ b/PathfinderAPI/Options/PluginSlider.cs
@@ -0,0 +1,47 @@
+using Hacknet.Gui;
+using Microsoft.Xna.Framework;
+
+namespace Pathfinder.Options;
+
+public class PluginSlider : BasePluginOption<float>
+{
+    public int SliderRangeWidth { get; set; } = 50;
+    public int SliderHeight { get; set; } = 20;
+    public float MinimumValue { get; set; } = 0f;
+    public float MaximumValue { get; set; } = 1f;
+    public float StepSize { get; set; }
+
+    public PluginSlider(string headerText, string descriptionText = null, float defaultValue = 0f, float stepSize = 0f, string configDesc = null, string id = null)
+        : base(headerText, descriptionText, defaultValue, configDesc, id)
+    {
+        StepSize = stepSize;
+    }
+
+    public override Vector2 MinSize
+    {
+        get
+        {
+            var headerSize = HeaderTextSize;
+            var descSize = DescriptionTextSize;
+            return new Vector2(Math.Max(headerSize.X, descSize.X + SliderRangeWidth + 10), headerSize.Y + Math.Max(descSize.Y, SliderHeight + 9));
+        }
+    }
+
+    public override void OnDraw(GameTime gameTime)
+    {
+        DrawString(Position, HeaderText, HeaderColor, HeaderFont);
+        Value = SliderBar.doSliderBar(
+            HacknetGuiId,
+            (int)Position.X + 5,
+            (int)Position.Y + 45,
+            SliderRangeWidth,
+            SliderHeight,
+            MaximumValue,
+            MinimumValue,
+            Value,
+            StepSize
+        );
+
+        DrawString(Position + new Vector2(SliderRangeWidth + 10, 43), DescriptionText, DescriptionColor, DescriptionFont);
+    }
+}
\ No newline at end of file
diff --git a/PathfinderAPI/Options/PluginTextbox.cs b/PathfinderAPI/Options/PluginTextbox.cs
new file mode 100644
index 00000000..b4720a1e
--- /dev/null
+++ b/PathfinderAPI/Options/PluginTextbox.cs
@@ -0,0 +1,65 @@
+using Hacknet;
+using Hacknet.Gui;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Pathfinder.Options;
+
+public class PluginTextbox : BasePluginOption<string>
+{
+    public int TextBoxWidth { get; set; } = 20;
+    public int TextBoxLines { get; set; } = 1;
+    public SpriteFont TextBoxFont { get; set; }
+
+    public PluginTextbox(string headerText, string descriptionText = null, string defaultValue = null, string configDesc = null, string id = null)
+        : base(headerText, descriptionText, defaultValue ?? "", configDesc, id)
+    {
+        TextBoxWidth = 20;
+    }
+
+    public override void LoadContent()
+    {
+        TextBoxFont ??= GuiData.smallfont;
+        base.LoadContent();
+    }
+
+    public Vector2 TextBoxSize =>
+        TextBoxWidth > 0
+            ? TextBoxFont.MeasureString(new string('o', TextBoxWidth+1))
+            : (TextBoxWidth == 0
+                ? new Vector2(2, TextBoxFont.MeasureString("o").Y)
+                : TextBoxFont.MeasureString(Value) + new Vector2(5, 0)
+            );
+
+    public override Vector2 MinSize
+    {
+        get
+        {
+            var textBoxSize = TextBoxSize;
+            var headerSize = HeaderTextSize;
+            var descSize = DescriptionTextSize;
+            return new Vector2(
+                Math.Max(headerSize.X, descSize.X + textBoxSize.X + 10),
+                headerSize.Y + Math.Max(descSize.Y, textBoxSize.Y)// + (Math.Max(0, TextBoxLines - 1)) * 25)
+            );
+        }
+    }
+
+    public override void OnDraw(GameTime gameTime)
+    {
+        var textBoxSize = TextBoxSize;
+        DrawString(Position, HeaderText, HeaderColor, HeaderFont);
+        // Textbox doesn't support cliping the value to the width and doesn't take into account held down keys or special cases, like ctrl+backspace
+        Value = TextBox.doTextBox(
+            HacknetGuiId,
+            (int)Position.X,
+            (int)Position.Y + 34,
+            (int)textBoxSize.X,
+            TextBoxLines,
+            Value,
+            TextBoxFont
+        );
+
+        DrawString(Position + new Vector2(textBoxSize.X + 10, 32), DescriptionText, DescriptionColor, DescriptionFont);
+    }
+}
\ No newline at end of file
diff --git a/PathfinderAPI/PathfinderAPIPlugin.cs b/PathfinderAPI/PathfinderAPIPlugin.cs
index 372b7e69..c4f304ea 100644
--- a/PathfinderAPI/PathfinderAPIPlugin.cs
+++ b/PathfinderAPI/PathfinderAPIPlugin.cs
@@ -3,6 +3,9 @@
 using BepInEx.Hacknet;
 using HarmonyLib;
 using Pathfinder.Meta;
+using Pathfinder.Event;
+using Pathfinder.Event.Options;
+using Pathfinder.Options;
 using Pathfinder.Util;
 using System.Globalization;
 
@@ -15,6 +18,7 @@ namespace Pathfinder;
     "Pathfinder.Release.zip",
     "BepInEx/plugins/PathfinderAPI.dll"
 )]
+[HarmonyPatch]
 public class PathfinderAPIPlugin : HacknetPlugin
 {
     public const string ModGUID = "com.Pathfinder.API";
@@ -22,12 +26,14 @@ public class PathfinderAPIPlugin : HacknetPlugin
 
     new internal static Harmony HarmonyInstance;
     new internal static ConfigFile Config;
+    internal static PathfinderAPIPlugin Instance;
 
     public override bool Load()
     {
         PathfinderAPIPlugin.HarmonyInstance = base.HarmonyInstance;
         Logger.LogSource = base.Log;
         PathfinderAPIPlugin.Config = base.Config;
+        Instance = this;
 
         foreach (var initMethod in typeof(PathfinderAPIPlugin).Assembly.GetTypes().SelectMany(AccessTools.GetDeclaredMethods))
         {
@@ -39,6 +45,21 @@ public override bool Load()
 
         CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+
         return true;
     }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(HacknetPlugin), nameof(HacknetPlugin.PostLoad))]
+    private static void PrefixPostLoad(HacknetPlugin __instance)
+    {
+        var pluginInfo = MetadataHelper.GetMetadata(__instance);
+        OptionsManager.OnConfigLoad(pluginInfo.GUID, __instance.Config);
+        EventManager<CustomOptionsLoadEvent>.AddHandler(_ => OptionsManager.OnConfigLoad(pluginInfo.GUID, __instance.Config));
+        EventManager<CustomOptionsSaveEvent>.AddHandler(_ =>
+        {
+            OptionsManager.OnConfigSave(pluginInfo.GUID, __instance.Config);
+            __instance.Config.Save();
+        });
+    }
 }
\ No newline at end of file
diff --git a/PathfinderUpdater/MainMenuOverride.cs b/PathfinderUpdater/MainMenuOverride.cs
index dd94b81e..0a2045c8 100644
--- a/PathfinderUpdater/MainMenuOverride.cs
+++ b/PathfinderUpdater/MainMenuOverride.cs
@@ -2,46 +2,47 @@
 using Microsoft.Xna.Framework;
 using Pathfinder.Event;
 using Pathfinder.Event.Menu;
-using Pathfinder.Event.Options;
 using Pathfinder.GUI;
 using Pathfinder.Options;
-using HarmonyLib;
 
 namespace PathfinderUpdater;
 
-[HarmonyPatch]
 internal static class MainMenuOverride
 {
-    private static OptionCheckbox IsEnabledBox = new OptionCheckbox("Enabled", "Enables the auto updater", PathfinderUpdaterPlugin.IsEnabled.Value);
-    private static OptionCheckbox IncludePrerelease = new OptionCheckbox("IncludePreReleases", "Autoupdate to pre-releases", PathfinderUpdaterPlugin.EnablePreReleases.Value);
-    internal static OptionCheckbox NoRestartPrompt = new OptionCheckbox("NoRestartPrompt", "Prevents a restart prompt appearing");
-    private static PFButton CheckForUpdate = new PFButton(10, 10, 160, 30, "Check For Update", new Color(255, 255, 87));
+    internal static PluginOptionTab UpdaterTab;
+
+    internal static PluginCheckbox IsEnabledBox = new PluginCheckbox(
+        "Enabled",
+        "Enables the auto updater",
+        true,
+        "Enables or disables automatic updates for PathfinderAPI"
+    );
+    internal static PluginCheckbox IncludePrerelease = new PluginCheckbox(
+        "Include Pre Releases",
+        "Autoupdate to pre-releases",
+        configDesc: "Whether or not to automatically update to beta versions"
+    );
+    internal static PluginCheckbox NoRestartPrompt = new PluginCheckbox(
+        "No Restart Prompt",
+        "Prevents a restart prompt from appearing",
+        configDesc: "Whether ot not the restart prompt will appear when the update is finished"
+    );
+
+    private static PFButton CheckForUpdate = new PFButton(10, 10, 200, 30, "Check For Update", new Color(255, 255, 87));
     private const string UPDATE_STRING = "Update";
-    private static PFButton PerformUpdate = new PFButton(180, 10, 160, 30, UPDATE_STRING);
+    private static PFButton PerformUpdate = new PFButton(220, 10, 170, 30, UPDATE_STRING);
     private static RestartPopupScreen popupScreen;
 
-
-    [HarmonyPrefix]
-    [HarmonyPatch(typeof(Program), nameof(Program.Main))]
     internal static void PFAPILoaded()
     {
-        OptionsManager.AddOption("Updater", IsEnabledBox);
-        OptionsManager.AddOption("Updater", IncludePrerelease);
-        OptionsManager.AddOption("Updater", NoRestartPrompt);
-        EventManager<CustomOptionsSaveEvent>.AddHandler(OptionsSaved);
+        UpdaterTab = OptionsManager.GetOrRegisterTab(PathfinderUpdaterPlugin.Instance, "Updater")
+        .AddOption(IsEnabledBox)
+        .AddOption(IncludePrerelease)
+        .AddOption(NoRestartPrompt);
         EventManager<DrawMainMenuEvent>.AddHandler(OnDrawMainMenu);
         CanPerformUpdate = PathfinderUpdaterPlugin.NeedsUpdate;
     }
 
-    internal static void OptionsSaved(CustomOptionsSaveEvent args)
-    {
-        PathfinderUpdaterPlugin.IsEnabled.Value = IsEnabledBox.Value;
-        PathfinderUpdaterPlugin.EnablePreReleases.Value = IncludePrerelease.Value;
-        PathfinderUpdaterPlugin.NoRestartPrompt.Value = NoRestartPrompt.Value;
-        if(popupScreen != null)
-            popupScreen.NoRestartPrompt.Value = PathfinderUpdaterPlugin.NoRestartPrompt.Value;
-    }
-
     internal static async Task PerformCheckAndUpdateButtonAsync()
     {
         PerformUpdate.Text = UPDATE_STRING;
@@ -64,8 +65,8 @@ private static async Task PerformUpdateAndUpdateButtonAsync(MainMenu menu)
         PerformUpdate.Text = "Currently Updating...";
         await PathfinderUpdaterPlugin.PerformUpdateAsync();
         PerformUpdate.Text = oldText;
-        if(!menu.ScreenManager.screens.Contains(popupScreen) && !PathfinderUpdaterPlugin.NoRestartPrompt.Value)
-            menu.ScreenManager.AddScreen(popupScreen ??= new RestartPopupScreen());
+        if(!menu.ScreenManager.screens.Contains(popupScreen) && !NoRestartPrompt.Value)
+            menu.ScreenManager.AddScreen(popupScreen ??= new RestartPopupScreen(PathfinderUpdaterPlugin.Config));
         CanPerformUpdate = !menu.ScreenManager.screens.Contains(popupScreen);
         CanCheckForUpdate = couldCheckForUpdate;
     }
@@ -74,6 +75,8 @@ private static async Task PerformUpdateAndUpdateButtonAsync(MainMenu menu)
     private static bool CanPerformUpdate;
     internal static void OnDrawMainMenu(MainMenuEvent args)
     {
+        if(!IsEnabledBox.Value) return;
+
         if(CheckForUpdate.Do() && CanCheckForUpdate)
             Task.Run(async () => await PerformCheckAndUpdateButtonAsync());
 
diff --git a/PathfinderUpdater/PathfinderUpdaterPlugin.cs b/PathfinderUpdater/PathfinderUpdaterPlugin.cs
index 71eb798e..fabe2afd 100644
--- a/PathfinderUpdater/PathfinderUpdaterPlugin.cs
+++ b/PathfinderUpdater/PathfinderUpdaterPlugin.cs
@@ -26,15 +26,13 @@ public class PathfinderUpdaterPlugin : HacknetPlugin
 
     new internal static ConfigFile Config;
 
-    internal static ConfigEntry<bool> IsEnabled;
-    internal static ConfigEntry<bool> EnablePreReleases;
-    internal static ConfigEntry<bool> NoRestartPrompt;
     internal static ConfigEntry<string> AcceptedUpdate;
     internal static ConfigEntry<string> CurrentVersion;
 
     public static Version VersionToRequest = null;
     public static bool NeedsUpdate;
     internal static Updater PathfinderUpdater;
+    internal static PathfinderUpdaterPlugin Instance;
 
     public static readonly List<Updater> Updaters = new List<Updater>();
     private static readonly List<string> UpdaterWhitelistGuids = new List<string>
@@ -46,19 +44,19 @@ public class PathfinderUpdaterPlugin : HacknetPlugin
     public override bool Load()
     {
         Config = base.Config;
+        Instance = this;
 
-        IsEnabled = Config.Bind<bool>("AutoUpdater", "EnableAutoUpdates", true, "Enables or disables automatic updates for PathfinderAPI");
-        EnablePreReleases = Config.Bind<bool>("AutoUpdater", "UsePreReleases", false, "Whether or not to automatically update to beta versions");
         AcceptedUpdate = Config.Bind<string>("AutoUpdater", "LatestAcceptedUpdate", "", "Used internally to keep track of whether you accepted the update or not");
         CurrentVersion = Config.Bind<string>("AutoUpdater", "CurrentVersion", HacknetChainloader.VERSION,
             "Used internally to keep track of version.\nIf you want to skip updating to a version but keep the updater on, set this manually to the latest verison.");
-        NoRestartPrompt = Config.Bind<bool>("AutoUpdater", "NoRestartPrompt", false, "Whether ot not the restart prompt will automatically appear when the update is finished");
+
+        MainMenuOverride.PFAPILoaded();
 
         HarmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
         if (Type.GetType("Mono.Runtime") != null)
             HarmonyInstance.CreateClassProcessor(typeof(MonoRuntimeFixConfig), true).Patch();
 
-        if (!IsEnabled.Value)
+        if (!MainMenuOverride.IsEnabledBox.Value)
             return true;
 
         ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
@@ -68,12 +66,12 @@ public override bool Load()
 
     public override void PostLoad()
     {
-        if(!IsEnabled.Value) return;
+        if(!MainMenuOverride.IsEnabledBox.Value) return;
         if(!Updater.TryCreate(typeof(HacknetChainloader), out var chainLoaderUpdater, true))
             throw new InvalidOperationException("HacknetChainloader missing __UpdaterData");
         Updaters.Add(chainLoaderUpdater);
         chainLoaderUpdater.TryDeleteDllTempFile();
-        chainLoaderUpdater.IncludePrerelease = EnablePreReleases.Value;
+        chainLoaderUpdater.IncludePrerelease = MainMenuOverride.IncludePrerelease.Value;
         chainLoaderUpdater.CurrentVersion = CurrentVersion.Value;
 
         foreach(var kvPair in HacknetChainloader.Instance.Plugins)
@@ -84,7 +82,7 @@ public override void PostLoad()
                 continue;
             Updaters.Add(updater);
             updater.TryDeleteDllTempFile();
-            updater.IncludePrerelease = EnablePreReleases.Value;
+            updater.IncludePrerelease = MainMenuOverride.IncludePrerelease.Value;
             updater.CurrentVersion = CurrentVersion.Value;
             if(kvPair.Key == UpdaterWhitelistGuids[0])
                 PathfinderUpdater = updater;
diff --git a/PathfinderUpdater/RestartPopupScreen.cs b/PathfinderUpdater/RestartPopupScreen.cs
index dde4ed16..1951cf83 100644
--- a/PathfinderUpdater/RestartPopupScreen.cs
+++ b/PathfinderUpdater/RestartPopupScreen.cs
@@ -1,3 +1,4 @@
+using BepInEx.Configuration;
 using Hacknet;
 using Hacknet.Gui;
 using Microsoft.Xna.Framework;
@@ -8,13 +9,22 @@ namespace PathfinderUpdater;
 
 internal class RestartPopupScreen : GameScreen
 {
-    private PFButton AcceptVersion = new PFButton(500, 330, 120, 30, "Yes", new Color(102,255,127));
-    private PFButton DenyVersion = new PFButton(980, 330, 120, 30, "No", new Color(255,92,87));
-    internal OptionCheckbox NoRestartPrompt = new OptionCheckbox("", "Do not prompt for restart");
+    private PFButton AcceptVersion = new PFButton(450, 330, 120, 30, "Yes", new Color(102,255,127));
+    private PFButton DenyVersion = new PFButton(1030, 330, 120, 30, "No", new Color(255,92,87));
+    internal PluginCheckbox NoRestartPrompt = new PluginCheckbox("", "Do not prompt for restart", id: MainMenuOverride.NoRestartPrompt.Id);
+    private ConfigFile _config;
 
-    public RestartPopupScreen()
+    public RestartPopupScreen(ConfigFile config)
     {
+        _config = config;
         IsPopup = true;
+        NoRestartPrompt.Tab = MainMenuOverride.UpdaterTab;
+        NoRestartPrompt.TrySetOffset(new Vector2(595, 300));
+    }
+
+    public void SaveUiData()
+    {
+        NoRestartPrompt.ConfigEntry.ConfigFile.Save();
     }
 
     public override void HandleInput(InputState input)
@@ -29,7 +39,10 @@ public override void Draw(GameTime gameTime)
         ScreenManager.SpriteBatch.Draw(Utils.white, new Rectangle(0, 0, ScreenManager.SpriteBatch.GraphicsDevice.Viewport.Width, GuiData.spriteBatch.GraphicsDevice.Viewport.Height), new Color(0, 0, 0, 0.65f));
         ScreenManager.SpriteBatch.Draw(Utils.white, new Rectangle(400, 250, 800, 150), Color.Black);
         TextItem.doLabel(new Vector2(550, 260), $"Do you want to restart the game?", Color.White);
-        NoRestartPrompt.Draw(675, 300);
+        var prevRestartValue = NoRestartPrompt.Value;
+        NoRestartPrompt.OnDraw(gameTime);
+        if(NoRestartPrompt.Value != prevRestartValue)
+            SaveUiData();
         if(AcceptVersion.Do())
         {
             PathfinderUpdaterPlugin.RestartForUpdate();
@@ -39,11 +52,4 @@ public override void Draw(GameTime gameTime)
             ExitScreen();
         ScreenManager.SpriteBatch.End();
     }
-
-    public new void ExitScreen()
-    {
-        base.ExitScreen();
-        PathfinderUpdaterPlugin.NoRestartPrompt.Value = NoRestartPrompt.Value;
-        MainMenuOverride.NoRestartPrompt.Value = PathfinderUpdaterPlugin.NoRestartPrompt.Value;
-    }
 }
\ No newline at end of file