diff --git a/OWML.Common/IModHelper.cs b/OWML.Common/IModHelper.cs
index bc169e33..d25e1c2f 100644
--- a/OWML.Common/IModHelper.cs
+++ b/OWML.Common/IModHelper.cs
@@ -1,4 +1,6 @@
-namespace OWML.Common
+using OWML.Common.Menus;
+
+namespace OWML.Common
 {
     public interface IModHelper
     {
diff --git a/OWML.Common/IModMenu.cs b/OWML.Common/IModMenu.cs
deleted file mode 100644
index c3bb84b7..00000000
--- a/OWML.Common/IModMenu.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System.Collections.Generic;
-using UnityEngine.UI;
-
-namespace OWML.Common
-{
-    public interface IModMenu
-    {
-        List<Button> GetButtons();
-        Button AddButton(string title, int index);
-    }
-}
diff --git a/OWML.Common/IModMenus.cs b/OWML.Common/IModMenus.cs
deleted file mode 100644
index 76079f7b..00000000
--- a/OWML.Common/IModMenus.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-namespace OWML.Common
-{
-    public interface IModMenus
-    {
-        IModMenu MainMenu { get; }
-        IModPopupMenu PauseMenu { get; }
-    }
-}
diff --git a/OWML.Common/Menus/IModButton.cs b/OWML.Common/Menus/IModButton.cs
new file mode 100644
index 00000000..41eff159
--- /dev/null
+++ b/OWML.Common/Menus/IModButton.cs
@@ -0,0 +1,32 @@
+using System;
+using UnityEngine.UI;
+
+namespace OWML.Common.Menus
+{
+    public interface IModButton
+    {
+        event Action OnClick;
+        string Title { get; set; }
+        int Index { get; set; }
+        Button Button { get; }
+        void Initialize(IModMenu menu);
+
+        IModButton Copy();
+        IModButton Copy(string title);
+        IModButton Copy(int index);
+        IModButton Copy(string title, int index);
+
+        IModButton Duplicate();
+        IModButton Duplicate(string title);
+        IModButton Duplicate(int index);
+        IModButton Duplicate(string title, int index);
+
+        IModButton Replace();
+        IModButton Replace(string title);
+        IModButton Replace(int index);
+        IModButton Replace(string title, int index);
+
+        void Show();
+        void Hide();
+    }
+}
\ No newline at end of file
diff --git a/OWML.Common/Menus/IModMainMenu.cs b/OWML.Common/Menus/IModMainMenu.cs
new file mode 100644
index 00000000..8e9a5248
--- /dev/null
+++ b/OWML.Common/Menus/IModMainMenu.cs
@@ -0,0 +1,16 @@
+namespace OWML.Common.Menus
+{
+    public interface IModMainMenu : IModMenu
+    {
+        IModTabbedMenu OptionsMenu { get; }
+
+        IModButton ResumeExpeditionButton { get; }
+        IModButton NewExpeditionButton { get; }
+        IModButton OptionsButton { get; }
+        IModButton ViewCreditsButton { get; }
+        IModButton SwitchProfileButton { get; }
+        IModButton QuitButton { get; }
+
+        void Initialize(TitleScreenManager titleScreenManager);
+    }
+}
diff --git a/OWML.Common/Menus/IModMenu.cs b/OWML.Common/Menus/IModMenu.cs
new file mode 100644
index 00000000..d7b065b5
--- /dev/null
+++ b/OWML.Common/Menus/IModMenu.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.UI;
+
+namespace OWML.Common.Menus
+{
+    public interface IModMenu
+    {
+        event Action OnInit;
+
+        Menu Menu { get; }
+        List<IModButton> Buttons { get; }
+        IModButton GetButton(string title);
+        void AddButton(IModButton button);
+        void AddButton(IModButton button, int index);
+
+        [Obsolete("Use Buttons instead")]
+        List<Button> GetButtons();
+        [Obsolete("Use button.Duplicate instead")]
+        Button AddButton(string title, int index);
+    }
+}
diff --git a/OWML.Common/Menus/IModMenus.cs b/OWML.Common/Menus/IModMenus.cs
new file mode 100644
index 00000000..90698be5
--- /dev/null
+++ b/OWML.Common/Menus/IModMenus.cs
@@ -0,0 +1,8 @@
+namespace OWML.Common.Menus
+{
+    public interface IModMenus
+    {
+        IModMainMenu MainMenu { get; }
+        IModPauseMenu PauseMenu { get; }
+    }
+}
diff --git a/OWML.Common/Menus/IModPauseMenu.cs b/OWML.Common/Menus/IModPauseMenu.cs
new file mode 100644
index 00000000..d68ad0da
--- /dev/null
+++ b/OWML.Common/Menus/IModPauseMenu.cs
@@ -0,0 +1,13 @@
+namespace OWML.Common.Menus
+{
+    public interface IModPauseMenu : IModPopupMenu
+    {
+        IModTabbedMenu OptionsMenu { get; }
+        
+        IModButton ResumeButton { get; }
+        IModButton OptionsButton { get; }
+        IModButton QuitButton { get; }
+
+        void Initialize(SettingsManager settingsManager);
+    }
+}
diff --git a/OWML.Common/IModPopupMenu.cs b/OWML.Common/Menus/IModPopupMenu.cs
similarity index 58%
rename from OWML.Common/IModPopupMenu.cs
rename to OWML.Common/Menus/IModPopupMenu.cs
index b365eb73..ab82e221 100644
--- a/OWML.Common/IModPopupMenu.cs
+++ b/OWML.Common/Menus/IModPopupMenu.cs
@@ -1,19 +1,24 @@
 using System;
 
-namespace OWML.Common
+namespace OWML.Common.Menus
 {
     public interface IModPopupMenu : IModMenu
     {
         Action OnOpen { get; set; }
         Action OnClose { get; set; }
-        Action OnInit { get; set; }
 
         bool IsOpen { get; }
+        string Title { get; set; }
 
         void Open();
         void Close();
         void Toggle();
 
+        IModPopupMenu Copy();
+        IModPopupMenu Copy(string title);
+        void Initialize(Menu menu);
+
+        [Obsolete("Use Copy instead")]
         IModPopupMenu CreateCopy(string name);
     }
 }
diff --git a/OWML.Common/Menus/IModTabMenu.cs b/OWML.Common/Menus/IModTabMenu.cs
new file mode 100644
index 00000000..a65ffab1
--- /dev/null
+++ b/OWML.Common/Menus/IModTabMenu.cs
@@ -0,0 +1,7 @@
+namespace OWML.Common.Menus
+{
+    public interface IModTabMenu : IModPopupMenu
+    {
+        void Initialize(TabButton tabButton);
+    }
+}
\ No newline at end of file
diff --git a/OWML.Common/Menus/IModTabbedMenu.cs b/OWML.Common/Menus/IModTabbedMenu.cs
new file mode 100644
index 00000000..a007de92
--- /dev/null
+++ b/OWML.Common/Menus/IModTabbedMenu.cs
@@ -0,0 +1,15 @@
+namespace OWML.Common.Menus
+{
+    public interface IModTabbedMenu : IModPopupMenu
+    {
+        IModTabMenu GameplayTab { get; }
+        IModTabMenu AudioTab { get; }
+        IModTabMenu InputTab { get; }
+        IModTabMenu GraphicsTab { get; }
+
+        new IModTabbedMenu Copy();
+
+        void Initialize(TabbedMenu menu);
+        new TabbedMenu Menu { get; }
+    }
+}
diff --git a/OWML.Common/OWML.Common.csproj b/OWML.Common/OWML.Common.csproj
index d562b820..e5c74119 100644
--- a/OWML.Common/OWML.Common.csproj
+++ b/OWML.Common/OWML.Common.csproj
@@ -67,17 +67,22 @@
     <Compile Include="IHarmonyHelper.cs" />
     <Compile Include="IModAssets.cs" />
     <Compile Include="IModAsset.cs" />
+    <Compile Include="Menus\IModButton.cs" />
     <Compile Include="IModConfig.cs" />
     <Compile Include="IModData.cs" />
-    <Compile Include="IModPopupMenu.cs" />
+    <Compile Include="Menus\IModMainMenu.cs" />
+    <Compile Include="Menus\IModPauseMenu.cs" />
+    <Compile Include="Menus\IModTabbedMenu.cs" />
+    <Compile Include="Menus\IModPopupMenu.cs" />
+    <Compile Include="Menus\IModTabMenu.cs" />
     <Compile Include="IOwmlConfig.cs" />
     <Compile Include="IModEvents.cs" />
     <Compile Include="IModFinder.cs" />
     <Compile Include="IModHelper.cs" />
     <Compile Include="IModConsole.cs" />
     <Compile Include="IModBehaviour.cs" />
-    <Compile Include="IModMenu.cs" />
-    <Compile Include="IModMenus.cs" />
+    <Compile Include="Menus\IModMenu.cs" />
+    <Compile Include="Menus\IModMenus.cs" />
     <Compile Include="IModLogger.cs" />
     <Compile Include="IModManifest.cs" />
     <Compile Include="IModStorage.cs" />
diff --git a/OWML.Launcher/App.cs b/OWML.Launcher/App.cs
index ba73366b..aff54278 100644
--- a/OWML.Launcher/App.cs
+++ b/OWML.Launcher/App.cs
@@ -12,7 +12,7 @@ namespace OWML.Launcher
 {
     public class App
     {
-        private const string Version = "0.3.29";
+        private const string Version = "0.3.30";
 
         private readonly IOwmlConfig _owmlConfig;
         private readonly IModConsole _writer;
diff --git a/OWML.ModHelper.Menus/ModButton.cs b/OWML.ModHelper.Menus/ModButton.cs
new file mode 100644
index 00000000..5cd16571
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModButton.cs
@@ -0,0 +1,145 @@
+using System;
+using OWML.Common.Menus;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModButton : IModButton
+    {
+        public event Action OnClick;
+
+        public Button Button { get; }
+        public IModMenu Menu { get; private set; }
+
+        private readonly Text _text;
+        public string Title
+        {
+            get => _text.text;
+            set => _text.text = value;
+        }
+
+        private int _index;
+        public int Index
+        {
+            get => Button.transform.parent == null ? _index : Button.transform.GetSiblingIndex();
+            set
+            {
+                _index = value;
+                Button.transform.SetSiblingIndex(value);
+            }
+        }
+
+        public ModButton(Button button, IModMenu menu)
+        {
+            Button = button;
+            Button.onClick.AddListener(() => OnClick?.Invoke());
+            _text = Button.GetComponentInChildren<Text>();
+            Initialize(menu);
+        }
+
+        public void Initialize(IModMenu menu)
+        {
+            Menu = menu;
+        }
+
+        public IModButton Copy()
+        {
+            var button = GameObject.Instantiate(Button);
+            GameObject.Destroy(button.GetComponent<SubmitAction>());
+            GameObject.Destroy(button.GetComponentInChildren<LocalizedText>());
+            return new ModButton(button, Menu)
+            {
+                Index = Index + 1
+            };
+        }
+
+        public IModButton Copy(string title)
+        {
+            var copy = Copy();
+            copy.Title = title;
+            return copy;
+        }
+
+        public IModButton Copy(int index)
+        {
+            var copy = Copy();
+            copy.Index = index;
+            return copy;
+        }
+
+        public IModButton Copy(string title, int index)
+        {
+            var copy = Copy(title);
+            copy.Index = index;
+            return copy;
+        }
+
+        public IModButton Duplicate()
+        {
+            var copy = Copy();
+            Menu.AddButton(copy);
+            return copy;
+        }
+
+        public IModButton Duplicate(string title)
+        {
+            var dupe = Duplicate();
+            dupe.Title = title;
+            return dupe;
+        }
+
+        public IModButton Duplicate(int index)
+        {
+            var dupe = Duplicate();
+            dupe.Index = index;
+            return dupe;
+        }
+
+        public IModButton Duplicate(string title, int index)
+        {
+            var dupe = Duplicate(title);
+            dupe.Index = index;
+            return dupe;
+        }
+
+        public IModButton Replace()
+        {
+            var duplicate = Duplicate();
+            Hide();
+            return duplicate;
+        }
+
+        public IModButton Replace(string title)
+        {
+            var replacement = Replace();
+            replacement.Title = title;
+            return replacement;
+        }
+
+        public IModButton Replace(int index)
+        {
+            var replacement = Replace();
+            replacement.Index = index;
+            return replacement;
+        }
+
+        public IModButton Replace(string title, int index)
+        {
+            var replacement = Replace(title);
+            replacement.Index = index;
+            return replacement;
+        }
+
+        public void Show()
+        {
+            Button.gameObject.SetActive(true);
+        }
+
+        public void Hide()
+        {
+            Button.gameObject.SetActive(false);
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModMainMenu.cs b/OWML.ModHelper.Menus/ModMainMenu.cs
index 5b500245..b3522258 100644
--- a/OWML.ModHelper.Menus/ModMainMenu.cs
+++ b/OWML.ModHelper.Menus/ModMainMenu.cs
@@ -1,59 +1,60 @@
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using OWML.Common;
+using OWML.Common.Menus;
 using OWML.ModHelper.Events;
 using UnityEngine;
-using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
 {
-    public class ModMainMenu : IModMenu
+    public class ModMainMenu : ModMenu, IModMainMenu
     {
+        public IModTabbedMenu OptionsMenu { get; }
+
+        public IModButton ResumeExpeditionButton { get; private set; }
+        public IModButton NewExpeditionButton { get; private set; }
+        public IModButton OptionsButton { get; private set; }
+        public IModButton ViewCreditsButton { get; private set; }
+        public IModButton SwitchProfileButton { get; private set; }
+        public IModButton QuitButton { get; private set; }
+
+        private TitleAnimationController _anim;
+
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
-        private readonly TitleAnimationController _anim;
-        private readonly List<CanvasGroupFadeController> _fadeControllers;
-        private readonly Menu _menu;
 
-        public ModMainMenu(IModLogger logger, IModConsole console)
+        public ModMainMenu(IModLogger logger, IModConsole console) : base(logger, console)
         {
             _logger = logger;
             _console = console;
-            var titleScreenManager = GameObject.FindObjectOfType<TitleScreenManager>();
-            _anim = titleScreenManager.GetComponent<TitleAnimationController>();
-            _menu = titleScreenManager.GetValue<Menu>("_mainMenu");
-            _fadeControllers = _anim.GetValue<CanvasGroupFadeController[]>("_buttonFadeControllers").ToList();
+            OptionsMenu = new ModOptionsMenu(logger, console);
         }
 
-        public List<Button> GetButtons()
+        public void Initialize(TitleScreenManager titleScreenManager)
         {
-            return _menu.GetComponentsInChildren<Button>().ToList();
+            _anim = titleScreenManager.GetComponent<TitleAnimationController>();
+            var menu = titleScreenManager.GetValue<Menu>("_mainMenu");
+            Initialize(menu);
+
+            ResumeExpeditionButton = GetButton("Button-ResumeGame");
+            NewExpeditionButton = GetButton("Button-NewGame");
+            OptionsButton = GetButton("Button-Options");
+            ViewCreditsButton = GetButton("Button-Credits");
+            SwitchProfileButton = GetButton("Button-Profile");
+            QuitButton = GetButton("Button-Exit");
+
+            var tabbedMenu = titleScreenManager.GetValue<TabbedMenu>("_optionsMenu");
+            OptionsMenu.Initialize(tabbedMenu);
+            InvokeOnInit();
         }
 
-        public Button AddButton(string title, int index)
+        public override void AddButton(IModButton button, int index)
         {
-            _console.WriteLine("Adding main menu button: " + title);
-
-            var original = _menu.GetComponentInChildren<Button>();
-            _logger.Log("Copying button: " + original.name);
-
-            var copy = GameObject.Instantiate(original, _menu.transform);
-            copy.name = title;
-            copy.transform.SetSiblingIndex(index + 2);
-
-            GameObject.Destroy(copy.GetComponentInChildren<LocalizedText>());
-            GameObject.Destroy(copy.GetComponent<SubmitAction>());
-
-            copy.GetComponentInChildren<Text>().text = title;
-
-            var fadeController = new CanvasGroupFadeController
+            base.AddButton(button, index);
+            var fadeControllers = Buttons.OrderBy(x => x.Index).Select(x => new CanvasGroupFadeController
             {
-                group = copy.GetComponent<CanvasGroup>()
-            };
-            _fadeControllers.Insert(index, fadeController);
-            _anim.SetValue("_buttonFadeControllers", _fadeControllers.ToArray());
-
-            return copy;
+                group = x.Button.GetComponent<CanvasGroup>()
+            });
+            _anim.SetValue("_buttonFadeControllers", fadeControllers.ToArray());
         }
 
     }
diff --git a/OWML.ModHelper.Menus/ModMenu.cs b/OWML.ModHelper.Menus/ModMenu.cs
new file mode 100644
index 00000000..0aad876b
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModMenu.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OWML.Common;
+using OWML.Common.Menus;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModMenu : IModMenu
+    {
+        public event Action OnInit;
+
+        public Menu Menu { get; private set; }
+        public List<IModButton> Buttons { get; private set; }
+
+        private readonly IModLogger _logger;
+        private readonly IModConsole _console;
+        private LayoutGroup _layoutGroup;
+
+        public ModMenu(IModLogger logger, IModConsole console)
+        {
+            _logger = logger;
+            _console = console;
+        }
+
+        public virtual void Initialize(Menu menu)
+        {
+            Menu = menu;
+            _layoutGroup = Menu.GetComponent<LayoutGroup>() ?? Menu.GetComponentInChildren<LayoutGroup>();
+            Buttons = new List<IModButton>();
+            Buttons.AddRange(Menu.GetComponentsInChildren<Button>().Select(x => new ModButton(x, this)).Cast<IModButton>());
+        }
+
+        [Obsolete("Use Buttons instead")]
+        public List<Button> GetButtons()
+        {
+            return Menu.GetComponentsInChildren<Button>().ToList();
+        }
+
+        [Obsolete("Use button.Duplicate instead")]
+        public Button AddButton(string title, int index)
+        {
+            var original = Buttons?.FirstOrDefault();
+            if (original == null)
+            {
+                _console.WriteLine("Warning: no buttons to copy");
+                return null;
+            }
+
+            var copy = original.Copy();
+            copy.Title = title;
+
+            AddButton(copy, index);
+
+            return copy.Button;
+        }
+
+        public void AddButton(IModButton button)
+        {
+            AddButton(button, button.Index);
+        }
+
+        public virtual void AddButton(IModButton button, int index)
+        {
+            button.Button.transform.parent = _layoutGroup.transform;
+            button.Index = index;
+            button.Initialize(this);
+            Buttons.Add(button);
+        }
+
+        public IModButton GetButton(string title)
+        {
+            var button = Buttons.FirstOrDefault(x => x.Title == title || x.Button.name == title);
+            if (button == null)
+            {
+                _console.WriteLine("Warning: no button found with title or name: " + title);
+            }
+            return button;
+        }
+
+        protected void InvokeOnInit()
+        {
+            OnInit?.Invoke();
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModMenus.cs b/OWML.ModHelper.Menus/ModMenus.cs
index 6a4f8f95..2b5749c2 100644
--- a/OWML.ModHelper.Menus/ModMenus.cs
+++ b/OWML.ModHelper.Menus/ModMenus.cs
@@ -1,11 +1,13 @@
 using OWML.Common;
+using OWML.Common.Menus;
+using UnityEngine;
 
 namespace OWML.ModHelper.Menus
 {
     public class ModMenus : IModMenus
     {
-        public IModMenu MainMenu { get; }
-        public IModPopupMenu PauseMenu { get; }
+        public IModMainMenu MainMenu { get; }
+        public IModPauseMenu PauseMenu { get; }
 
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
@@ -14,10 +16,31 @@ public ModMenus(IModLogger logger, IModConsole console, IModEvents events)
         {
             _logger = logger;
             _console = console;
+
             MainMenu = new ModMainMenu(logger, console);
-            PauseMenu = new ModPauseMenu(logger, console, events);
+            var titleScreenManager = GameObject.FindObjectOfType<TitleScreenManager>();
+            MainMenu.Initialize(titleScreenManager);
+
+            PauseMenu = new ModPauseMenu(logger, console);
+
+            events.Subscribe<SettingsManager>(Common.Events.AfterStart);
+            events.Subscribe<TitleScreenManager>(Common.Events.AfterAwake);
+            events.OnEvent += OnEvent;
         }
 
-    }
+        private void OnEvent(MonoBehaviour behaviour, Common.Events ev)
+        {
+            if (behaviour.GetType() == typeof(SettingsManager) && ev == Common.Events.AfterStart && behaviour.name == "PauseMenuManagers")
+            {
+                var settingsManager = (SettingsManager)behaviour;
+                PauseMenu.Initialize(settingsManager);
+            }
+            else if (behaviour.GetType() == typeof(TitleScreenManager) && ev == Common.Events.AfterAwake)
+            {
+                var titleScreenManager = (TitleScreenManager)behaviour;
+                MainMenu.Initialize(titleScreenManager);
+            }
+        }
 
+    }
 }
diff --git a/OWML.ModHelper.Menus/ModOptionsMenu.cs b/OWML.ModHelper.Menus/ModOptionsMenu.cs
new file mode 100644
index 00000000..2de7c18f
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModOptionsMenu.cs
@@ -0,0 +1,63 @@
+using System.Linq;
+using OWML.Common;
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModOptionsMenu : ModPopupMenu, IModTabbedMenu
+    {
+        public IModTabMenu GameplayTab { get; }
+        public IModTabMenu AudioTab { get; }
+        public IModTabMenu InputTab { get; }
+        public IModTabMenu GraphicsTab { get; }
+
+        private readonly IModLogger _logger;
+        private readonly IModConsole _console;
+
+        public new TabbedMenu Menu { get; private set; }
+
+        private TabButton[] _tabButtons;
+
+        public ModOptionsMenu(IModLogger logger, IModConsole console) : base(logger, console)
+        {
+            _logger = logger;
+            _console = console;
+            GameplayTab = new ModTabMenu(logger, console, this);
+            AudioTab = new ModTabMenu(logger, console, this);
+            InputTab = new ModTabMenu(logger, console, this);
+            GraphicsTab = new ModTabMenu(logger, console, this);
+        }
+
+        public void Initialize(TabbedMenu menu)
+        {
+            base.Initialize(menu);
+            Menu = menu;
+
+            _tabButtons = menu.GetValue<TabButton[]>("_menuTabs");
+            GameplayTab.Initialize(GetTabButton("Button-GamePlay"));
+            AudioTab.Initialize(GetTabButton("Button-Audio"));
+            InputTab.Initialize(GetTabButton("Button-Input"));
+            GraphicsTab.Initialize(GetTabButton("Button-Graphics"));
+
+            InvokeOnInit();
+        }
+
+        public TabButton GetTabButton(string name)
+        {
+            var tabButton = _tabButtons.FirstOrDefault(x => x.name == name);
+            if (tabButton == null)
+            {
+                _console.WriteLine("Error: could not find tab for " + name);
+                return null;
+            }
+            return tabButton;
+        }
+
+        public new IModTabbedMenu Copy()
+        {
+            return (IModTabbedMenu)base.Copy();
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModPauseMenu.cs b/OWML.ModHelper.Menus/ModPauseMenu.cs
index 4fb8a1d8..54bf4b61 100644
--- a/OWML.ModHelper.Menus/ModPauseMenu.cs
+++ b/OWML.ModHelper.Menus/ModPauseMenu.cs
@@ -1,30 +1,42 @@
-using OWML.Common;
+using System.Linq;
+using OWML.Common;
+using OWML.Common.Menus;
 using OWML.ModHelper.Events;
-using UnityEngine;
 
 namespace OWML.ModHelper.Menus
 {
-    public class ModPauseMenu : ModPopupMenu
+    public class ModPauseMenu : ModPopupMenu, IModPauseMenu
     {
+        public IModTabbedMenu OptionsMenu { get; }
+
+        public IModButton ResumeButton { get; private set; }
+        public IModButton OptionsButton { get; private set; }
+        public IModButton QuitButton { get; private set; }
+
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
 
-        public ModPauseMenu(IModLogger logger, IModConsole console, IModEvents events) : base(logger, console)
+        public ModPauseMenu(IModLogger logger, IModConsole console) : base(logger, console)
         {
             _logger = logger;
             _console = console;
-            events.Subscribe<PauseMenuManager>(Common.Events.AfterStart);
-            events.OnEvent += OnEvent;
+            OptionsMenu = new ModOptionsMenu(logger, console);
         }
 
-        private void OnEvent(MonoBehaviour behaviour, Common.Events ev)
+        public void Initialize(SettingsManager settingsManager)
         {
-            if (behaviour.GetType() == typeof(PauseMenuManager) && ev == Common.Events.AfterStart)
-            {
-                _console.WriteLine("Pause menu started");
-                var menu = behaviour.GetValue<Menu>("_pauseMenu");
-                Initialize(menu);
-            }
+            var pauseMenuManager = settingsManager.GetComponent<PauseMenuManager>();
+            var optionsMenu = settingsManager.GetValue<TabbedMenu>("_mainSettingsMenu");
+            OptionsMenu.Initialize(optionsMenu);
+
+            var pauseMenu = pauseMenuManager.GetValue<Menu>("_pauseMenu");
+            base.Initialize(pauseMenu);
+
+            ResumeButton = Buttons.Single(x => x.Button.name == "Button-Unpause");
+            OptionsButton = Buttons.Single(x => x.Button.name == "Button-Options");
+            QuitButton = Buttons.Single(x => x.Button.name == "Button-ExitToMainMenu");
+
+            InvokeOnInit();
         }
 
     }
diff --git a/OWML.ModHelper.Menus/ModPopupMenu.cs b/OWML.ModHelper.Menus/ModPopupMenu.cs
index 0e2b8849..ac0e5102 100644
--- a/OWML.ModHelper.Menus/ModPopupMenu.cs
+++ b/OWML.ModHelper.Menus/ModPopupMenu.cs
@@ -1,77 +1,47 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using OWML.Common;
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
 using UnityEngine;
 using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
 {
-    public class ModPopupMenu : IModPopupMenu
+    public class ModPopupMenu : ModMenu, IModPopupMenu
     {
         public Action OnOpen { get; set; }
         public Action OnClose { get; set; }
-        public Action OnInit { get; set; }
 
         public bool IsOpen { get; private set; }
 
+        private Text _title;
+        public string Title
+        {
+            get => _title.text;
+            set => _title.text = value;
+        }
+
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
 
-        protected Menu Menu;
-        private LayoutGroup _layoutGroup;
-        private Text _title;
-
-        public ModPopupMenu(IModLogger logger, IModConsole console)
+        public ModPopupMenu(IModLogger logger, IModConsole console) : base(logger, console)
         {
             _logger = logger;
             _console = console;
         }
 
-        public virtual List<Button> GetButtons()
+        public override void Initialize(Menu menu)
         {
-            if (Menu == null)
-            {
-                _console.WriteLine("Warning: can't get buttons before menu exists");
-                return new List<Button>();
-            }
-            return _layoutGroup.GetComponentsInChildren<Button>().ToList();
-        }
-
-        public virtual Button AddButton(string title, int index)
-        {
-            if (Menu == null)
+            base.Initialize(menu);
+            _title = Menu.GetComponentInChildren<Text>();
+            var localizedText = _title.GetComponent<LocalizedText>();
+            if (localizedText != null)
             {
-                _console.WriteLine("Warning: can't add button before menu exists");
-                return null;
+                Title = UITextLibrary.GetString(localizedText.GetValue<UITextType>("_textID"));
+                GameObject.Destroy(localizedText);
             }
-
-            _console.WriteLine("Adding button: " + title);
-
-            var original = _layoutGroup.GetComponentInChildren<Button>();
-            _logger.Log("Copying button: " + original.name);
-
-            var copy = GameObject.Instantiate(original, _layoutGroup.transform);
-            copy.name = title;
-            copy.transform.SetSiblingIndex(index + 2);
-
-            GameObject.Destroy(copy.GetComponentInChildren<LocalizedText>());
-            GameObject.Destroy(copy.GetComponent<SubmitAction>());
-
-            copy.GetComponentInChildren<Text>().text = title;
-
-            return copy;
-        }
-
-        public void Initialize(Menu menu)
-        {
-            Menu = menu;
-            _layoutGroup = Menu.GetComponentInChildren<LayoutGroup>();
-            _title = Menu.GetComponentInChildren<Text>();
-            GameObject.Destroy(_title.GetComponent<LocalizedText>());
             Menu.OnActivateMenu += OnActivateMenu;
             Menu.OnDeactivateMenu += OnDeactivateMenu;
-            OnInit?.Invoke();
         }
 
         private void OnDeactivateMenu()
@@ -96,7 +66,7 @@ public virtual void Open()
             Menu.EnableMenu(true);
         }
 
-        public virtual void Close()
+        public void Close()
         {
             if (Menu == null)
             {
@@ -118,23 +88,37 @@ public void Toggle()
             }
         }
 
-        public IModPopupMenu CreateCopy(string title)
+        public IModPopupMenu Copy()
         {
             if (Menu == null)
             {
                 _console.WriteLine("Warning: can't copy menu, it doesn't exist.");
                 return null;
             }
-            var copy = GameObject.Instantiate(Menu, Menu.transform.parent);
+            var menu = GameObject.Instantiate(Menu, Menu.transform.parent);
             var modMenu = new ModPopupMenu(_logger, _console);
-            modMenu.Initialize(copy);
-            modMenu.SetTitle(title);
+            modMenu.Initialize(menu);
             return modMenu;
         }
 
-        private void SetTitle(string title)
+        public IModPopupMenu Copy(string title)
+        {
+            var copy = Copy();
+            copy.Title = title;
+            return copy;
+        }
+
+        [Obsolete("Use Copy instead")]
+        public IModPopupMenu CreateCopy(string title)
         {
-            _title.text = title;
+            if (Menu == null)
+            {
+                _console.WriteLine("Warning: can't copy menu, it doesn't exist.");
+                return null;
+            }
+            var menu = Copy();
+            menu.Title = title;
+            return menu;
         }
 
     }
diff --git a/OWML.ModHelper.Menus/ModTabMenu.cs b/OWML.ModHelper.Menus/ModTabMenu.cs
new file mode 100644
index 00000000..e4c06338
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModTabMenu.cs
@@ -0,0 +1,40 @@
+using OWML.Common;
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModTabMenu : ModPopupMenu, IModTabMenu
+    {
+        private readonly IModLogger _logger;
+        private readonly IModConsole _console;
+        private readonly IModTabbedMenu _optionsMenu;
+
+        private TabButton _tabButton;
+
+        public ModTabMenu(IModLogger logger, IModConsole console, IModTabbedMenu optionsMenu) : base(logger, console)
+        {
+            _logger = logger;
+            _console = console;
+            _optionsMenu = optionsMenu;
+        }
+
+        public void Initialize(TabButton tabButton)
+        {
+            _tabButton = tabButton;
+            var menu = tabButton.GetValue<Menu>("_tabbedMenu");
+            Initialize(menu);
+            InvokeOnInit();
+        }
+
+        public override void Open()
+        {
+            if (!_optionsMenu.IsOpen)
+            {
+                _optionsMenu.Open();
+            }
+            _optionsMenu.Menu.Invoke("SelectTabButton", _tabButton);
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModsMenu.cs b/OWML.ModHelper.Menus/ModsMenu.cs
index 66be10c8..a01e222f 100644
--- a/OWML.ModHelper.Menus/ModsMenu.cs
+++ b/OWML.ModHelper.Menus/ModsMenu.cs
@@ -1,17 +1,16 @@
 using System.Collections.Generic;
 using OWML.Common;
-using UnityEngine;
 using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
 {
-    public class ModsMenu : IModMenu
+    public class ModsMenu : ModPopupMenu
     {
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
         private readonly List<IModBehaviour> _registeredMods;
 
-        public ModsMenu(IModLogger logger, IModConsole console)
+        public ModsMenu(IModLogger logger, IModConsole console) : base(logger, console)
         {
             _logger = logger;
             _console = console;
@@ -36,24 +35,6 @@ private IModConfig ParseConfig(Button button)
             _console.WriteLine("todo: implement ModsMenu.ParseConfig");
             return new ModConfig();
         }
-
-        public Button AddButton(string title, int index)
-        {
-            _console.WriteLine("todo: implement ModsMenu.AddButton");
-            var go = new GameObject();
-            return go.AddComponent<Button>(); // todo
-        }
-
-        public List<Button> GetButtons()
-        {
-            _console.WriteLine("todo: implement ModsMenu.GetButtons");
-            return new List<Button>();
-        }
-
-        public void Open()
-        {
-            _console.WriteLine("todo: implement ModsMenu.Open");
-        }
-
+        
     }
 }
diff --git a/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj b/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj
index 24501d07..4a5ee129 100644
--- a/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj
+++ b/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj
@@ -66,11 +66,15 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ModButton.cs" />
+    <Compile Include="ModMenu.cs" />
+    <Compile Include="ModOptionsMenu.cs" />
+    <Compile Include="ModPauseMenu.cs" />
     <Compile Include="ModPopupMenu.cs" />
     <Compile Include="ModsMenu.cs" />
-    <Compile Include="ModPauseMenu.cs" />
     <Compile Include="ModMenus.cs" />
     <Compile Include="ModMainMenu.cs" />
+    <Compile Include="ModTabMenu.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/OWML.ModHelper/ModHelper.cs b/OWML.ModHelper/ModHelper.cs
index 4f60fec6..e36a9bd4 100644
--- a/OWML.ModHelper/ModHelper.cs
+++ b/OWML.ModHelper/ModHelper.cs
@@ -1,5 +1,6 @@
 
 using OWML.Common;
+using OWML.Common.Menus;
 
 namespace OWML.ModHelper
 {
diff --git a/OWML.ModLoader/Owo.cs b/OWML.ModLoader/Owo.cs
index a78b2b62..ed8a28c7 100644
--- a/OWML.ModLoader/Owo.cs
+++ b/OWML.ModLoader/Owo.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Reflection;
 using OWML.Common;
+using OWML.Common.Menus;
 using OWML.ModHelper;
 using OWML.ModHelper.Assets;
 using OWML.ModHelper.Events;
diff --git a/OWML.SampleMods/OWML.EnableDebugMode/manifest.json b/OWML.SampleMods/OWML.EnableDebugMode/manifest.json
index 6ffe6592..d9520408 100644
--- a/OWML.SampleMods/OWML.EnableDebugMode/manifest.json
+++ b/OWML.SampleMods/OWML.EnableDebugMode/manifest.json
@@ -4,5 +4,5 @@
   "name": "EnableDebugMode",
   "uniqueName": "Alek.EnableDebugMode",
   "version": "0.2",
-  "owmlVersion": "0.3.29"
+  "owmlVersion": "0.3.30"
 }
\ No newline at end of file
diff --git a/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs b/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs
index 68c9ba4b..33c2a4fe 100644
--- a/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs
+++ b/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs
@@ -37,14 +37,26 @@ private void Start()
             ModHelper.Events.Subscribe<PlayerBody>(Events.AfterAwake);
             ModHelper.Events.OnEvent += OnEvent;
 
-            var owo = ModHelper.Menus.MainMenu.AddButton("OWO", 3);
-            owo.onClick.AddListener(OnOwo);
+            ModHelper.Menus.MainMenu.OnInit += DoMainMenuStuff;
+            DoMainMenuStuff();
 
-            ModHelper.Menus.PauseMenu.OnInit += () =>
-            {
-                var uwu = ModHelper.Menus.PauseMenu.AddButton("UWU", 1);
-                uwu.onClick.AddListener(OnUwu);
-            };
+            ModHelper.Menus.PauseMenu.OnInit += DoPauseMenuStuff;
+        }
+
+        private void DoMainMenuStuff()
+        {
+            ModHelper.Console.WriteLine(nameof(DoMainMenuStuff));
+            var resumeDupe = ModHelper.Menus.MainMenu.ResumeExpeditionButton.Duplicate();
+            resumeDupe.Title = "OPEN INPUT MENU";
+            resumeDupe.OnClick += () => ModHelper.Menus.MainMenu.OptionsMenu.InputTab.Open();
+        }
+
+        private void DoPauseMenuStuff()
+        {
+            ModHelper.Console.WriteLine(nameof(DoPauseMenuStuff));
+            var openInputButton = ModHelper.Menus.PauseMenu.ResumeButton.Duplicate();
+            openInputButton.Title = "OPEN INPUT MENU";
+            openInputButton.OnClick += () => ModHelper.Menus.PauseMenu.OptionsMenu.InputTab.Open();
         }
 
         public override void Configure(IModConfig config)
@@ -87,7 +99,7 @@ private void OnEvent(MonoBehaviour behaviour, Events ev)
 
         private void Update()
         {
-            if (!_isStarted)
+            if (!_isStarted || OWTime.IsPaused())
             {
                 return;
             }
@@ -120,16 +132,6 @@ private void CreateCube()
             Instantiate(_cube, _playerTransform.position + _playerTransform.forward * 2f, Quaternion.identity);
         }
 
-        private void OnOwo()
-        {
-            ModHelper.Console.WriteLine("OWO!");
-        }
-
-        private void OnUwu()
-        {
-            ModHelper.Console.WriteLine("UWU!");
-        }
-
         private void ToggleMusic(bool enable)
         {
             if (_music == null)
diff --git a/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json b/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json
index c4f352e1..31fa97c6 100644
--- a/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json
+++ b/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json
@@ -3,6 +3,6 @@
   "author": "Alek",
   "name": "LoadCustomAssets",
   "uniqueName": "Alek.LoadCustomAssets",
-  "version": "0.4",
-  "owmlVersion": "0.3.29"
+  "version": "0.5",
+  "owmlVersion": "0.3.30"
 }
\ No newline at end of file