diff --git a/.github/workflows/build-test-debug.yml b/.github/workflows/build-test-debug.yml
index 9ae31c8c1b..f205f300a9 100644
--- a/.github/workflows/build-test-debug.yml
+++ b/.github/workflows/build-test-debug.yml
@@ -51,7 +51,7 @@ jobs:
       shell: pwsh
       run: |
         $env:DOTNET_gcServer=1
-        dotnet test --no-build --configuration DebugOpt Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0 NUnit.MapWarningTo=Failed
+        dotnet test --no-build --configuration DebugOpt Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0
   ci-success:
     name: Build & Test Debug
     needs:
diff --git a/Content.Client/Actions/ActionsSystem.cs b/Content.Client/Actions/ActionsSystem.cs
index 48c53869e6..92f59d4697 100644
--- a/Content.Client/Actions/ActionsSystem.cs
+++ b/Content.Client/Actions/ActionsSystem.cs
@@ -302,7 +302,7 @@ public void LoadActionAssignments(string path, bool userData)
                     continue;
 
                 var action = _serialization.Read<BaseActionComponent>(actionNode, notNullableOverride: true);
-                var actionId = Spawn(null);
+                var actionId = Spawn();
                 AddComp(actionId, action);
                 AddActionDirect(user, actionId);
 
diff --git a/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs b/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs
index 3ef7f0ae73..57bd34ed06 100644
--- a/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs
+++ b/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs
@@ -10,15 +10,11 @@ namespace Content.Client.Chemistry.UI
     /// Initializes a <see cref="ChemMasterWindow"/> and updates it when new server messages are received.
     /// </summary>
     [UsedImplicitly]
-    public sealed class ChemMasterBoundUserInterface : BoundUserInterface
+    public sealed class ChemMasterBoundUserInterface(EntityUid owner, Enum uiKey) : BoundUserInterface(owner, uiKey)
     {
         [ViewVariables]
         private ChemMasterWindow? _window;
 
-        public ChemMasterBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
-        {
-        }
-
         /// <summary>
         /// Called each time a chem master UI instance is opened. Generates the window and fills it with
         /// relevant info. Sets the actions for static buttons.
@@ -53,7 +49,11 @@ protected override void Open()
                 _window.PillTypeButtons[i].OnPressed += _ => SendMessage(new ChemMasterSetPillTypeMessage(pillType));
             }
 
-            _window.OnReagentButtonPressed += (args, button) => SendMessage(new ChemMasterReagentAmountButtonMessage(button.Id, button.Amount, button.IsBuffer));
+            _window.OnReagentButtonPressed += (_, button, amount) => SendMessage(new ChemMasterReagentAmountButtonMessage(button.Id, amount, button.IsBuffer));
+            _window.OnSortMethodChanged += sortMethod => SendMessage(new ChemMasterSortMethodUpdated(sortMethod));
+            _window.OnTransferAmountChanged += amount => SendMessage(new ChemMasterTransferringAmountUpdated(amount));
+
+
         }
 
         /// <summary>
@@ -68,7 +68,6 @@ protected override void UpdateState(BoundUserInterfaceState state)
             base.UpdateState(state);
 
             var castState = (ChemMasterBoundUserInterfaceState) state;
-
             _window?.UpdateState(castState); // Update window state
         }
     }
diff --git a/Content.Client/Chemistry/UI/ChemMasterWindow.xaml b/Content.Client/Chemistry/UI/ChemMasterWindow.xaml
index 61bbba3c35..94e7a0e84b 100644
--- a/Content.Client/Chemistry/UI/ChemMasterWindow.xaml
+++ b/Content.Client/Chemistry/UI/ChemMasterWindow.xaml
@@ -2,7 +2,7 @@
                 xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
-                MinSize="620 770"
+                MinSize="500 770"
                 Title="{Loc 'chem-master-bound-user-interface-title'}">
     <TabContainer Name="Tabs" Margin="5 5 7 5">
         <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="5" SeparationOverride="10">
@@ -10,7 +10,9 @@
             <BoxContainer Orientation="Horizontal">
                 <Label Text="{Loc 'chem-master-window-container-label'}" />
                 <Control HorizontalExpand="True" />
-                <Button MinSize="80 0" Name="InputEjectButton" Access="Public" Text="{Loc 'chem-master-window-eject-button'}" />
+                <RichTextLabel Name="InputAmountLabel" Text="{Loc 'chem-master-window-transferring-default-label'}"  Margin="0 0 7 0"/>
+                <LineEdit MinSize="140 0" Name="InputAmountLineEdit" Access="Public" PlaceHolder="{Loc 'chem-master-window-amount-placeholder'}" />
+                <Button MinSize="80 0" Name="InputEjectButton" Access="Public" Text="{Loc 'chem-master-window-eject-button'}" StyleClasses="OpenLeft" />
             </BoxContainer>
 
             <PanelContainer VerticalExpand="True" MinSize="0 300">
@@ -34,6 +36,7 @@
                 <Label Text="{Loc 'chem-master-window-buffer-text'}" />
                 <Control HorizontalExpand="True" />
                 <Button MinSize="80 0" Name="BufferTransferButton" Access="Public" Text="{Loc 'chem-master-window-transfer-button'}" ToggleMode="True" StyleClasses="OpenRight" />
+                <OptionButton Name="SortMethod" Access="Public" ToolTip="{Loc 'chem-master-window-sort-method-tooltip'}" StyleClasses="OpenBoth" />
                 <Button MinSize="80 0" Name="BufferDiscardButton" Access="Public" Text="{Loc 'chem-master-window-discard-button'}" ToggleMode="True" StyleClasses="OpenLeft" />
             </BoxContainer>
 
@@ -57,6 +60,8 @@
             <BoxContainer Orientation="Horizontal">
                 <Label Text="{Loc 'chem-master-window-container-label'}" />
                 <Control HorizontalExpand="True" />
+                <Label Name="OutputAmountLabel" Text="{Loc 'chem-master-window-transferring-default-label'}" Margin="0 0 7 0"/>
+                <LineEdit MinSize="140 0" Name="OutputAmountLineEdit" Access="Public" PlaceHolder="{Loc 'chem-master-window-amount-placeholder'}" />
                 <Button MinSize="80 0" Name="OutputEjectButton" Access="Public" Text="{Loc 'chem-master-window-eject-button'}" />
             </BoxContainer>
 
@@ -129,4 +134,4 @@
             </PanelContainer>
         </BoxContainer>
     </TabContainer>
-</controls:FancyWindow>
\ No newline at end of file
+</controls:FancyWindow>
diff --git a/Content.Client/Chemistry/UI/ChemMasterWindow.xaml.cs b/Content.Client/Chemistry/UI/ChemMasterWindow.xaml.cs
index ec6d41bd32..bba3533d61 100644
--- a/Content.Client/Chemistry/UI/ChemMasterWindow.xaml.cs
+++ b/Content.Client/Chemistry/UI/ChemMasterWindow.xaml.cs
@@ -24,9 +24,19 @@ namespace Content.Client.Chemistry.UI
     public sealed partial class ChemMasterWindow : FancyWindow
     {
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-        public event Action<BaseButton.ButtonEventArgs, ReagentButton>? OnReagentButtonPressed;
+        public event Action<BaseButton.ButtonEventArgs, ReagentButton, int>? OnReagentButtonPressed;
+        public event Action<int>? OnSortMethodChanged;
+        public event Action<int>? OnTransferAmountChanged;
         public readonly Button[] PillTypeButtons;
 
+        private Dictionary<string, ReagentCached> _reagents;
+        private const string TransferringAmountColor = "#ffa500";
+        private ReagentSortMethod _currentSortMethod = ReagentSortMethod.Alphabetical;
+        private ChemMasterBoundUserInterfaceState? _lastState;
+        private string _lastAmountText = "50";
+        private int _transferAmount = 50;
+
+
         private const string PillsRsiPath = "/Textures/Objects/Specific/Chemistry/pills.rsi";
 
         /// <summary>
@@ -38,6 +48,14 @@ public ChemMasterWindow()
             RobustXamlLoader.Load(this);
             IoCManager.InjectDependencies(this);
 
+            _reagents = new();
+
+            InputAmountLineEdit.OnTextEntered += SetAmount;
+            InputAmountLineEdit.OnFocusExit += SetAmount;
+
+            OutputAmountLineEdit.OnTextEntered += SetAmount;
+            OutputAmountLineEdit.OnFocusExit += SetAmount;
+
             // Pill type selection buttons, in total there are 20 pills.
             // Pill rsi file should have states named as pill1, pill2, and so on.
             var resourcePath = new ResPath(PillsRsiPath);
@@ -87,46 +105,118 @@ public ChemMasterWindow()
 
             Tabs.SetTabTitle(0, Loc.GetString("chem-master-window-input-tab"));
             Tabs.SetTabTitle(1, Loc.GetString("chem-master-window-output-tab"));
+
+            SortMethod.AddItem(
+                Loc.GetString("chem-master-window-sort-method-Alphabetical-text"),
+                (int) ReagentSortMethod.Alphabetical);
+            SortMethod.AddItem(Loc.GetString("chem-master-window-sort-method-Amount-text"), (int) ReagentSortMethod.Amount);
+            SortMethod.AddItem(Loc.GetString("chem-master-window-sort-method-Time-text"), (int) ReagentSortMethod.Time);
+            SortMethod.OnItemSelected += HandleChildPressed;
+
+            BufferTransferButton.OnPressed += HandleDiscardTransferPress;
+            BufferDiscardButton.OnPressed += HandleDiscardTransferPress;
+        }
+
+        private void HandleDiscardTransferPress(BaseButton.ButtonEventArgs args)
+        {
+            var buttons = BufferInfo.Children
+                .Where(c => c is Button)
+                .Cast<Button>();
+
+            foreach (var button in buttons)
+            {
+                var text = BufferTransferButton.Pressed ? "transfer" : "discard";
+                button.Text = Loc.GetString($"chem-master-window-{text}-button-text");
+            }
+        }
+
+        private void HandleSortMethodChange(int newSortMethod)
+        {
+            if (newSortMethod == (int) _currentSortMethod)
+                return;
+
+            _currentSortMethod = (ReagentSortMethod) newSortMethod;
+            SortMethod.SelectId(newSortMethod);
+            SortUpdated();
+        }
+
+        private void HandleChildPressed(OptionButton.ItemSelectedEventArgs args)
+        {
+            HandleSortMethodChange(args.Id);
+            OnSortMethodChanged?.Invoke(args.Id);
+        }
+
+        private void SortUpdated()
+        {
+            if (_lastState == null)
+                return;
+
+            UpdatePanelInfo(_lastState);
+        }
+
+        private bool ValidateAmount(string newText)
+        {
+            if (string.IsNullOrWhiteSpace(newText) || !int.TryParse(newText, out int amount))
+            {
+                InputAmountLineEdit.SetText(string.Empty);
+                OutputAmountLineEdit.SetText(string.Empty);
+                return false;
+            }
+
+            _lastAmountText = newText;
+            _transferAmount = amount;
+            OnTransferAmountChanged?.Invoke(amount);
+            return true;
+        }
+
+        private void SetAmount(LineEdit.LineEditEventArgs args) =>
+            SetAmountText(args.Text);
+
+        private void SetAmountText(string newText)
+        {
+            if (newText == _lastAmountText)
+                return;
+
+            if (!ValidateAmount(newText))
+                return;
+
+            var localizedAmount = Loc.GetString(
+                "chem-master-window-transferring-label",
+                ("quantity", newText),
+                ("color", TransferringAmountColor));
+
+            InputAmountLabel.Text = localizedAmount;
+            OutputAmountLabel.Text = localizedAmount;
+
+            InputAmountLineEdit.SetText(string.Empty);
+            OutputAmountLineEdit.SetText(string.Empty);
         }
 
-        private ReagentButton MakeReagentButton(string text, ChemMasterReagentAmount amount, ReagentId id, bool isBuffer, string styleClass)
+        private ReagentButton MakeReagentButton(string text, ReagentId id, bool isBuffer)
         {
-            var reagentTransferButton = new ReagentButton(text, amount, id, isBuffer, styleClass);
+            var reagentTransferButton = new ReagentButton(text, id, isBuffer);
             reagentTransferButton.OnPressed += args
-                => OnReagentButtonPressed?.Invoke(args, reagentTransferButton);
+                => OnReagentButtonPressed?.Invoke(args, reagentTransferButton, _transferAmount);
             return reagentTransferButton;
         }
         /// <summary>
         /// Conditionally generates a set of reagent buttons based on the supplied boolean argument.
         /// This was moved outside of BuildReagentRow to facilitate conditional logic, stops indentation depth getting out of hand as well.
         /// </summary>
-        private List<ReagentButton> CreateReagentTransferButtons(ReagentId reagent, bool isBuffer, bool addReagentButtons)
+        private ReagentButton? CreateReagentTransferButton(ReagentId reagent, bool isBuffer, bool addReagentButtons)
         {
             if (!addReagentButtons)
-                return new(); // Return an empty list if reagentTransferButton creation is disabled.
+                return null; // Return an empty list if reagentTransferButton creation is disabled.
 
-            var buttons = new List<ReagentButton>();
-            var names = Enum.GetNames<ChemMasterReagentAmount>();
-            var values = Enum.GetValues<ChemMasterReagentAmount>();
+            var text = BufferTransferButton.Pressed ? "transfer" : "discard";
 
-            for (int i = 0; i < names.Length; i++)
-            {
-                var isNumber = int.TryParse(names[i].Substring(1), out int number);
-                var name = isNumber ? number.ToString() : names[i];
-                var reagentAmount = values[i];
-
-                var reagentTransferButton = MakeReagentButton(
-                    name,
-                    reagentAmount,
-                    reagent,
-                    isBuffer,
-                    i != names.Length - 1 ? StyleBase.ButtonOpenBoth : StyleBase.ButtonOpenLeft
-                );
-
-                buttons.Add(reagentTransferButton);
-            }
+            var reagentTransferButton = MakeReagentButton(
+                Loc.GetString($"chem-master-window-{text}-button"),
+                reagent,
+                isBuffer
+            );
 
-            return buttons;
+            return reagentTransferButton;
         }
 
         /// <summary>
@@ -140,8 +230,12 @@ public void UpdateState(BoundUserInterfaceState state)
             if (castState.UpdateLabel)
                 LabelLine = GenerateLabel(castState);
 
+            _lastState = castState;
+
             // Ensure the Panel Info is updated, including UI elements for Buffer Volume, Output Container and so on
             UpdatePanelInfo(castState);
+            HandleSortMethodChange(castState.SortMethod);
+            SetAmountText(castState.TransferringAmount.ToString());
 
             BufferCurrentVolume.Text = $" {castState.BufferCurrentVolume?.Int() ?? 0}u";
 
@@ -238,15 +332,57 @@ private void UpdatePanelInfo(ChemMasterBoundUserInterfaceState state)
             bufferHBox.AddChild(bufferVol);
 
             // initialises rowCount to allow for striped rows
-
             var rowCount = 0;
-            foreach (var (reagent, quantity) in state.BufferReagents.OrderBy(x => x.Reagent.Prototype))
+            var bufferReagents = state.BufferReagents.OrderBy(x => x.Reagent.Prototype);
+
+            if (_currentSortMethod == ReagentSortMethod.Amount)
+                bufferReagents = bufferReagents.OrderByDescending(x => x.Quantity);
+
+            if (_currentSortMethod == ReagentSortMethod.Time)
+            {
+                bufferReagents = bufferReagents.OrderByDescending(
+                    x =>
+                    {
+                        var exists = _reagents.TryGetValue(x.Reagent.Prototype, out var reagent);
+                        return exists && reagent != null ? reagent.TimeAdded : DateTimeOffset.UtcNow;
+                    });
+            }
+
+            var bufferAsNames = bufferReagents.Select(r => r.Reagent.Prototype).ToHashSet();
+            var hashSetCachedReagents = _reagents.Keys.ToHashSet();
+            hashSetCachedReagents.ExceptWith(bufferAsNames);
+
+            foreach (var missing in hashSetCachedReagents)
+                _reagents.Remove(missing);
+
+            foreach (var (reagent, quantity) in bufferReagents)
             {
                 var reagentId = reagent;
                 _prototypeManager.TryIndex(reagentId.Prototype, out ReagentPrototype? proto);
                 var name = proto?.LocalizedName ?? Loc.GetString("chem-master-window-unknown-reagent-text");
                 var reagentColor = proto?.SubstanceColor ?? default(Color);
                 BufferInfo.Children.Add(BuildReagentRow(reagentColor, rowCount++, name, reagentId, quantity, true, true));
+
+                var exists = _reagents.TryGetValue(reagent.Prototype, out var reagentCached);
+
+                if (!exists)
+                {
+                    reagentCached = new()
+                    {
+                        Id = reagentId,
+                        Quantity = quantity,
+                        TimeAdded = reagentCached?.TimeAdded ?? DateTimeOffset.UtcNow
+                    };
+
+                    _reagents.Add(reagentId.Prototype, reagentCached);
+                }
+                else
+                {
+                    reagentCached!.Quantity = quantity;
+                    reagentCached!.Id = reagentId;
+
+                    _reagents[reagentId.Prototype] = reagentCached;
+                }
             }
         }
 
@@ -316,7 +452,7 @@ private Control BuildReagentRow(Color reagentColor, int rowCount, string name, R
                 reagentColor = currentRowColor;
             }
             //this calls the separated button builder, and stores the return to render after labels
-            var reagentButtonConstructors = CreateReagentTransferButtons(reagent, isBuffer, addReagentButtons);
+            var reagentButtonConstructor = CreateReagentTransferButton(reagent, isBuffer, addReagentButtons);
 
             // Create the row layout with the color panel
             var rowContainer = new BoxContainer
@@ -348,11 +484,9 @@ private Control BuildReagentRow(Color reagentColor, int rowCount, string name, R
                 }
             };
 
-            // Add the reagent buttons after the color panel
-            foreach (var reagentTransferButton in reagentButtonConstructors)
-            {
-                rowContainer.AddChild(reagentTransferButton);
-            }
+            if (reagentButtonConstructor != null)
+                rowContainer.AddChild(reagentButtonConstructor);
+
             //Apply panencontainer to allow for striped rows
             return new PanelContainer
             {
@@ -370,16 +504,28 @@ public string LabelLine
 
     public sealed class ReagentButton : Button
     {
-        public ChemMasterReagentAmount Amount { get; set; }
         public bool IsBuffer = true;
         public ReagentId Id { get; set; }
-        public ReagentButton(string text, ChemMasterReagentAmount amount, ReagentId id, bool isBuffer, string styleClass)
+        public ReagentButton(string text, ReagentId id, bool isBuffer)
         {
-            AddStyleClass(styleClass);
+            AddStyleClass(StyleBase.ButtonOpenLeft);
             Text = text;
-            Amount = amount;
             Id = id;
             IsBuffer = isBuffer;
         }
     }
+
+    public sealed class ReagentCached
+    {
+        public ReagentId Id { get; set; }
+        public DateTimeOffset TimeAdded { get; set; }
+        public FixedPoint2 Quantity { get; set; }
+    }
+
+    public enum ReagentSortMethod
+    {
+        Time,
+        Alphabetical,
+        Amount
+    }
 }
diff --git a/Content.Client/Commands/ActionsCommands.cs b/Content.Client/Commands/ActionsCommands.cs
index dd489fd4d6..fd2596fafd 100644
--- a/Content.Client/Commands/ActionsCommands.cs
+++ b/Content.Client/Commands/ActionsCommands.cs
@@ -84,27 +84,3 @@ private static async void LoadActs()
         reader.Close();
     }
 }
-
-[AnyCommand]
-public sealed class LoadMappingActionsCommand : LocalizedCommands
-{
-    [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
-
-    public const string CommandName = "loadmapacts";
-
-    public override string Command => CommandName;
-
-    public override string Help => LocalizationManager.GetString($"cmd-{Command}-help", ("command", Command));
-
-    public override void Execute(IConsoleShell shell, string argStr, string[] args)
-    {
-        try
-        {
-            _entitySystemManager.GetEntitySystem<MappingSystem>().LoadMappingActions();
-        }
-        catch
-        {
-            shell.WriteError(LocalizationManager.GetString($"cmd-{Command}-error"));
-        }
-    }
-}
diff --git a/Content.Client/Commands/MappingClientSideSetupCommand.cs b/Content.Client/Commands/MappingClientSideSetupCommand.cs
index 39268c6284..eb2d13c954 100644
--- a/Content.Client/Commands/MappingClientSideSetupCommand.cs
+++ b/Content.Client/Commands/MappingClientSideSetupCommand.cs
@@ -1,6 +1,8 @@
+using Content.Client.Mapping;
 using Content.Client.Markers;
 using JetBrains.Annotations;
 using Robust.Client.Graphics;
+using Robust.Client.State;
 using Robust.Shared.Console;
 
 namespace Content.Client.Commands;
@@ -10,6 +12,7 @@ internal sealed class MappingClientSideSetupCommand : LocalizedCommands
 {
     [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
     [Dependency] private readonly ILightManager _lightManager = default!;
+    [Dependency] private readonly IStateManager _stateManager = default!;
 
     public override string Command => "mappingclientsidesetup";
 
@@ -21,8 +24,8 @@ public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             _entitySystemManager.GetEntitySystem<MarkerSystem>().MarkersVisible = true;
             _lightManager.Enabled = false;
-            shell.ExecuteCommand(ShowSubFloorForever.CommandName);
-            shell.ExecuteCommand(LoadMappingActionsCommand.CommandName);
+            shell.ExecuteCommand("showsubfloorforever");
+            _stateManager.RequestStateChange<MappingState>();
         }
     }
 }
diff --git a/Content.Client/ContextMenu/UI/ContextMenuUIController.cs b/Content.Client/ContextMenu/UI/ContextMenuUIController.cs
index 5b156644a7..2d94034bb9 100644
--- a/Content.Client/ContextMenu/UI/ContextMenuUIController.cs
+++ b/Content.Client/ContextMenu/UI/ContextMenuUIController.cs
@@ -2,6 +2,7 @@
 using System.Threading;
 using Content.Client.CombatMode;
 using Content.Client.Gameplay;
+using Content.Client.Mapping;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controllers;
 using Timer = Robust.Shared.Timing.Timer;
@@ -16,7 +17,7 @@ namespace Content.Client.ContextMenu.UI
     /// <remarks>
     ///     This largely involves setting up timers to open and close sub-menus when hovering over other menu elements.
     /// </remarks>
-    public sealed class ContextMenuUIController : UIController, IOnStateEntered<GameplayState>, IOnStateExited<GameplayState>, IOnSystemChanged<CombatModeSystem>
+    public sealed class ContextMenuUIController : UIController, IOnStateEntered<GameplayState>, IOnStateExited<GameplayState>, IOnSystemChanged<CombatModeSystem>, IOnStateEntered<MappingState>, IOnStateExited<MappingState>
     {
         public static readonly TimeSpan HoverDelay = TimeSpan.FromSeconds(0.2);
 
@@ -42,18 +43,51 @@ public sealed class ContextMenuUIController : UIController, IOnStateEntered<Game
         public Action<ContextMenuElement>? OnSubMenuOpened;
         public Action<ContextMenuElement, GUIBoundKeyEventArgs>? OnContextKeyEvent;
 
+        private bool _setup;
+
         public void OnStateEntered(GameplayState state)
         {
+            Setup();
+        }
+
+        public void OnStateExited(GameplayState state)
+        {
+            Shutdown();
+        }
+
+        public void OnStateEntered(MappingState state)
+        {
+            Setup();
+        }
+
+        public void OnStateExited(MappingState state)
+        {
+            Shutdown();
+        }
+
+        public void Setup()
+        {
+            if (_setup)
+                return;
+
+            _setup = true;
+
             RootMenu = new(this, null);
             RootMenu.OnPopupHide += Close;
             Menus.Push(RootMenu);
         }
 
-        public void OnStateExited(GameplayState state)
+        public void Shutdown()
         {
+            if (!_setup)
+                return;
+
+            _setup = false;
+
             Close();
             RootMenu.OnPopupHide -= Close;
             RootMenu.Dispose();
+            RootMenu = default!;
         }
 
         /// <summary>
diff --git a/Content.Client/DebugMon/DebugMonitorSystem.cs b/Content.Client/DebugMon/DebugMonitorManager.cs
similarity index 51%
rename from Content.Client/DebugMon/DebugMonitorSystem.cs
rename to Content.Client/DebugMon/DebugMonitorManager.cs
index fb5cd4f51a..7e1dca0d6f 100644
--- a/Content.Client/DebugMon/DebugMonitorSystem.cs
+++ b/Content.Client/DebugMon/DebugMonitorManager.cs
@@ -1,23 +1,28 @@
-using Content.Client.Administration.Managers;
+using Content.Client.Administration.Managers;
 using Content.Shared.CCVar;
+using Robust.Client;
 using Robust.Client.UserInterface;
 using Robust.Shared.Configuration;
 
-
 namespace Content.Client.DebugMon;
 
 /// <summary>
-/// This handles preventing certain debug monitors from appearing.
+/// This handles preventing certain debug monitors from being usable by non-admins.
 /// </summary>
-public sealed class DebugMonitorSystem : EntitySystem
+internal sealed class DebugMonitorManager
 {
     [Dependency] private readonly IConfigurationManager _cfg = default!;
     [Dependency] private readonly IClientAdminManager _admin = default!;
     [Dependency] private readonly IUserInterfaceManager _userInterface = default!;
+    [Dependency] private readonly IBaseClient _baseClient = default!;
 
-    public override void FrameUpdate(float frameTime)
+    public void FrameUpdate()
     {
-        if (!_admin.IsActive() && _cfg.GetCVar(CCVars.DebugCoordinatesAdminOnly))
+        if (_baseClient.RunLevel == ClientRunLevel.InGame
+            && !_admin.IsActive()
+            && _cfg.GetCVar(CCVars.DebugCoordinatesAdminOnly))
+        {
             _userInterface.DebugMonitors.SetMonitor(DebugMonitor.Coords, false);
+        }
     }
 }
diff --git a/Content.Client/Decals/Overlays/DecalPlacementOverlay.cs b/Content.Client/Decals/Overlays/DecalPlacementOverlay.cs
index 845bd7c03d..07b6f57bdb 100644
--- a/Content.Client/Decals/Overlays/DecalPlacementOverlay.cs
+++ b/Content.Client/Decals/Overlays/DecalPlacementOverlay.cs
@@ -4,6 +4,7 @@
 using Robust.Client.Input;
 using Robust.Shared.Enums;
 using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
 
 namespace Content.Client.Decals.Overlays;
 
@@ -16,7 +17,7 @@ public sealed class DecalPlacementOverlay : Overlay
     private readonly SharedTransformSystem _transform;
     private readonly SpriteSystem _sprite;
 
-    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+    public override OverlaySpace Space => OverlaySpace.WorldSpaceEntities;
 
     public DecalPlacementOverlay(DecalPlacementSystem placement, SharedTransformSystem transform, SpriteSystem sprite)
     {
@@ -24,6 +25,7 @@ public DecalPlacementOverlay(DecalPlacementSystem placement, SharedTransformSyst
         _placement = placement;
         _transform = transform;
         _sprite = sprite;
+        ZIndex = 1000;
     }
 
     protected override void Draw(in OverlayDrawArgs args)
@@ -55,7 +57,7 @@ protected override void Draw(in OverlayDrawArgs args)
 
         if (snap)
         {
-            localPos = (Vector2) localPos.Floored() + grid.TileSizeHalfVector;
+            localPos = localPos.Floored() + grid.TileSizeHalfVector;
         }
 
         // Nothing uses snap cardinals so probably don't need preview?
diff --git a/Content.Client/Electrocution/ElectrocutionOverlaySystem.cs b/Content.Client/Electrocution/ElectrocutionOverlaySystem.cs
new file mode 100644
index 0000000000..2751c498de
--- /dev/null
+++ b/Content.Client/Electrocution/ElectrocutionOverlaySystem.cs
@@ -0,0 +1,101 @@
+using Content.Shared.Electrocution;
+using Robust.Client.GameObjects;
+using Robust.Client.Player;
+using Robust.Shared.Player;
+
+namespace Content.Client.Electrocution;
+
+/// <summary>
+/// Shows the ElectrocutionOverlay to entities with the ElectrocutionOverlayComponent.
+/// </summary>
+public sealed class ElectrocutionOverlaySystem : EntitySystem
+{
+
+    [Dependency] private readonly AppearanceSystem _appearance = default!;
+    [Dependency] private readonly IPlayerManager _playerMan = default!;
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<ElectrocutionOverlayComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<ElectrocutionOverlayComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ElectrocutionOverlayComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<ElectrocutionOverlayComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+
+        SubscribeLocalEvent<ElectrifiedComponent, AppearanceChangeEvent>(OnAppearanceChange);
+    }
+
+    private void OnPlayerAttached(Entity<ElectrocutionOverlayComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        ShowOverlay();
+    }
+
+    private void OnPlayerDetached(Entity<ElectrocutionOverlayComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        RemoveOverlay();
+    }
+
+    private void OnInit(Entity<ElectrocutionOverlayComponent> ent, ref ComponentInit args)
+    {
+        if (_playerMan.LocalEntity == ent)
+        {
+            ShowOverlay();
+        }
+    }
+
+    private void OnShutdown(Entity<ElectrocutionOverlayComponent> ent, ref ComponentShutdown args)
+    {
+        if (_playerMan.LocalEntity == ent)
+        {
+            RemoveOverlay();
+        }
+    }
+
+    private void ShowOverlay()
+    {
+        var electrifiedQuery = AllEntityQuery<ElectrifiedComponent, AppearanceComponent, SpriteComponent>();
+        while (electrifiedQuery.MoveNext(out var uid, out var _, out var appearanceComp, out var spriteComp))
+        {
+            if (!_appearance.TryGetData<bool>(uid, ElectrifiedVisuals.IsElectrified, out var electrified, appearanceComp))
+                continue;
+
+            if (!spriteComp.LayerMapTryGet(ElectrifiedLayers.Overlay, out var layer))
+                continue;
+
+            if (electrified)
+                spriteComp.LayerSetVisible(ElectrifiedLayers.Overlay, true);
+            else
+                spriteComp.LayerSetVisible(ElectrifiedLayers.Overlay, false);
+        }
+    }
+
+    private void RemoveOverlay()
+    {
+        var electrifiedQuery = AllEntityQuery<ElectrifiedComponent, AppearanceComponent, SpriteComponent>();
+        while (electrifiedQuery.MoveNext(out var uid, out var _, out var appearanceComp, out var spriteComp))
+        {
+            if (!spriteComp.LayerMapTryGet(ElectrifiedLayers.Overlay, out var layer))
+                continue;
+
+            spriteComp.LayerSetVisible(layer, false);
+        }
+    }
+
+    private void OnAppearanceChange(Entity<ElectrifiedComponent> ent, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+            return;
+
+        if (!_appearance.TryGetData<bool>(ent.Owner, ElectrifiedVisuals.IsElectrified, out var electrified, args.Component))
+            return;
+
+        if (!args.Sprite.LayerMapTryGet(ElectrifiedLayers.Overlay, out var layer))
+            return;
+
+        var player = _playerMan.LocalEntity;
+        if (electrified && HasComp<ElectrocutionOverlayComponent>(player))
+            args.Sprite.LayerSetVisible(layer, true);
+        else
+            args.Sprite.LayerSetVisible(layer, false);
+    }
+}
diff --git a/Content.Client/Entry/EntryPoint.cs b/Content.Client/Entry/EntryPoint.cs
index 05d3454f48..8907d9bd47 100644
--- a/Content.Client/Entry/EntryPoint.cs
+++ b/Content.Client/Entry/EntryPoint.cs
@@ -3,6 +3,7 @@
 using Content.Client.Chat.Managers;
 using Content.Client.DiscordAuth;
 using Content.Client.JoinQueue;
+using Content.Client.DebugMon;
 using Content.Client.Eui;
 using Content.Client.Flash;
 using Content.Client.Fullscreen;
@@ -36,6 +37,7 @@
 using Robust.Shared.ContentPack;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Replays;
+using Robust.Shared.Timing;
 
 namespace Content.Client.Entry
 {
@@ -72,6 +74,8 @@ public sealed class EntryPoint : GameClient
         [Dependency] private readonly ILogManager _logManager = default!;
         [Dependency] private readonly JoinQueueManager _joinQueue = default!;
         [Dependency] private readonly DiscordAuthManager _discordAuth = default!;
+        [Dependency] private readonly ContentReplayPlaybackManager _replayMan = default!;
+        [Dependency] private readonly DebugMonitorManager _debugMonitorManager = default!;
 
         public override void Init()
         {
@@ -213,5 +217,13 @@ private void SwitchToDefaultState(bool disconnected = false)
                 _stateManager.RequestStateChange<MainScreen>();
             }
         }
+
+        public override void Update(ModUpdateLevel level, FrameEventArgs frameEventArgs)
+        {
+            if (level == ModUpdateLevel.FramePreEngine)
+            {
+                _debugMonitorManager.FrameUpdate();
+            }
+        }
     }
 }
diff --git a/Content.Client/IoC/ClientContentIoC.cs b/Content.Client/IoC/ClientContentIoC.cs
index 6d181c52b8..41d2ff33e4 100644
--- a/Content.Client/IoC/ClientContentIoC.cs
+++ b/Content.Client/IoC/ClientContentIoC.cs
@@ -5,18 +5,21 @@
 using Content.Client.DeltaV.NanoChat;
 using Content.Client.DiscordAuth;
 using Content.Client.JoinQueue;
+using Content.Client.DebugMon;
 using Content.Client.Eui;
+using Content.Client.Fullscreen;
 using Content.Client.GhostKick;
+using Content.Client.Guidebook;
 using Content.Client.Launcher;
+using Content.Client.Mapping;
 using Content.Client.Parallax.Managers;
 using Content.Client.Players.PlayTimeTracking;
+using Content.Client.Replay;
 using Content.Client.Screenshot;
-using Content.Client.Fullscreen;
 using Content.Client.Stylesheets;
 using Content.Client.Viewport;
 using Content.Client.Voting;
 using Content.Shared.Administration.Logs;
-using Content.Client.Guidebook;
 using Content.Client.Lobby;
 using Content.Client.Players.RateLimiting;
 using Content.Client.Replay;
@@ -26,7 +29,6 @@
 using Content.Shared.Players.RateLimiting;
 using Robust.Client.GameObjects;
 
-
 namespace Content.Client.IoC
 {
     internal static class ClientContentIoC
@@ -61,6 +63,8 @@ public static void Register()
             collection.Register<PlayerRateLimitManager>();
             collection.Register<SharedPlayerRateLimitManager, PlayerRateLimitManager>();
             collection.Register<NanoChatSystem>();
+            collection.Register<MappingManager>();
+            collection.Register<DebugMonitorManager>();
         }
     }
 }
diff --git a/Content.Client/Mapping/MappingActionsButton.xaml b/Content.Client/Mapping/MappingActionsButton.xaml
new file mode 100644
index 0000000000..099719a70e
--- /dev/null
+++ b/Content.Client/Mapping/MappingActionsButton.xaml
@@ -0,0 +1,8 @@
+<mapping:MappingActionsButton
+    xmlns="https://spacestation14.io"
+    xmlns:mapping="clr-namespace:Content.Client.Mapping"
+    StyleClasses="ButtonSquare" ToggleMode="True" SetSize="32 32" Margin="0 0 5 0"
+    TooltipDelay="0">
+    <TextureRect Name="Texture" Access="Public" Stretch="Scale" SetSize="16 16"
+                 HorizontalAlignment="Center" VerticalAlignment="Center" />
+</mapping:MappingActionsButton>
diff --git a/Content.Client/Mapping/MappingActionsButton.xaml.cs b/Content.Client/Mapping/MappingActionsButton.xaml.cs
new file mode 100644
index 0000000000..1a2f2c069f
--- /dev/null
+++ b/Content.Client/Mapping/MappingActionsButton.xaml.cs
@@ -0,0 +1,15 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.Mapping;
+
+[GenerateTypedNameReferences]
+public sealed partial class MappingActionsButton : Button
+{
+    public MappingActionsButton()
+    {
+        RobustXamlLoader.Load(this);
+    }
+}
+
diff --git a/Content.Client/Mapping/MappingDoNotMeasure.xaml b/Content.Client/Mapping/MappingDoNotMeasure.xaml
new file mode 100644
index 0000000000..08909636ee
--- /dev/null
+++ b/Content.Client/Mapping/MappingDoNotMeasure.xaml
@@ -0,0 +1,4 @@
+<mapping:MappingDoNotMeasure
+    xmlns="https://spacestation14.io"
+    xmlns:mapping="clr-namespace:Content.Client.Mapping">
+</mapping:MappingDoNotMeasure>
diff --git a/Content.Client/Mapping/MappingDoNotMeasure.xaml.cs b/Content.Client/Mapping/MappingDoNotMeasure.xaml.cs
new file mode 100644
index 0000000000..c4cb560234
--- /dev/null
+++ b/Content.Client/Mapping/MappingDoNotMeasure.xaml.cs
@@ -0,0 +1,21 @@
+using System.Numerics;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.Mapping;
+
+[GenerateTypedNameReferences]
+public sealed partial class MappingDoNotMeasure : Control
+{
+    public MappingDoNotMeasure()
+    {
+        RobustXamlLoader.Load(this);
+    }
+
+    protected override Vector2 MeasureOverride(Vector2 availableSize)
+    {
+        return Vector2.Zero;
+    }
+}
+
diff --git a/Content.Client/Mapping/MappingManager.cs b/Content.Client/Mapping/MappingManager.cs
new file mode 100644
index 0000000000..1aac02be71
--- /dev/null
+++ b/Content.Client/Mapping/MappingManager.cs
@@ -0,0 +1,69 @@
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Content.Shared.Mapping;
+using Robust.Client.UserInterface;
+using Robust.Shared.Network;
+
+namespace Content.Client.Mapping;
+
+public sealed class MappingManager : IPostInjectInit
+{
+    [Dependency] private readonly IFileDialogManager _file = default!;
+    [Dependency] private readonly IClientNetManager _net = default!;
+
+    private Stream? _saveStream;
+    private MappingMapDataMessage? _mapData;
+
+    public void PostInject()
+    {
+        _net.RegisterNetMessage<MappingSaveMapMessage>();
+        _net.RegisterNetMessage<MappingSaveMapErrorMessage>(OnSaveError);
+        _net.RegisterNetMessage<MappingMapDataMessage>(OnMapData);
+    }
+
+    private void OnSaveError(MappingSaveMapErrorMessage message)
+    {
+        _saveStream?.DisposeAsync();
+        _saveStream = null;
+    }
+
+    private async void OnMapData(MappingMapDataMessage message)
+    {
+        if (_saveStream == null)
+        {
+            _mapData = message;
+            return;
+        }
+
+        await _saveStream.WriteAsync(Encoding.ASCII.GetBytes(message.Yml));
+        await _saveStream.DisposeAsync();
+
+        _saveStream = null;
+        _mapData = null;
+    }
+
+    public async Task SaveMap()
+    {
+        if (_saveStream != null)
+            await _saveStream.DisposeAsync();
+
+        var request = new MappingSaveMapMessage();
+        _net.ClientSendMessage(request);
+
+        var path = await _file.SaveFile();
+        if (path is not { fileStream: var stream })
+            return;
+
+        if (_mapData != null)
+        {
+            await stream.WriteAsync(Encoding.ASCII.GetBytes(_mapData.Yml));
+            _mapData = null;
+            await stream.FlushAsync();
+            await stream.DisposeAsync();
+            return;
+        }
+
+        _saveStream = stream;
+    }
+}
diff --git a/Content.Client/Mapping/MappingOverlay.cs b/Content.Client/Mapping/MappingOverlay.cs
new file mode 100644
index 0000000000..ef9f3e795e
--- /dev/null
+++ b/Content.Client/Mapping/MappingOverlay.cs
@@ -0,0 +1,84 @@
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.Player;
+using Robust.Client.UserInterface;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+using static Content.Client.Mapping.MappingState;
+
+namespace Content.Client.Mapping;
+
+public sealed class MappingOverlay : Overlay
+{
+    [Dependency] private readonly IEntityManager _entities = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IPrototypeManager _prototypes = default!;
+
+    // 1 off in case something else uses these colors since we use them to compare
+    private static readonly Color PickColor = new(1, 255, 0);
+    private static readonly Color DeleteColor = new(255, 1, 0);
+
+    private readonly Dictionary<EntityUid, Color> _oldColors = new();
+
+    private readonly MappingState _state;
+    private readonly ShaderInstance _shader;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+    public MappingOverlay(MappingState state)
+    {
+        IoCManager.InjectDependencies(this);
+
+        _state = state;
+        _shader = _prototypes.Index<ShaderPrototype>("unshaded").Instance();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        foreach (var (id, color) in _oldColors)
+        {
+            if (!_entities.TryGetComponent(id, out SpriteComponent? sprite))
+                continue;
+
+            if (sprite.Color == DeleteColor || sprite.Color == PickColor)
+                sprite.Color = color;
+        }
+
+        _oldColors.Clear();
+
+        if (_player.LocalEntity == null)
+            return;
+
+        var handle = args.WorldHandle;
+        handle.UseShader(_shader);
+
+        switch (_state.State)
+        {
+            case CursorState.Pick:
+            {
+                if (_state.GetHoveredEntity() is { } entity &&
+                    _entities.TryGetComponent(entity, out SpriteComponent? sprite))
+                {
+                    _oldColors[entity] = sprite.Color;
+                    sprite.Color = PickColor;
+                }
+
+                break;
+            }
+            case CursorState.Delete:
+            {
+                if (_state.GetHoveredEntity() is { } entity &&
+                    _entities.TryGetComponent(entity, out SpriteComponent? sprite))
+                {
+                    _oldColors[entity] = sprite.Color;
+                    sprite.Color = DeleteColor;
+                }
+
+                break;
+            }
+        }
+
+        handle.UseShader(null);
+    }
+}
diff --git a/Content.Client/Mapping/MappingPrototype.cs b/Content.Client/Mapping/MappingPrototype.cs
new file mode 100644
index 0000000000..eff2dfab15
--- /dev/null
+++ b/Content.Client/Mapping/MappingPrototype.cs
@@ -0,0 +1,39 @@
+using Content.Shared.Decals;
+using Content.Shared.Maps;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Mapping;
+
+/// <summary>
+///     Used to represent a button's data in the mapping editor.
+/// </summary>
+public sealed class MappingPrototype
+{
+    /// <summary>
+    ///     The prototype instance, if any.
+    ///     Can be one of <see cref="EntityPrototype"/>, <see cref="ContentTileDefinition"/> or <see cref="DecalPrototype"/>
+    ///     If null, this is a top-level button (such as Entities, Tiles or Decals)
+    /// </summary>
+    public readonly IPrototype? Prototype;
+
+    /// <summary>
+    ///     The text to display on the UI for this button.
+    /// </summary>
+    public readonly string Name;
+
+    /// <summary>
+    ///     Which other prototypes (buttons) this one is nested inside of.
+    /// </summary>
+    public List<MappingPrototype>? Parents;
+
+    /// <summary>
+    ///     Which other prototypes (buttons) are nested inside this one.
+    /// </summary>
+    public List<MappingPrototype>? Children;
+
+    public MappingPrototype(IPrototype? prototype, string name)
+    {
+        Prototype = prototype;
+        Name = name;
+    }
+}
diff --git a/Content.Client/Mapping/MappingPrototypeList.xaml b/Content.Client/Mapping/MappingPrototypeList.xaml
new file mode 100644
index 0000000000..de311240df
--- /dev/null
+++ b/Content.Client/Mapping/MappingPrototypeList.xaml
@@ -0,0 +1,21 @@
+<mapping:MappingPrototypeList
+    xmlns="https://spacestation14.io"
+    xmlns:mapping="clr-namespace:Content.Client.Mapping">
+    <BoxContainer Orientation="Vertical">
+        <BoxContainer Orientation="Horizontal">
+            <Button Name="CollapseAllButton" Access="Public" Text="-" SetSize="48 48"
+                    StyleClasses="ButtonSquare" ToolTip="Collapse All" TooltipDelay="0" />
+            <LineEdit Name="SearchBar" SetHeight="48" HorizontalExpand="True" Access="Public" />
+            <Button Name="ClearSearchButton" Access="Public" Text="X" SetSize="48 48"
+                    StyleClasses="ButtonSquare" />
+        </BoxContainer>
+        <ScrollContainer Name="ScrollContainer" Access="Public" VerticalExpand="True"
+                         ReserveScrollbarSpace="True">
+            <BoxContainer Name="PrototypeList" Access="Public" Orientation="Vertical" />
+            <PrototypeListContainer Name="SearchList" Access="Public" Visible="False" />
+        </ScrollContainer>
+        <mapping:MappingDoNotMeasure Visible="False">
+            <mapping:MappingSpawnButton Name="MeasureButton" Access="Public" />
+        </mapping:MappingDoNotMeasure>
+    </BoxContainer>
+</mapping:MappingPrototypeList>
diff --git a/Content.Client/Mapping/MappingPrototypeList.xaml.cs b/Content.Client/Mapping/MappingPrototypeList.xaml.cs
new file mode 100644
index 0000000000..8b59e6eb6f
--- /dev/null
+++ b/Content.Client/Mapping/MappingPrototypeList.xaml.cs
@@ -0,0 +1,170 @@
+using System.Numerics;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using static Robust.Client.UserInterface.Controls.BaseButton;
+
+namespace Content.Client.Mapping;
+
+[GenerateTypedNameReferences]
+public sealed partial class MappingPrototypeList : Control
+{
+    private (int start, int end) _lastIndices;
+    private readonly List<MappingPrototype> _prototypes = new();
+    private readonly List<Texture> _insertTextures = new();
+    private readonly List<MappingPrototype> _search = new();
+
+    public MappingSpawnButton? Selected;
+    public Action<IPrototype, List<Texture>>? GetPrototypeData;
+    public event Action<MappingSpawnButton, IPrototype?>? SelectionChanged;
+    public event Action<MappingSpawnButton, ButtonToggledEventArgs>? CollapseToggled;
+
+    public MappingPrototypeList()
+    {
+        RobustXamlLoader.Load(this);
+
+        MeasureButton.Measure(Vector2Helpers.Infinity);
+
+        ScrollContainer.OnScrolled += UpdateSearch;
+        OnResized += UpdateSearch;
+    }
+
+    public void UpdateVisible(List<MappingPrototype> prototypes)
+    {
+        _prototypes.Clear();
+
+        PrototypeList.DisposeAllChildren();
+
+        _prototypes.AddRange(prototypes);
+
+        Selected = null;
+        ScrollContainer.SetScrollValue(new Vector2(0, 0));
+
+        foreach (var prototype in _prototypes)
+        {
+            Insert(PrototypeList, prototype, true);
+        }
+    }
+
+    public MappingSpawnButton Insert(Container list, MappingPrototype mapping, bool includeChildren)
+    {
+        var prototype = mapping.Prototype;
+
+        _insertTextures.Clear();
+
+        if (prototype != null)
+            GetPrototypeData?.Invoke(prototype, _insertTextures);
+
+        var button = new MappingSpawnButton { Prototype = mapping };
+        button.Label.Text = mapping.Name;
+
+        if (_insertTextures.Count > 0)
+        {
+            button.Texture.Textures.AddRange(_insertTextures);
+            button.Texture.InvalidateMeasure();
+        }
+        else
+        {
+            button.Texture.Visible = false;
+        }
+
+        if (prototype != null && button.Prototype == Selected?.Prototype)
+        {
+            Selected = button;
+            button.Button.Pressed = true;
+        }
+
+        list.AddChild(button);
+
+        button.Button.OnToggled += _ => SelectionChanged?.Invoke(button, prototype);
+
+        if (includeChildren && mapping.Children?.Count > 0)
+        {
+            button.CollapseButton.Visible = true;
+            button.CollapseButton.OnToggled += args => CollapseToggled?.Invoke(button, args);
+        }
+        else
+        {
+            button.CollapseButtonWrapper.Visible = false;
+            button.CollapseButton.Visible = false;
+        }
+
+        return button;
+    }
+
+    public void Search(List<MappingPrototype> prototypes)
+    {
+        _search.Clear();
+        SearchList.DisposeAllChildren();
+        _lastIndices = (0, -1);
+
+        _search.AddRange(prototypes);
+        SearchList.TotalItemCount = _search.Count;
+        ScrollContainer.SetScrollValue(new Vector2(0, 0));
+
+        UpdateSearch();
+    }
+
+    /// <summary>
+    ///     Constructs a virtual list where not all buttons exist at one time, since there may be thousands of them.
+    /// </summary>
+    private void UpdateSearch()
+    {
+        if (!SearchList.Visible)
+            return;
+
+        var height = MeasureButton.DesiredSize.Y + PrototypeListContainer.Separation;
+        var offset = Math.Max(-SearchList.Position.Y, 0);
+        var startIndex = (int) Math.Floor(offset / height);
+        SearchList.ItemOffset = startIndex;
+
+        var (prevStart, prevEnd) = _lastIndices;
+        var endIndex = startIndex - 1;
+        var spaceUsed = -height;
+
+        // calculate how far down we are scrolled
+        while (spaceUsed < SearchList.Parent!.Height)
+        {
+            spaceUsed += height;
+            endIndex += 1;
+        }
+
+        endIndex = Math.Min(endIndex, _search.Count - 1);
+
+        // nothing changed in terms of which buttons are visible now and before
+        if (endIndex == prevEnd && startIndex == prevStart)
+            return;
+
+        _lastIndices = (startIndex, endIndex);
+
+        // remove previously seen but now unseen buttons from the top
+        for (var i = prevStart; i < startIndex && i <= prevEnd; i++)
+        {
+            var control = SearchList.GetChild(0);
+            SearchList.RemoveChild(control);
+        }
+
+        // remove previously seen but now unseen buttons from the bottom
+        for (var i = prevEnd; i > endIndex && i >= prevStart; i--)
+        {
+            var control = SearchList.GetChild(SearchList.ChildCount - 1);
+            SearchList.RemoveChild(control);
+        }
+
+        // insert buttons that can now be seen, from the start
+        for (var i = Math.Min(prevStart - 1, endIndex); i >= startIndex; i--)
+        {
+            Insert(SearchList, _search[i], false).SetPositionInParent(0);
+        }
+
+        // insert buttons that can now be seen, from the end
+        for (var i = Math.Max(prevEnd + 1, startIndex); i <= endIndex; i++)
+        {
+            Insert(SearchList, _search[i], false);
+        }
+    }
+}
diff --git a/Content.Client/Mapping/MappingScreen.xaml b/Content.Client/Mapping/MappingScreen.xaml
new file mode 100644
index 0000000000..b641360847
--- /dev/null
+++ b/Content.Client/Mapping/MappingScreen.xaml
@@ -0,0 +1,85 @@
+<mapping:MappingScreen
+    xmlns="https://spacestation14.io"
+    xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+    xmlns:widgets="clr-namespace:Content.Client.UserInterface.Systems.Chat.Widgets"
+    xmlns:hotbar="clr-namespace:Content.Client.UserInterface.Systems.Hotbar.Widgets"
+    xmlns:graphics="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+    xmlns:mapping="clr-namespace:Content.Client.Mapping"
+    VerticalExpand="False"
+    VerticalAlignment="Bottom"
+    HorizontalAlignment="Center">
+    <controls:RecordedSplitContainer Name="ScreenContainer" HorizontalExpand="True"
+                                     VerticalExpand="True" SplitWidth="0"
+                                     StretchDirection="TopLeft">
+        <BoxContainer Orientation="Vertical" VerticalExpand="True" Name="SpawnContainer" MinWidth="200" SetWidth="600">
+            <mapping:MappingPrototypeList Name="Prototypes" Access="Public" VerticalExpand="True" />
+            <BoxContainer Name="DecalContainer" Access="Public" Orientation="Horizontal"
+                          Visible="False">
+                <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                    <ColorSelectorSliders Name="DecalColorPicker" IsAlphaVisible="True" />
+                    <Button Name="DecalPickerOpen" Text="{Loc decal-placer-window-palette}"
+                            StyleClasses="ButtonSquare" />
+                </BoxContainer>
+                <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                    <CheckBox Name="DecalEnableAuto" Margin="0 0 0 10"
+                              Text="{Loc decal-placer-window-enable-auto}" />
+                    <CheckBox Name="DecalEnableSnap"
+                              Text="{Loc decal-placer-window-enable-snap}" />
+                    <CheckBox Name="DecalEnableCleanable"
+                              Text="{Loc decal-placer-window-enable-cleanable}" />
+                    <BoxContainer Name="DecalSpinBoxContainer" Orientation="Horizontal">
+                        <Label Text="{Loc decal-placer-window-rotation}" Margin="0 0 0 1" />
+                    </BoxContainer>
+                    <BoxContainer Orientation="Horizontal">
+                        <Label Text="{Loc decal-placer-window-zindex}" Margin="0 0 0 1" />
+                        <SpinBox Name="DecalZIndexSpinBox" HorizontalExpand="True" />
+                    </BoxContainer>
+                </BoxContainer>
+            </BoxContainer>
+            <BoxContainer Name="EntityContainer" Access="Public" Orientation="Horizontal"
+                          Visible="False">
+                <Button Name="EntityReplaceButton" Access="Public" ToggleMode="True"
+                        SetHeight="48"
+                        StyleClasses="ButtonSquare" Text="{Loc 'mapping-replace'}" HorizontalExpand="True" />
+                <OptionButton Name="EntityPlacementMode" Access="Public"
+                              SetHeight="48"
+                              StyleClasses="ButtonSquare" TooltipDelay="0"
+                              ToolTip="{Loc entity-spawn-window-override-menu-tooltip}"
+                              HorizontalExpand="True" />
+            </BoxContainer>
+            <BoxContainer Orientation="Horizontal">
+                <Button Name="EraseEntityButton" Access="Public" HorizontalExpand="True"
+                        SetHeight="48"
+                        ToggleMode="True" Text="{Loc 'mapping-erase-entity'}" StyleClasses="ButtonSquare" />
+                <Button Name="EraseDecalButton" Access="Public" HorizontalExpand="True"
+                        SetHeight="48"
+                        ToggleMode="True" Text="{Loc 'mapping-erase-decal'}" StyleClasses="ButtonSquare" />
+            </BoxContainer>
+            <widgets:ChatBox Visible="False" />
+        </BoxContainer>
+        <LayoutContainer Name="ViewportContainer" HorizontalExpand="True" VerticalExpand="True">
+            <controls:MainViewport Name="MainViewport"/>
+            <hotbar:HotbarGui Name="Hotbar" />
+            <PanelContainer Name="Actions" VerticalExpand="True" HorizontalExpand="True"
+                            MaxHeight="48">
+                <PanelContainer.PanelOverride>
+                    <graphics:StyleBoxFlat BackgroundColor="#222222AA" />
+                </PanelContainer.PanelOverride>
+                <BoxContainer Orientation="Horizontal" Margin="15 10">
+                    <mapping:MappingActionsButton
+                        Name="Add" Access="Public" Disabled="True" ToolTip="" Visible="False" />
+                    <mapping:MappingActionsButton Name="Fill" Access="Public"
+                                                  ToolTip="" Visible="False" />
+                    <mapping:MappingActionsButton Name="Grab" Access="Public"
+                                                  ToolTip="" Visible="False" />
+                    <mapping:MappingActionsButton Name="Move" Access="Public"
+                                                  ToolTip="" Visible="False" />
+                    <mapping:MappingActionsButton Name="Pick" Access="Public"
+                                                  ToolTip="Pick (Hold 5)" />
+                    <mapping:MappingActionsButton Name="Delete" Access="Public"
+                                                  ToolTip="Delete (Hold 6)" />
+                </BoxContainer>
+            </PanelContainer>
+        </LayoutContainer>
+    </controls:RecordedSplitContainer>
+</mapping:MappingScreen>
diff --git a/Content.Client/Mapping/MappingScreen.xaml.cs b/Content.Client/Mapping/MappingScreen.xaml.cs
new file mode 100644
index 0000000000..b2ad2fd83f
--- /dev/null
+++ b/Content.Client/Mapping/MappingScreen.xaml.cs
@@ -0,0 +1,197 @@
+using System.Linq;
+using System.Numerics;
+using Content.Client.Decals;
+using Content.Client.Decals.UI;
+using Content.Client.UserInterface.Screens;
+using Content.Client.UserInterface.Systems.Chat.Widgets;
+using Content.Shared.Decals;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using static Robust.Client.UserInterface.Controls.BaseButton;
+
+namespace Content.Client.Mapping;
+
+[GenerateTypedNameReferences]
+public sealed partial class MappingScreen : InGameScreen
+{
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+
+    public DecalPlacementSystem DecalSystem = default!;
+
+    private PaletteColorPicker? _picker;
+
+    private ProtoId<DecalPrototype>? _id;
+    private Color _decalColor = Color.White;
+    private float _decalRotation;
+    private bool _decalSnap;
+    private int _decalZIndex;
+    private bool _decalCleanable;
+
+    private bool _decalAuto;
+
+    public override ChatBox ChatBox => GetWidget<ChatBox>()!;
+
+    public event Func<MappingSpawnButton, bool>? IsDecalVisible;
+
+    public MappingScreen()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        AutoscaleMaxResolution = new Vector2i(1080, 770);
+
+        SetAnchorPreset(ScreenContainer, LayoutPreset.Wide);
+        SetAnchorPreset(ViewportContainer, LayoutPreset.Wide);
+        SetAnchorPreset(SpawnContainer, LayoutPreset.Wide);
+        SetAnchorPreset(MainViewport, LayoutPreset.Wide);
+        SetAnchorAndMarginPreset(Hotbar, LayoutPreset.BottomWide, margin: 5);
+        SetAnchorAndMarginPreset(Actions, LayoutPreset.TopWide, margin: 5);
+
+        ScreenContainer.OnSplitResizeFinished += () =>
+            OnChatResized?.Invoke(new Vector2(ScreenContainer.SplitFraction, 0));
+
+        var rotationSpinBox = new FloatSpinBox(90.0f, 0)
+        {
+            HorizontalExpand = true
+        };
+        DecalSpinBoxContainer.AddChild(rotationSpinBox);
+
+        DecalColorPicker.OnColorChanged += OnDecalColorPicked;
+        DecalPickerOpen.OnPressed += OnDecalPickerOpenPressed;
+        rotationSpinBox.OnValueChanged += args =>
+        {
+            _decalRotation = args.Value;
+            UpdateDecal();
+        };
+        DecalEnableAuto.OnToggled += args =>
+        {
+            _decalAuto = args.Pressed;
+            if (_id is { } id)
+                SelectDecal(id);
+        };
+        DecalEnableSnap.OnToggled += args =>
+        {
+            _decalSnap = args.Pressed;
+            UpdateDecal();
+        };
+        DecalEnableCleanable.OnToggled += args =>
+        {
+            _decalCleanable = args.Pressed;
+            UpdateDecal();
+        };
+        DecalZIndexSpinBox.ValueChanged += args =>
+        {
+            _decalZIndex = args.Value;
+            UpdateDecal();
+        };
+
+        for (var i = 0; i < EntitySpawnWindow.InitOpts.Length; i++)
+        {
+            EntityPlacementMode.AddItem(EntitySpawnWindow.InitOpts[i], i);
+        }
+
+        Pick.Texture.TexturePath = "/Textures/Interface/eyedropper.svg.png";
+        Delete.Texture.TexturePath = "/Textures/Interface/eraser.svg.png";
+    }
+
+    private void OnDecalColorPicked(Color color)
+    {
+        _decalColor = color;
+        DecalColorPicker.Color = color;
+        UpdateDecal();
+    }
+
+    private void OnDecalPickerOpenPressed(ButtonEventArgs obj)
+    {
+        if (_picker == null)
+        {
+            _picker = new PaletteColorPicker();
+            _picker.OpenToLeft();
+            _picker.PaletteList.OnItemSelected += args =>
+            {
+                var color = ((Color?) args.ItemList.GetSelected().First().Metadata)!.Value;
+                OnDecalColorPicked(color);
+            };
+
+            return;
+        }
+
+        if (_picker.IsOpen)
+            _picker.Close();
+        else
+            _picker.Open();
+    }
+
+    private void UpdateDecal()
+    {
+        if (_id is not { } id)
+            return;
+
+        DecalSystem.UpdateDecalInfo(id, _decalColor, _decalRotation, _decalSnap, _decalZIndex, _decalCleanable);
+    }
+
+    public void SelectDecal(string decalId)
+    {
+        if (!_prototype.TryIndex<DecalPrototype>(decalId, out var decal))
+            return;
+
+        _id = decalId;
+
+        if (_decalAuto)
+        {
+            _decalColor = Color.White;
+            _decalCleanable = decal.DefaultCleanable;
+            _decalSnap = decal.DefaultSnap;
+
+            DecalColorPicker.Color = _decalColor;
+            DecalEnableCleanable.Pressed = _decalCleanable;
+            DecalEnableSnap.Pressed = _decalSnap;
+        }
+
+        UpdateDecal();
+        RefreshList();
+    }
+
+    private void RefreshList()
+    {
+        foreach (var control in Prototypes.Children)
+        {
+            if (control is not MappingSpawnButton button ||
+                button.Prototype?.Prototype is not DecalPrototype)
+            {
+                continue;
+            }
+
+            foreach (var child in button.Children)
+            {
+                if (child is not MappingSpawnButton { Prototype.Prototype: DecalPrototype } childButton)
+                {
+                    continue;
+                }
+
+                childButton.Texture.Modulate = _decalColor;
+                childButton.Visible = IsDecalVisible?.Invoke(childButton) ?? true;
+            }
+        }
+    }
+
+    public override void SetChatSize(Vector2 size)
+    {
+        ScreenContainer.DesiredSplitCenter = size.X;
+        ScreenContainer.ResizeMode = SplitContainer.SplitResizeMode.RespectChildrenMinSize;
+    }
+
+    public void UnPressActionsExcept(Control except)
+    {
+        Add.Pressed = Add == except;
+        Fill.Pressed = Fill == except;
+        Grab.Pressed = Grab == except;
+        Move.Pressed = Move == except;
+        Pick.Pressed = Pick == except;
+        Delete.Pressed = Delete == except;
+    }
+}
diff --git a/Content.Client/Mapping/MappingSpawnButton.xaml b/Content.Client/Mapping/MappingSpawnButton.xaml
new file mode 100644
index 0000000000..a944d5ec2f
--- /dev/null
+++ b/Content.Client/Mapping/MappingSpawnButton.xaml
@@ -0,0 +1,26 @@
+<mapping:MappingSpawnButton
+    xmlns="https://spacestation14.io"
+    xmlns:mapping="clr-namespace:Content.Client.Mapping">
+    <BoxContainer Orientation="Vertical">
+        <Control>
+            <Button Name="Button" Access="Public" ToggleMode="True" StyleClasses="ButtonSquare" />
+            <BoxContainer Orientation="Horizontal">
+                <LayeredTextureRect Name="Texture" Access="Public" MinSize="48 48"
+                                    HorizontalAlignment="Center" VerticalAlignment="Center"
+                                    Stretch="KeepAspectCentered" CanShrink="True" />
+                <Control SetSize="48 48" Access="Public" Name="CollapseButtonWrapper">
+                    <Button Name="CollapseButton" Access="Public" Text="▶"
+                            ToggleMode="True" StyleClasses="ButtonSquare" SetSize="48 48" />
+                </Control>
+                <Label Name="Label" Access="Public"
+                       VAlign="Center"
+                       VerticalExpand="True"
+                       MinHeight="48"
+                       Margin="5 0"
+                       HorizontalExpand="True" ClipText="True" />
+            </BoxContainer>
+        </Control>
+        <BoxContainer Name="ChildrenPrototypes" Access="Public" Orientation="Vertical"
+                      Margin="24 0 0 0" />
+    </BoxContainer>
+</mapping:MappingSpawnButton>
diff --git a/Content.Client/Mapping/MappingSpawnButton.xaml.cs b/Content.Client/Mapping/MappingSpawnButton.xaml.cs
new file mode 100644
index 0000000000..29fb884ed6
--- /dev/null
+++ b/Content.Client/Mapping/MappingSpawnButton.xaml.cs
@@ -0,0 +1,16 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.Mapping;
+
+[GenerateTypedNameReferences]
+public sealed partial class MappingSpawnButton : Control
+{
+    public MappingPrototype? Prototype;
+
+    public MappingSpawnButton()
+    {
+        RobustXamlLoader.Load(this);
+    }
+}
diff --git a/Content.Client/Mapping/MappingState.cs b/Content.Client/Mapping/MappingState.cs
new file mode 100644
index 0000000000..bcc739fe4f
--- /dev/null
+++ b/Content.Client/Mapping/MappingState.cs
@@ -0,0 +1,936 @@
+using System.Linq;
+using System.Numerics;
+using Content.Client.Administration.Managers;
+using Content.Client.ContextMenu.UI;
+using Content.Client.Decals;
+using Content.Client.Gameplay;
+using Content.Client.UserInterface.Controls;
+using Content.Client.UserInterface.Systems.Gameplay;
+using Content.Client.Verbs;
+using Content.Shared.Administration;
+using Content.Shared.Decals;
+using Content.Shared.Input;
+using Content.Shared.Maps;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.Placement;
+using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Enums;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+using static System.StringComparison;
+using static Robust.Client.UserInterface.Controls.BaseButton;
+using static Robust.Client.UserInterface.Controls.LineEdit;
+using static Robust.Client.UserInterface.Controls.OptionButton;
+using static Robust.Shared.Input.Binding.PointerInputCmdHandler;
+
+namespace Content.Client.Mapping;
+
+public sealed class MappingState : GameplayStateBase
+{
+    [Dependency] private readonly IClientAdminManager _admin = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IEntityNetworkManager _entityNetwork = default!;
+    [Dependency] private readonly IInputManager _input = default!;
+    [Dependency] private readonly ILogManager _log = default!;
+    [Dependency] private readonly IMapManager _mapMan = default!;
+    [Dependency] private readonly MappingManager _mapping = default!;
+    [Dependency] private readonly IOverlayManager _overlays = default!;
+    [Dependency] private readonly IPlacementManager _placement = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IResourceCache _resources = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    private EntityMenuUIController _entityMenuController = default!;
+
+    private DecalPlacementSystem _decal = default!;
+    private SpriteSystem _sprite = default!;
+    private TransformSystem _transform = default!;
+    private VerbSystem _verbs = default!;
+
+    private readonly ISawmill _sawmill;
+    private readonly GameplayStateLoadController _loadController;
+    private bool _setup;
+    private readonly List<MappingPrototype> _allPrototypes = new();
+    private readonly Dictionary<IPrototype, MappingPrototype> _allPrototypesDict = new();
+    private readonly Dictionary<Type, Dictionary<string, MappingPrototype>> _idDict = new();
+    private readonly List<MappingPrototype> _prototypes = new();
+    private (TimeSpan At, MappingSpawnButton Button)? _lastClicked;
+    private Control? _scrollTo;
+    private bool _updatePlacement;
+    private bool _updateEraseDecal;
+
+    private MappingScreen Screen => (MappingScreen) UserInterfaceManager.ActiveScreen!;
+    private MainViewport Viewport => UserInterfaceManager.ActiveScreen!.GetWidget<MainViewport>()!;
+
+    public CursorState State { get; set; }
+
+    public MappingState()
+    {
+        IoCManager.InjectDependencies(this);
+
+        _sawmill = _log.GetSawmill("mapping");
+        _loadController = UserInterfaceManager.GetUIController<GameplayStateLoadController>();
+    }
+
+    protected override void Startup()
+    {
+        EnsureSetup();
+        base.Startup();
+
+        UserInterfaceManager.LoadScreen<MappingScreen>();
+        _loadController.LoadScreen();
+
+        var context = _input.Contexts.GetContext("common");
+        context.AddFunction(ContentKeyFunctions.MappingUnselect);
+        context.AddFunction(ContentKeyFunctions.SaveMap);
+        context.AddFunction(ContentKeyFunctions.MappingEnablePick);
+        context.AddFunction(ContentKeyFunctions.MappingEnableDelete);
+        context.AddFunction(ContentKeyFunctions.MappingPick);
+        context.AddFunction(ContentKeyFunctions.MappingRemoveDecal);
+        context.AddFunction(ContentKeyFunctions.MappingCancelEraseDecal);
+        context.AddFunction(ContentKeyFunctions.MappingOpenContextMenu);
+
+        Screen.DecalSystem = _decal;
+        Screen.Prototypes.SearchBar.OnTextChanged += OnSearch;
+        Screen.Prototypes.CollapseAllButton.OnPressed += OnCollapseAll;
+        Screen.Prototypes.ClearSearchButton.OnPressed += OnClearSearch;
+        Screen.Prototypes.GetPrototypeData += OnGetData;
+        Screen.Prototypes.SelectionChanged += OnSelected;
+        Screen.Prototypes.CollapseToggled += OnCollapseToggled;
+        Screen.Pick.OnPressed += OnPickPressed;
+        Screen.Delete.OnPressed += OnDeletePressed;
+        Screen.EntityReplaceButton.OnToggled += OnEntityReplacePressed;
+        Screen.EntityPlacementMode.OnItemSelected += OnEntityPlacementSelected;
+        Screen.EraseEntityButton.OnToggled += OnEraseEntityPressed;
+        Screen.EraseDecalButton.OnToggled += OnEraseDecalPressed;
+        _placement.PlacementChanged += OnPlacementChanged;
+
+        CommandBinds.Builder
+            .Bind(ContentKeyFunctions.MappingUnselect, new PointerInputCmdHandler(HandleMappingUnselect, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.SaveMap, new PointerInputCmdHandler(HandleSaveMap, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.MappingEnablePick, new PointerStateInputCmdHandler(HandleEnablePick, HandleDisablePick, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.MappingEnableDelete, new PointerStateInputCmdHandler(HandleEnableDelete, HandleDisableDelete, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.MappingPick, new PointerInputCmdHandler(HandlePick, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.MappingRemoveDecal, new PointerInputCmdHandler(HandleEditorCancelPlace, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.MappingCancelEraseDecal, new PointerInputCmdHandler(HandleCancelEraseDecal, outsidePrediction: true))
+            .Bind(ContentKeyFunctions.MappingOpenContextMenu, new PointerInputCmdHandler(HandleOpenContextMenu, outsidePrediction: true))
+            .Register<MappingState>();
+
+        _overlays.AddOverlay(new MappingOverlay(this));
+
+        _prototypeManager.PrototypesReloaded += OnPrototypesReloaded;
+
+        Screen.Prototypes.UpdateVisible(_prototypes);
+    }
+
+    private void OnPrototypesReloaded(PrototypesReloadedEventArgs obj)
+    {
+        if (!obj.WasModified<EntityPrototype>() &&
+            !obj.WasModified<ContentTileDefinition>() &&
+            !obj.WasModified<DecalPrototype>())
+        {
+            return;
+        }
+
+        ReloadPrototypes();
+    }
+
+    private bool HandleOpenContextMenu(in PointerInputCmdArgs args)
+    {
+        Deselect();
+
+        var coords = args.Coordinates.ToMap(_entityManager, _transform);
+        if (_verbs.TryGetEntityMenuEntities(coords, out var entities))
+            _entityMenuController.OpenRootMenu(entities);
+
+        return true;
+    }
+
+    protected override void Shutdown()
+    {
+        CommandBinds.Unregister<MappingState>();
+
+        Screen.Prototypes.SearchBar.OnTextChanged -= OnSearch;
+        Screen.Prototypes.CollapseAllButton.OnPressed -= OnCollapseAll;
+        Screen.Prototypes.ClearSearchButton.OnPressed -= OnClearSearch;
+        Screen.Prototypes.GetPrototypeData -= OnGetData;
+        Screen.Prototypes.SelectionChanged -= OnSelected;
+        Screen.Prototypes.CollapseToggled -= OnCollapseToggled;
+        Screen.Pick.OnPressed -= OnPickPressed;
+        Screen.Delete.OnPressed -= OnDeletePressed;
+        Screen.EntityReplaceButton.OnToggled -= OnEntityReplacePressed;
+        Screen.EntityPlacementMode.OnItemSelected -= OnEntityPlacementSelected;
+        Screen.EraseEntityButton.OnToggled -= OnEraseEntityPressed;
+        Screen.EraseDecalButton.OnToggled -= OnEraseDecalPressed;
+        _placement.PlacementChanged -= OnPlacementChanged;
+        _prototypeManager.PrototypesReloaded -= OnPrototypesReloaded;
+
+        UserInterfaceManager.ClearWindows();
+        _loadController.UnloadScreen();
+        UserInterfaceManager.UnloadScreen();
+
+        var context = _input.Contexts.GetContext("common");
+        context.RemoveFunction(ContentKeyFunctions.MappingUnselect);
+        context.RemoveFunction(ContentKeyFunctions.SaveMap);
+        context.RemoveFunction(ContentKeyFunctions.MappingEnablePick);
+        context.RemoveFunction(ContentKeyFunctions.MappingEnableDelete);
+        context.RemoveFunction(ContentKeyFunctions.MappingPick);
+        context.RemoveFunction(ContentKeyFunctions.MappingRemoveDecal);
+        context.RemoveFunction(ContentKeyFunctions.MappingCancelEraseDecal);
+        context.RemoveFunction(ContentKeyFunctions.MappingOpenContextMenu);
+
+        _overlays.RemoveOverlay<MappingOverlay>();
+
+        base.Shutdown();
+    }
+
+    private void EnsureSetup()
+    {
+        if (_setup)
+            return;
+
+        _setup = true;
+
+        _entityMenuController = UserInterfaceManager.GetUIController<EntityMenuUIController>();
+
+        _decal = _entityManager.System<DecalPlacementSystem>();
+        _sprite = _entityManager.System<SpriteSystem>();
+        _transform = _entityManager.System<TransformSystem>();
+        _verbs = _entityManager.System<VerbSystem>();
+        ReloadPrototypes();
+    }
+
+    private void ReloadPrototypes()
+    {
+        var entities = new MappingPrototype(null, Loc.GetString("mapping-entities")) { Children = new List<MappingPrototype>() };
+        _prototypes.Add(entities);
+
+        var mappings = new Dictionary<string, MappingPrototype>();
+        foreach (var entity in _prototypeManager.EnumeratePrototypes<EntityPrototype>())
+        {
+            Register(entity, entity.ID, entities);
+        }
+
+        Sort(mappings, entities);
+        mappings.Clear();
+
+        var tiles = new MappingPrototype(null, Loc.GetString("mapping-tiles")) { Children = new List<MappingPrototype>() };
+        _prototypes.Add(tiles);
+
+        foreach (var tile in _prototypeManager.EnumeratePrototypes<ContentTileDefinition>())
+        {
+            Register(tile, tile.ID, tiles);
+        }
+
+        Sort(mappings, tiles);
+        mappings.Clear();
+
+        var decals = new MappingPrototype(null, Loc.GetString("mapping-decals")) { Children = new List<MappingPrototype>() };
+        _prototypes.Add(decals);
+
+        foreach (var decal in _prototypeManager.EnumeratePrototypes<DecalPrototype>())
+        {
+            Register(decal, decal.ID, decals);
+        }
+
+        Sort(mappings, decals);
+        mappings.Clear();
+    }
+
+    private void Sort(Dictionary<string, MappingPrototype> prototypes, MappingPrototype topLevel)
+    {
+        static int Compare(MappingPrototype a, MappingPrototype b)
+        {
+            return string.Compare(a.Name, b.Name, OrdinalIgnoreCase);
+        }
+
+        topLevel.Children ??= new List<MappingPrototype>();
+
+        foreach (var prototype in prototypes.Values)
+        {
+            if (prototype.Parents == null && prototype != topLevel)
+            {
+                prototype.Parents = new List<MappingPrototype> { topLevel };
+                topLevel.Children.Add(prototype);
+            }
+
+            prototype.Parents?.Sort(Compare);
+            prototype.Children?.Sort(Compare);
+        }
+
+        topLevel.Children.Sort(Compare);
+    }
+
+    private MappingPrototype? Register<T>(T? prototype, string id, MappingPrototype topLevel) where T : class, IPrototype, IInheritingPrototype
+    {
+        {
+            if (prototype == null &&
+                _prototypeManager.TryIndex(id, out prototype) &&
+                prototype is EntityPrototype entity)
+            {
+                if (entity.HideSpawnMenu || entity.Abstract)
+                    prototype = null;
+            }
+        }
+
+        if (prototype == null)
+        {
+            if (!_prototypeManager.TryGetMapping(typeof(T), id, out var node))
+            {
+                _sawmill.Error($"No {nameof(T)} found with id {id}");
+                return null;
+            }
+
+            var ids = _idDict.GetOrNew(typeof(T));
+            if (ids.TryGetValue(id, out var mapping))
+            {
+                return mapping;
+            }
+            else
+            {
+                var name = node.TryGet("name", out ValueDataNode? nameNode)
+                    ? nameNode.Value
+                    : id;
+
+                if (node.TryGet("suffix", out ValueDataNode? suffix))
+                    name = $"{name} [{suffix.Value}]";
+
+                mapping = new MappingPrototype(prototype, name);
+                _allPrototypes.Add(mapping);
+                ids.Add(id, mapping);
+
+                if (node.TryGet("parent", out ValueDataNode? parentValue))
+                {
+                    var parent = Register<T>(null, parentValue.Value, topLevel);
+
+                    if (parent != null)
+                    {
+                        mapping.Parents ??= new List<MappingPrototype>();
+                        mapping.Parents.Add(parent);
+                        parent.Children ??= new List<MappingPrototype>();
+                        parent.Children.Add(mapping);
+                    }
+                }
+                else if (node.TryGet("parent", out SequenceDataNode? parentSequence))
+                {
+                    foreach (var parentNode in parentSequence.Cast<ValueDataNode>())
+                    {
+                        var parent = Register<T>(null, parentNode.Value, topLevel);
+
+                        if (parent != null)
+                        {
+                            mapping.Parents ??= new List<MappingPrototype>();
+                            mapping.Parents.Add(parent);
+                            parent.Children ??= new List<MappingPrototype>();
+                            parent.Children.Add(mapping);
+                        }
+                    }
+                }
+                else
+                {
+                    topLevel.Children ??= new List<MappingPrototype>();
+                    topLevel.Children.Add(mapping);
+                    mapping.Parents ??= new List<MappingPrototype>();
+                    mapping.Parents.Add(topLevel);
+                }
+
+                return mapping;
+            }
+        }
+        else
+        {
+            var ids = _idDict.GetOrNew(typeof(T));
+            if (ids.TryGetValue(id, out var mapping))
+            {
+                return mapping;
+            }
+            else
+            {
+                var entity = prototype as EntityPrototype;
+                var name = entity?.Name ?? prototype.ID;
+
+                if (!string.IsNullOrWhiteSpace(entity?.EditorSuffix))
+                    name = $"{name} [{entity.EditorSuffix}]";
+
+                mapping = new MappingPrototype(prototype, name);
+                _allPrototypes.Add(mapping);
+                _allPrototypesDict.Add(prototype, mapping);
+                ids.Add(prototype.ID, mapping);
+            }
+
+            if (prototype.Parents == null)
+            {
+                topLevel.Children ??= new List<MappingPrototype>();
+                topLevel.Children.Add(mapping);
+                mapping.Parents ??= new List<MappingPrototype>();
+                mapping.Parents.Add(topLevel);
+                return mapping;
+            }
+
+            foreach (var parentId in prototype.Parents)
+            {
+                var parent = Register<T>(null, parentId, topLevel);
+
+                if (parent != null)
+                {
+                    mapping.Parents ??= new List<MappingPrototype>();
+                    mapping.Parents.Add(parent);
+                    parent.Children ??= new List<MappingPrototype>();
+                    parent.Children.Add(mapping);
+                }
+            }
+
+            return mapping;
+        }
+    }
+
+    private void OnPlacementChanged(object? sender, EventArgs e)
+    {
+        _updatePlacement = true;
+    }
+
+    protected override void OnKeyBindStateChanged(ViewportBoundKeyEventArgs args)
+    {
+        if (args.Viewport == null)
+            base.OnKeyBindStateChanged(new ViewportBoundKeyEventArgs(args.KeyEventArgs, Viewport.Viewport));
+        else
+            base.OnKeyBindStateChanged(args);
+    }
+
+    private void OnSearch(LineEditEventArgs args)
+    {
+        if (string.IsNullOrEmpty(args.Text))
+        {
+            Screen.Prototypes.PrototypeList.Visible = true;
+            Screen.Prototypes.SearchList.Visible = false;
+            return;
+        }
+
+        var matches = new List<MappingPrototype>();
+        foreach (var prototype in _allPrototypes)
+        {
+            if (prototype.Name.Contains(args.Text, OrdinalIgnoreCase))
+                matches.Add(prototype);
+        }
+
+        matches.Sort(static (a, b) => string.Compare(a.Name, b.Name, OrdinalIgnoreCase));
+
+        Screen.Prototypes.PrototypeList.Visible = false;
+        Screen.Prototypes.SearchList.Visible = true;
+        Screen.Prototypes.Search(matches);
+    }
+
+    private void OnCollapseAll(ButtonEventArgs args)
+    {
+        foreach (var child in Screen.Prototypes.PrototypeList.Children)
+        {
+            if (child is not MappingSpawnButton button)
+                continue;
+
+            Collapse(button);
+        }
+
+        Screen.Prototypes.ScrollContainer.SetScrollValue(new Vector2(0, 0));
+    }
+
+    private void OnClearSearch(ButtonEventArgs obj)
+    {
+        Screen.Prototypes.SearchBar.Text = string.Empty;
+        OnSearch(new LineEditEventArgs(Screen.Prototypes.SearchBar, string.Empty));
+    }
+
+    private void OnGetData(IPrototype prototype, List<Texture> textures)
+    {
+        switch (prototype)
+        {
+            case EntityPrototype entity:
+                textures.AddRange(SpriteComponent.GetPrototypeTextures(entity, _resources).Select(t => t.Default));
+                break;
+            case DecalPrototype decal:
+                textures.Add(_sprite.Frame0(decal.Sprite));
+                break;
+            case ContentTileDefinition tile:
+                if (tile.Sprite?.ToString() is { } sprite)
+                    textures.Add(_resources.GetResource<TextureResource>(sprite).Texture);
+                break;
+        }
+    }
+
+    private void OnSelected(MappingPrototype mapping)
+    {
+        if (mapping.Prototype == null)
+            return;
+
+        var chain = new Stack<MappingPrototype>();
+        chain.Push(mapping);
+
+        var parent = mapping.Parents?.FirstOrDefault();
+        while (parent != null)
+        {
+            chain.Push(parent);
+            parent = parent.Parents?.FirstOrDefault();
+        }
+
+        _lastClicked = null;
+
+        Control? last = null;
+        var children = Screen.Prototypes.PrototypeList.Children;
+        foreach (var prototype in chain)
+        {
+            foreach (var child in children)
+            {
+                if (child is MappingSpawnButton button &&
+                    button.Prototype == prototype)
+                {
+                    UnCollapse(button);
+                    OnSelected(button, prototype.Prototype);
+                    children = button.ChildrenPrototypes.Children;
+                    last = child;
+                    break;
+                }
+            }
+        }
+
+        if (last != null && Screen.Prototypes.PrototypeList.Visible)
+            _scrollTo = last;
+    }
+
+    private void OnSelected(MappingSpawnButton button, IPrototype? prototype)
+    {
+        var time = _timing.CurTime;
+        if (prototype is DecalPrototype)
+            Screen.SelectDecal(prototype.ID);
+
+        // Double-click functionality if it's collapsible.
+        if (_lastClicked is { } lastClicked &&
+            lastClicked.Button == button &&
+            lastClicked.At > time - TimeSpan.FromSeconds(0.333) &&
+            string.IsNullOrEmpty(Screen.Prototypes.SearchBar.Text) &&
+            button.CollapseButton.Visible)
+        {
+            button.CollapseButton.Pressed = !button.CollapseButton.Pressed;
+            ToggleCollapse(button);
+            button.Button.Pressed = true;
+            Screen.Prototypes.Selected = button;
+            _lastClicked = null;
+            return;
+        }
+
+        // Toggle if it's the same button (at least if we just unclicked it).
+        if (!button.Button.Pressed && button.Prototype?.Prototype != null && _lastClicked?.Button == button)
+        {
+            _lastClicked = null;
+            Deselect();
+            return;
+        }
+
+        _lastClicked = (time, button);
+
+        if (button.Prototype == null)
+            return;
+
+        if (Screen.Prototypes.Selected is { } oldButton &&
+            oldButton != button)
+        {
+            Deselect();
+        }
+
+        Screen.EntityContainer.Visible = false;
+        Screen.DecalContainer.Visible = false;
+
+        switch (prototype)
+        {
+            case EntityPrototype entity:
+            {
+                var placementId = Screen.EntityPlacementMode.SelectedId;
+
+                var placement = new PlacementInformation
+                {
+                    PlacementOption = placementId > 0 ? EntitySpawnWindow.InitOpts[placementId] : entity.PlacementMode,
+                    EntityType = entity.ID,
+                    IsTile = false
+                };
+
+                Screen.EntityContainer.Visible = true;
+                _decal.SetActive(false);
+                _placement.BeginPlacing(placement);
+                break;
+            }
+            case DecalPrototype decal:
+                _placement.Clear();
+
+                _decal.SetActive(true);
+                _decal.UpdateDecalInfo(decal.ID, Color.White, 0, true, 0, false);
+                Screen.DecalContainer.Visible = true;
+                break;
+            case ContentTileDefinition tile:
+            {
+                var placement = new PlacementInformation
+                {
+                    PlacementOption = "AlignTileAny",
+                    TileType = tile.TileId,
+                    IsTile = true
+                };
+
+                _decal.SetActive(false);
+                _placement.BeginPlacing(placement);
+                break;
+            }
+            default:
+                _placement.Clear();
+                break;
+        }
+
+        Screen.Prototypes.Selected = button;
+
+        button.Button.Pressed = true;
+    }
+
+    private void Deselect()
+    {
+        if (Screen.Prototypes.Selected is { } selected)
+        {
+            selected.Button.Pressed = false;
+            Screen.Prototypes.Selected = null;
+
+            if (selected.Prototype?.Prototype is DecalPrototype)
+            {
+                _decal.SetActive(false);
+                Screen.DecalContainer.Visible = false;
+            }
+
+            if (selected.Prototype?.Prototype is EntityPrototype)
+            {
+                _placement.Clear();
+            }
+
+            if (selected.Prototype?.Prototype is ContentTileDefinition)
+            {
+                _placement.Clear();
+            }
+        }
+    }
+
+    private void OnCollapseToggled(MappingSpawnButton button, ButtonToggledEventArgs args)
+    {
+        ToggleCollapse(button);
+    }
+
+    private void OnPickPressed(ButtonEventArgs args)
+    {
+        if (args.Button.Pressed)
+            EnablePick();
+        else
+            DisablePick();
+    }
+
+    private void OnDeletePressed(ButtonEventArgs obj)
+    {
+        if (obj.Button.Pressed)
+            EnableDelete();
+        else
+            DisableDelete();
+    }
+
+    private void OnEntityReplacePressed(ButtonToggledEventArgs args)
+    {
+        _placement.Replacement = args.Pressed;
+    }
+
+    private void OnEntityPlacementSelected(ItemSelectedEventArgs args)
+    {
+        Screen.EntityPlacementMode.SelectId(args.Id);
+
+        if (_placement.CurrentMode != null)
+        {
+            var placement = new PlacementInformation
+            {
+                PlacementOption = EntitySpawnWindow.InitOpts[args.Id],
+                EntityType = _placement.CurrentPermission!.EntityType,
+                TileType = _placement.CurrentPermission.TileType,
+                Range = 2,
+                IsTile = _placement.CurrentPermission.IsTile,
+            };
+
+            _placement.BeginPlacing(placement);
+        }
+    }
+
+    private void OnEraseEntityPressed(ButtonEventArgs args)
+    {
+        if (args.Button.Pressed == _placement.Eraser)
+            return;
+
+        if (args.Button.Pressed)
+            EnableEraser();
+        else
+            DisableEraser();
+    }
+
+    private void OnEraseDecalPressed(ButtonToggledEventArgs args)
+    {
+        _placement.Clear();
+        Deselect();
+        Screen.EraseEntityButton.Pressed = false;
+        _updatePlacement = true;
+        _updateEraseDecal = args.Pressed;
+    }
+
+    private void EnableEraser()
+    {
+        if (_placement.Eraser)
+            return;
+
+        _placement.Clear();
+        _placement.ToggleEraser();
+        Screen.EntityPlacementMode.Disabled = true;
+        Screen.EraseDecalButton.Pressed = false;
+        Deselect();
+    }
+
+    private void DisableEraser()
+    {
+        if (!_placement.Eraser)
+            return;
+
+        _placement.ToggleEraser();
+        Screen.EntityPlacementMode.Disabled = false;
+    }
+
+    private void EnablePick()
+    {
+        Screen.UnPressActionsExcept(Screen.Pick);
+        State = CursorState.Pick;
+    }
+
+    private void DisablePick()
+    {
+        Screen.Pick.Pressed = false;
+        State = CursorState.None;
+    }
+
+    private void EnableDelete()
+    {
+        Screen.UnPressActionsExcept(Screen.Delete);
+        State = CursorState.Delete;
+        EnableEraser();
+    }
+
+    private void DisableDelete()
+    {
+        Screen.Delete.Pressed = false;
+        State = CursorState.None;
+        DisableEraser();
+    }
+
+    private bool HandleMappingUnselect(in PointerInputCmdArgs args)
+    {
+        if (Screen.Prototypes.Selected is not { Prototype.Prototype: DecalPrototype })
+            return false;
+
+        Deselect();
+        return true;
+    }
+
+    private bool HandleSaveMap(in PointerInputCmdArgs args)
+    {
+#if FULL_RELEASE
+        return false;
+#endif
+        if (!_admin.IsAdmin(true) || !_admin.HasFlag(AdminFlags.Host))
+            return false;
+
+        SaveMap();
+        return true;
+    }
+
+    private bool HandleEnablePick(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        EnablePick();
+        return true;
+    }
+
+    private bool HandleDisablePick(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        DisablePick();
+        return true;
+    }
+
+    private bool HandleEnableDelete(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        EnableDelete();
+        return true;
+    }
+
+    private bool HandleDisableDelete(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        DisableDelete();
+        return true;
+    }
+
+    private bool HandlePick(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        if (State != CursorState.Pick)
+            return false;
+
+        MappingPrototype? button = null;
+
+        // Try and get tile under it
+        // TODO: Separate mode for decals.
+        if (!uid.IsValid())
+        {
+            var mapPos = _transform.ToMapCoordinates(coords);
+
+            if (_mapMan.TryFindGridAt(mapPos, out var gridUid, out var grid) &&
+                _entityManager.System<SharedMapSystem>().TryGetTileRef(gridUid, grid, coords, out var tileRef) &&
+                _allPrototypesDict.TryGetValue(tileRef.GetContentTileDefinition(), out button))
+            {
+                OnSelected(button);
+                return true;
+            }
+        }
+
+        if (button == null)
+        {
+            if (uid == EntityUid.Invalid ||
+                _entityManager.GetComponentOrNull<MetaDataComponent>(uid) is not { EntityPrototype: { } prototype } ||
+                !_allPrototypesDict.TryGetValue(prototype, out button))
+            {
+                // we always block other input handlers if pick mode is enabled
+                // this makes you not accidentally place something in space because you
+                // miss-clicked while holding down the pick hotkey
+                return true;
+            }
+
+            // Selected an entity
+            OnSelected(button);
+
+            // Match rotation
+            _placement.Direction = _entityManager.GetComponent<TransformComponent>(uid).LocalRotation.GetDir();
+        }
+
+        return true;
+    }
+
+    private bool HandleEditorCancelPlace(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        if (!Screen.EraseDecalButton.Pressed)
+            return false;
+
+        _entityNetwork.SendSystemNetworkMessage(new RequestDecalRemovalEvent(_entityManager.GetNetCoordinates(coords)));
+        return true;
+    }
+
+    private bool HandleCancelEraseDecal(in PointerInputCmdArgs args)
+    {
+        if (!Screen.EraseDecalButton.Pressed)
+            return false;
+
+        Screen.EraseDecalButton.Pressed = false;
+        return true;
+    }
+
+    private async void SaveMap()
+    {
+        await _mapping.SaveMap();
+    }
+
+    private void ToggleCollapse(MappingSpawnButton button)
+    {
+        if (button.CollapseButton.Pressed)
+        {
+            if (button.Prototype?.Children != null)
+            {
+                foreach (var child in button.Prototype.Children)
+                {
+                    Screen.Prototypes.Insert(button.ChildrenPrototypes, child, true);
+                }
+            }
+
+            button.CollapseButton.Label.Text = "▼";
+        }
+        else
+        {
+            button.ChildrenPrototypes.DisposeAllChildren();
+            button.CollapseButton.Label.Text = "▶";
+        }
+    }
+
+    private void Collapse(MappingSpawnButton button)
+    {
+        if (!button.CollapseButton.Pressed)
+            return;
+
+        button.CollapseButton.Pressed = false;
+        ToggleCollapse(button);
+    }
+
+
+    private void UnCollapse(MappingSpawnButton button)
+    {
+        if (button.CollapseButton.Pressed)
+            return;
+
+        button.CollapseButton.Pressed = true;
+        ToggleCollapse(button);
+    }
+
+    public EntityUid? GetHoveredEntity()
+    {
+        if (UserInterfaceManager.CurrentlyHovered is not IViewportControl viewport ||
+            _input.MouseScreenPosition is not { IsValid: true } position)
+        {
+            return null;
+        }
+
+        var mapPos = viewport.PixelToMap(position.Position);
+        return GetClickedEntity(mapPos);
+    }
+
+    public override void FrameUpdate(FrameEventArgs e)
+    {
+        if (_updatePlacement)
+        {
+            _updatePlacement = false;
+
+            if (!_placement.IsActive && _decal.GetActiveDecal().Decal == null)
+                Deselect();
+
+            Screen.EraseEntityButton.Pressed = _placement.Eraser;
+            Screen.EraseDecalButton.Pressed = _updateEraseDecal;
+            Screen.EntityPlacementMode.Disabled = _placement.Eraser;
+        }
+
+        if (_scrollTo is not { } scrollTo)
+            return;
+
+        // this is not ideal but we wait until the control's height is computed to use
+        // its position to scroll to
+        if (scrollTo.Height > 0 && Screen.Prototypes.PrototypeList.Visible)
+        {
+            var y = scrollTo.GlobalPosition.Y - Screen.Prototypes.ScrollContainer.Height / 2 + scrollTo.Height;
+            var scroll = Screen.Prototypes.ScrollContainer;
+            scroll.SetScrollValue(scroll.GetScrollValue() + new Vector2(0, y));
+            _scrollTo = null;
+        }
+    }
+
+
+    // TODO this doesn't handle pressing down multiple state hotkeys at the moment
+    public enum CursorState
+    {
+        None,
+        Pick,
+        Delete
+    }
+}
diff --git a/Content.Client/Mapping/MappingSystem.cs b/Content.Client/Mapping/MappingSystem.cs
index 8daf193dfe..80189fbdfc 100644
--- a/Content.Client/Mapping/MappingSystem.cs
+++ b/Content.Client/Mapping/MappingSystem.cs
@@ -13,7 +13,6 @@ public sealed partial class MappingSystem : EntitySystem
 {
     [Dependency] private readonly IPlacementManager _placementMan = default!;
     [Dependency] private readonly ITileDefinitionManager _tileMan = default!;
-    [Dependency] private readonly ActionsSystem _actionsSystem = default!;
     [Dependency] private readonly MetaDataSystem _metaData = default!;
 
     /// <summary>
@@ -26,8 +25,6 @@ public sealed partial class MappingSystem : EntitySystem
     /// </summary>
     private readonly SpriteSpecifier _deleteIcon = new Texture(new ("Interface/VerbIcons/delete.svg.192dpi.png"));
 
-    public string DefaultMappingActions = "/mapping_actions.yml";
-
     public override void Initialize()
     {
         base.Initialize();
@@ -36,11 +33,6 @@ public override void Initialize()
         SubscribeLocalEvent<StartPlacementActionEvent>(OnStartPlacementAction);
     }
 
-    public void LoadMappingActions()
-    {
-        _actionsSystem.LoadActionAssignments(DefaultMappingActions, false);
-    }
-
     /// <summary>
     ///     This checks if the placement manager is currently active, and attempts to copy the placement information for
     ///     some entity or tile into an action. This is somewhat janky, but it seem to work well enough. Though I'd
diff --git a/Content.Client/Physics/Controllers/MoverController.cs b/Content.Client/Physics/Controllers/MoverController.cs
index edd4ef1426..f31aba53ed 100644
--- a/Content.Client/Physics/Controllers/MoverController.cs
+++ b/Content.Client/Physics/Controllers/MoverController.cs
@@ -66,7 +66,7 @@ private void OnRelayPlayerAttached(Entity<RelayInputMoverComponent> entity, ref
             Physics.UpdateIsPredicted(entity.Owner);
             Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
             if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
-                SetMoveInput((entity.Owner, inputMover), MoveButtons.None);
+                SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
         }
 
         private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
@@ -74,7 +74,7 @@ private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref
             Physics.UpdateIsPredicted(entity.Owner);
             Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
             if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
-                SetMoveInput((entity.Owner, inputMover), MoveButtons.None);
+                SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
         }
 
         private void OnPlayerAttached(Entity<InputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
diff --git a/Content.Client/Verbs/UI/VerbMenuUIController.cs b/Content.Client/Verbs/UI/VerbMenuUIController.cs
index c3fc8c8356..5e45612fff 100644
--- a/Content.Client/Verbs/UI/VerbMenuUIController.cs
+++ b/Content.Client/Verbs/UI/VerbMenuUIController.cs
@@ -3,6 +3,7 @@
 using Content.Client.CombatMode;
 using Content.Client.ContextMenu.UI;
 using Content.Client.Gameplay;
+using Content.Client.Mapping;
 using Content.Shared.Input;
 using Content.Shared.Verbs;
 using Robust.Client.Player;
@@ -21,7 +22,9 @@ namespace Content.Client.Verbs.UI
     ///     open a verb menu for a given entity, add verbs to it, and add server-verbs when the server response is
     ///     received.
     /// </remarks>
-    public sealed class VerbMenuUIController : UIController, IOnStateEntered<GameplayState>, IOnStateExited<GameplayState>
+    public sealed class VerbMenuUIController : UIController,
+        IOnStateEntered<GameplayState>, IOnStateExited<GameplayState>,
+        IOnStateEntered<MappingState>, IOnStateExited<MappingState>
     {
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly ContextMenuUIController _context = default!;
@@ -43,7 +46,6 @@ public void OnStateEntered(GameplayState state)
         {
             _context.OnContextKeyEvent += OnKeyBindDown;
             _context.OnContextClosed += Close;
-            _verbSystem.OnVerbsResponse += HandleVerbsResponse;
         }
 
         public void OnStateExited(GameplayState state)
@@ -55,6 +57,22 @@ public void OnStateExited(GameplayState state)
             Close();
         }
 
+        public void OnStateEntered(MappingState state)
+        {
+            _context.OnContextKeyEvent += OnKeyBindDown;
+            _context.OnContextClosed += Close;
+            _verbSystem.OnVerbsResponse += HandleVerbsResponse;
+        }
+
+        public void OnStateExited(MappingState state)
+        {
+            _context.OnContextKeyEvent -= OnKeyBindDown;
+            _context.OnContextClosed -= Close;
+            if (_verbSystem != null)
+                _verbSystem.OnVerbsResponse -= HandleVerbsResponse;
+            Close();
+        }
+
         /// <summary>
         ///     Open a verb menu and fill it with verbs applicable to the given target entity.
         /// </summary>
diff --git a/Content.IntegrationTests/PoolTestLogHandler.cs b/Content.IntegrationTests/PoolTestLogHandler.cs
index 909bee9785..d1a8492603 100644
--- a/Content.IntegrationTests/PoolTestLogHandler.cs
+++ b/Content.IntegrationTests/PoolTestLogHandler.cs
@@ -42,6 +42,11 @@ public void Log(string sawmillName, LogEvent message)
     {
         var level = message.Level.ToRobust();
 
+        // Ignore Sawmill Warnings. This means tests will only fail on debug asserts.
+        // Remove this when we fix the loadout performance issue.
+        if (level == LogLevel.Warning)
+            return;
+
         if (ShuttingDown && (FailureLevel == null || level < FailureLevel))
             return;
 
diff --git a/Content.IntegrationTests/Tests/MappingEditorTest.cs b/Content.IntegrationTests/Tests/MappingEditorTest.cs
new file mode 100644
index 0000000000..bd930aef9e
--- /dev/null
+++ b/Content.IntegrationTests/Tests/MappingEditorTest.cs
@@ -0,0 +1,41 @@
+using Content.Client.Gameplay;
+using Content.Client.Mapping;
+using Robust.Client.State;
+
+namespace Content.IntegrationTests.Tests;
+
+[TestFixture]
+public sealed class MappingEditorTest
+{
+    [Test]
+    public async Task StopHardCodingWidgetsJesusChristTest()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            Connected = true
+        });
+        var client = pair.Client;
+        var state = client.ResolveDependency<IStateManager>();
+
+        await client.WaitPost(() =>
+        {
+            Assert.DoesNotThrow(() =>
+            {
+                state.RequestStateChange<MappingState>();
+            });
+        });
+
+        // arbitrary short time
+        await client.WaitRunTicks(30);
+
+        await client.WaitPost(() =>
+        {
+            Assert.DoesNotThrow(() =>
+            {
+                state.RequestStateChange<GameplayState>();
+            });
+        });
+
+        await pair.CleanReturnAsync();
+    }
+}
diff --git a/Content.Server/Chat/SuicideSystem.cs b/Content.Server/Chat/SuicideSystem.cs
index 884292b0fa..0b850971b9 100644
--- a/Content.Server/Chat/SuicideSystem.cs
+++ b/Content.Server/Chat/SuicideSystem.cs
@@ -147,7 +147,7 @@ private void OnDamageableSuicide(Entity<DamageableComponent> victim, ref Suicide
             return;
         }
 
-        args.DamageType ??= "Bloodloss";
+        args.DamageType ??= "Blunt";
         _suicide.ApplyLethalDamage(victim, args.DamageType);
         args.Handled = true;
     }
diff --git a/Content.Server/Chemistry/Components/ChemMasterComponent.cs b/Content.Server/Chemistry/Components/ChemMasterComponent.cs
index 9578755ba7..e04dcc1716 100644
--- a/Content.Server/Chemistry/Components/ChemMasterComponent.cs
+++ b/Content.Server/Chemistry/Components/ChemMasterComponent.cs
@@ -23,5 +23,11 @@ public sealed partial class ChemMasterComponent : Component
 
         [DataField("clickSound"), ViewVariables(VVAccess.ReadWrite)]
         public SoundSpecifier ClickSound = new SoundPathSpecifier("/Audio/Machines/machine_switch.ogg");
+
+        [DataField]
+        public int SortMethod;
+
+        [DataField]
+        public int TransferringAmount;
     }
 }
diff --git a/Content.Server/Chemistry/EntitySystems/ChemMasterSystem.cs b/Content.Server/Chemistry/EntitySystems/ChemMasterSystem.cs
index 289db75981..09a8f3562d 100644
--- a/Content.Server/Chemistry/EntitySystems/ChemMasterSystem.cs
+++ b/Content.Server/Chemistry/EntitySystems/ChemMasterSystem.cs
@@ -58,12 +58,12 @@ public override void Initialize()
             SubscribeLocalEvent<ChemMasterComponent, ChemMasterReagentAmountButtonMessage>(OnReagentButtonMessage);
             SubscribeLocalEvent<ChemMasterComponent, ChemMasterCreatePillsMessage>(OnCreatePillsMessage);
             SubscribeLocalEvent<ChemMasterComponent, ChemMasterOutputToBottleMessage>(OnOutputToBottleMessage);
+            SubscribeLocalEvent<ChemMasterComponent, ChemMasterSortMethodUpdated>(OnSortMethodUpdated);
+            SubscribeLocalEvent<ChemMasterComponent, ChemMasterTransferringAmountUpdated>(OnTransferringAmountUpdated);
         }
 
-        private void SubscribeUpdateUiState<T>(Entity<ChemMasterComponent> ent, ref T ev)
-        {
+        private void SubscribeUpdateUiState<T>(Entity<ChemMasterComponent> ent, ref T ev) =>
             UpdateUiState(ent);
-        }
 
         private void UpdateUiState(Entity<ChemMasterComponent> ent, bool updateLabel = false)
         {
@@ -77,8 +77,16 @@ private void UpdateUiState(Entity<ChemMasterComponent> ent, bool updateLabel = f
             var bufferCurrentVolume = bufferSolution.Volume;
 
             var state = new ChemMasterBoundUserInterfaceState(
-                chemMaster.Mode, BuildInputContainerInfo(inputContainer), BuildOutputContainerInfo(outputContainer),
-                bufferReagents, bufferCurrentVolume, chemMaster.PillType, chemMaster.PillDosageLimit, updateLabel);
+                chemMaster.Mode,
+                BuildInputContainerInfo(inputContainer),
+                BuildOutputContainerInfo(outputContainer),
+                bufferReagents,
+                bufferCurrentVolume,
+                chemMaster.PillType,
+                chemMaster.PillDosageLimit,
+                updateLabel,
+                chemMaster.SortMethod,
+                chemMaster.TransferringAmount);
 
             _userInterfaceSystem.SetUiState(owner, ChemMasterUiKey.Key, state);
         }
@@ -107,17 +115,13 @@ private void OnSetPillTypeMessage(Entity<ChemMasterComponent> chemMaster, ref Ch
 
         private void OnReagentButtonMessage(Entity<ChemMasterComponent> chemMaster, ref ChemMasterReagentAmountButtonMessage message)
         {
-            // Ensure the amount corresponds to one of the reagent amount buttons.
-            if (!Enum.IsDefined(typeof(ChemMasterReagentAmount), message.Amount))
-                return;
-
             switch (chemMaster.Comp.Mode)
             {
                 case ChemMasterMode.Transfer:
-                    TransferReagents(chemMaster, message.ReagentId, message.Amount.GetFixedPoint(), message.FromBuffer);
+                    TransferReagents(chemMaster, message.ReagentId, message.Amount, message.FromBuffer);
                     break;
                 case ChemMasterMode.Discard:
-                    DiscardReagents(chemMaster, message.ReagentId, message.Amount.GetFixedPoint(), message.FromBuffer);
+                    DiscardReagents(chemMaster, message.ReagentId, message.Amount, message.FromBuffer);
                     break;
                 default:
                     // Invalid mode.
@@ -346,5 +350,17 @@ private static ContainerInfo BuildContainerInfo(string name, Solution solution)
                 Reagents = solution.Contents
             };
         }
+
+        private void OnSortMethodUpdated(EntityUid uid, ChemMasterComponent chemMaster, ChemMasterSortMethodUpdated args)
+        {
+            chemMaster.SortMethod = args.SortMethod;
+            UpdateUiState((uid, chemMaster));
+        }
+
+        private void OnTransferringAmountUpdated(EntityUid uid, ChemMasterComponent chemMaster, ChemMasterTransferringAmountUpdated args)
+        {
+            chemMaster.TransferringAmount = args.TransferringAmount;
+            UpdateUiState((uid, chemMaster));
+        }
     }
 }
diff --git a/Content.Server/DeviceNetwork/Systems/NetworkConfiguratorSystem.cs b/Content.Server/DeviceNetwork/Systems/NetworkConfiguratorSystem.cs
index 31613ca380..af0c400c67 100644
--- a/Content.Server/DeviceNetwork/Systems/NetworkConfiguratorSystem.cs
+++ b/Content.Server/DeviceNetwork/Systems/NetworkConfiguratorSystem.cs
@@ -18,7 +18,7 @@
 using Robust.Server.Audio;
 using Robust.Server.GameObjects;
 using Robust.Shared.Audio;
-using Robust.Shared.Player;
+using Robust.Shared.Map.Events;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -64,6 +64,42 @@ public override void Initialize()
         SubscribeLocalEvent<NetworkConfiguratorComponent, NetworkConfiguratorButtonPressedMessage>(OnConfigButtonPressed);
 
         SubscribeLocalEvent<DeviceListComponent, ComponentRemove>(OnComponentRemoved);
+
+        SubscribeLocalEvent<BeforeSaveEvent>(OnMapSave);
+    }
+
+    private void OnMapSave(BeforeSaveEvent ev)
+    {
+        var enumerator = AllEntityQuery<NetworkConfiguratorComponent>();
+        while (enumerator.MoveNext(out var uid, out var conf))
+        {
+            if (CompOrNull<TransformComponent>(conf.ActiveDeviceList)?.MapUid != ev.Map)
+                continue;
+
+            // The linked device list is (probably) being saved. Make sure that the configurator is also being saved
+            // (i.e., not in the hands of a mapper/ghost). In the future, map saving should raise a separate event
+            // containing a set of all entities that are about to be saved, which would make checking this much easier.
+            // This is a shitty bandaid, and will force close the UI during auto-saves.
+            // TODO Map serialization refactor
+
+            var xform = Transform(uid);
+            if (xform.MapUid == ev.Map && IsSaveable(uid))
+                continue;
+
+            _uiSystem.CloseUi(uid, NetworkConfiguratorUiKey.Configure);
+            DebugTools.AssertNull(conf.ActiveDeviceList);
+        }
+
+        bool IsSaveable(EntityUid uid)
+        {
+            while (uid.IsValid())
+            {
+                if (Prototype(uid)?.MapSavable == false)
+                    return false;
+                uid = Transform(uid).ParentUid;
+            }
+            return true;
+        }
     }
 
     private void OnShutdown(EntityUid uid, NetworkConfiguratorComponent component, ComponentShutdown args)
@@ -435,11 +471,11 @@ private void OpenDeviceLinkUi(EntityUid configuratorUid, EntityUid? targetUid, E
         if (Delay(configurator))
             return;
 
-        if (!targetUid.HasValue || !configurator.ActiveDeviceLink.HasValue || !TryComp(userUid, out ActorComponent? actor) || !AccessCheck(targetUid.Value, userUid, configurator))
+        if (!targetUid.HasValue || !configurator.ActiveDeviceLink.HasValue || !AccessCheck(targetUid.Value, userUid, configurator))
             return;
 
 
-        _uiSystem.OpenUi(configuratorUid, NetworkConfiguratorUiKey.Link, actor.PlayerSession);
+        _uiSystem.OpenUi(configuratorUid, NetworkConfiguratorUiKey.Link, userUid);
         configurator.DeviceLinkTarget = targetUid;
 
 
@@ -490,6 +526,9 @@ private void OpenDeviceListUi(EntityUid configuratorUid, EntityUid? targetUid, E
         if (!TryComp(targetUid, out DeviceListComponent? list))
             return;
 
+        if (TryComp(configurator.ActiveDeviceList, out DeviceListComponent? oldList))
+            oldList.Configurators.Remove(configuratorUid);
+
         list.Configurators.Add(configuratorUid);
         configurator.ActiveDeviceList = targetUid;
         Dirty(configuratorUid, configurator);
@@ -763,7 +802,7 @@ private void OnConfigButtonPressed(EntityUid uid, NetworkConfiguratorComponent c
                 {
                     if (query.TryGetComponent(device, out var comp))
                     {
-                        component.Devices[addr] = device;
+                        component.Devices.Add(addr, device);
                         comp.Configurators.Add(uid);
                     }
                 }
diff --git a/Content.Server/Electrocution/ElectrocutionSystem.cs b/Content.Server/Electrocution/ElectrocutionSystem.cs
index e8dc64e185..978c7573f5 100644
--- a/Content.Server/Electrocution/ElectrocutionSystem.cs
+++ b/Content.Server/Electrocution/ElectrocutionSystem.cs
@@ -123,7 +123,7 @@ private void UpdateState(float frameTime)
             activated.TimeLeft -= frameTime;
             if (activated.TimeLeft <= 0 || !IsPowered(uid, electrified, transform))
             {
-                _appearance.SetData(uid, ElectrifiedVisuals.IsPowered, false);
+                _appearance.SetData(uid, ElectrifiedVisuals.ShowSparks, false);
                 RemComp<ActivatedElectrifiedComponent>(uid);
             }
         }
@@ -219,7 +219,7 @@ public bool TryDoElectrifiedAct(EntityUid uid, EntityUid targetUid,
             return false;
 
         EnsureComp<ActivatedElectrifiedComponent>(uid);
-        _appearance.SetData(uid, ElectrifiedVisuals.IsPowered, true);
+        _appearance.SetData(uid, ElectrifiedVisuals.ShowSparks, true);
 
         siemens *= electrified.SiemensCoefficient;
         if (!DoCommonElectrocutionAttempt(targetUid, uid, ref siemens) || siemens <= 0)
@@ -490,15 +490,4 @@ private void PlayElectrocutionSound(EntityUid targetUid, EntityUid sourceUid, El
         }
         _audio.PlayPvs(electrified.ShockNoises, targetUid, AudioParams.Default.WithVolume(electrified.ShockVolume));
     }
-
-    public void SetElectrifiedWireCut(Entity<ElectrifiedComponent> ent, bool value)
-    {
-        if (ent.Comp.IsWireCut == value)
-        {
-            return;
-        }
-
-        ent.Comp.IsWireCut = value;
-        Dirty(ent);
-    }
 }
diff --git a/Content.Server/IoC/ServerContentIoC.cs b/Content.Server/IoC/ServerContentIoC.cs
index f8dc6436c3..4a4fbc709b 100644
--- a/Content.Server/IoC/ServerContentIoC.cs
+++ b/Content.Server/IoC/ServerContentIoC.cs
@@ -12,6 +12,7 @@
 using Content.Server.EUI;
 using Content.Server.GhostKick;
 using Content.Server.Info;
+using Content.Server.Mapping;
 using Content.Server.Maps;
 using Content.Server.Players.JobWhitelist;
 using Content.Server.MoMMI;
@@ -75,6 +76,7 @@ public static void Register()
             IoCManager.Register<JobWhitelistManager>();
             IoCManager.Register<PlayerRateLimitManager>();
             IoCManager.Register<SharedPlayerRateLimitManager, PlayerRateLimitManager>();
+            IoCManager.Register<MappingManager>();
         }
     }
 }
diff --git a/Content.Server/Mail/Systems/MailSystem.cs b/Content.Server/Mail/Systems/MailSystem.cs
index c779b8088b..21e1398770 100644
--- a/Content.Server/Mail/Systems/MailSystem.cs
+++ b/Content.Server/Mail/Systems/MailSystem.cs
@@ -650,7 +650,7 @@ private void SpawnMail(EntityUid uid, MailTeleporterComponent? component = null)
 
             if (candidateList.Count <= 0)
             {
-                _sawmill.Error("List of mail candidates was empty!");
+                _sawmill.Warning("List of mail candidates was empty!");
                 return;
             }
 
diff --git a/Content.Server/Mapping/MappingManager.cs b/Content.Server/Mapping/MappingManager.cs
new file mode 100644
index 0000000000..e8c6eca204
--- /dev/null
+++ b/Content.Server/Mapping/MappingManager.cs
@@ -0,0 +1,76 @@
+using System.IO;
+using Content.Server.Administration.Managers;
+using Content.Shared.Administration;
+using Content.Shared.Mapping;
+using Robust.Server.GameObjects;
+using Robust.Server.Player;
+using Robust.Shared.Map;
+using Robust.Shared.Network;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+using YamlDotNet.Core;
+using YamlDotNet.RepresentationModel;
+
+namespace Content.Server.Mapping;
+
+public sealed class MappingManager : IPostInjectInit
+{
+    [Dependency] private readonly IAdminManager _admin = default!;
+    [Dependency] private readonly ILogManager _log = default!;
+    [Dependency] private readonly IMapManager _map = default!;
+    [Dependency] private readonly IServerNetManager _net = default!;
+    [Dependency] private readonly IPlayerManager _players = default!;
+    [Dependency] private readonly IEntitySystemManager _systems = default!;
+
+    private ISawmill _sawmill = default!;
+    private ZStdCompressionContext _zstd = default!;
+
+    public void PostInject()
+    {
+#if !FULL_RELEASE
+        _net.RegisterNetMessage<MappingSaveMapMessage>(OnMappingSaveMap);
+        _net.RegisterNetMessage<MappingSaveMapErrorMessage>();
+        _net.RegisterNetMessage<MappingMapDataMessage>();
+
+        _sawmill = _log.GetSawmill("mapping");
+        _zstd = new ZStdCompressionContext();
+#endif
+    }
+
+    private void OnMappingSaveMap(MappingSaveMapMessage message)
+    {
+#if !FULL_RELEASE
+        try
+        {
+            if (!_players.TryGetSessionByChannel(message.MsgChannel, out var session) ||
+                !_admin.IsAdmin(session, true) ||
+                !_admin.HasAdminFlag(session, AdminFlags.Host) ||
+                session.AttachedEntity is not { } player)
+            {
+                return;
+            }
+
+            var mapId = _systems.GetEntitySystem<TransformSystem>().GetMapCoordinates(player).MapId;
+            var mapEntity = _map.GetMapEntityIdOrThrow(mapId);
+            var data = _systems.GetEntitySystem<MapLoaderSystem>().GetSaveData(mapEntity);
+            var document = new YamlDocument(data.ToYaml());
+            var stream = new YamlStream { document };
+            var writer = new StringWriter();
+            stream.Save(new YamlMappingFix(new Emitter(writer)), false);
+
+            var msg = new MappingMapDataMessage()
+            {
+                Context = _zstd,
+                Yml = writer.ToString()
+            };
+            _net.ServerSendMessage(msg, message.MsgChannel);
+        }
+        catch (Exception e)
+        {
+            _sawmill.Error($"Error saving map in mapping mode:\n{e}");
+            var msg = new MappingSaveMapErrorMessage();
+            _net.ServerSendMessage(msg, message.MsgChannel);
+        }
+#endif
+    }
+}
diff --git a/Content.Server/Nyanotrasen/Research/SophicScribe/SophicScribeSystem.cs b/Content.Server/Nyanotrasen/Research/SophicScribe/SophicScribeSystem.cs
index e468c838aa..b13febea0f 100644
--- a/Content.Server/Nyanotrasen/Research/SophicScribe/SophicScribeSystem.cs
+++ b/Content.Server/Nyanotrasen/Research/SophicScribe/SophicScribeSystem.cs
@@ -38,7 +38,7 @@ public override void Update(float frameTime)
             if (!TryComp<IntrinsicRadioTransmitterComponent>(scribe, out var radio))
                 continue;
 
-            var message = Loc.GetString("glimmer-report", ("level", _glimmerSystem.GlimmerOutput));
+            var message = Loc.GetString("glimmer-report", ("level", _glimmerSystem.GlimmerOutputString));
             var channel = _prototypeManager.Index<RadioChannelPrototype>("Science");
             _radioSystem.SendRadioMessage(scribe, message, channel, scribe);
 
@@ -62,7 +62,7 @@ private void OnInteractHand(EntityUid uid, SophicScribeComponent component, Inte
 
         component.StateTime = _timing.CurTime + component.StateCD;
 
-        _chat.TrySendInGameICMessage(uid, Loc.GetString("glimmer-report", ("level", _glimmerSystem.GlimmerOutput)), InGameICChatType.Speak, true);
+        _chat.TrySendInGameICMessage(uid, Loc.GetString("glimmer-report", ("level", _glimmerSystem.GlimmerOutputString)), InGameICChatType.Speak, true);
     }
 
     private void OnGlimmerEventEnded(GlimmerEventEndedEvent args)
@@ -79,7 +79,7 @@ private void OnGlimmerEventEnded(GlimmerEventEndedEvent args)
                 speaker = swapped.OriginalEntity;
             }
 
-            var message = Loc.GetString(args.Message, ("decrease", args.GlimmerBurned), ("level", _glimmerSystem.GlimmerOutput));
+            var message = Loc.GetString(args.Message, ("decrease", args.GlimmerBurned), ("level", _glimmerSystem.GlimmerOutputString));
             var channel = _prototypeManager.Index<RadioChannelPrototype>("Common");
             _radioSystem.SendRadioMessage(speaker, message, channel, speaker);
         }
diff --git a/Content.Server/Physics/Controllers/MoverController.cs b/Content.Server/Physics/Controllers/MoverController.cs
index 4e61cdcb52..de9cf6d49e 100644
--- a/Content.Server/Physics/Controllers/MoverController.cs
+++ b/Content.Server/Physics/Controllers/MoverController.cs
@@ -33,13 +33,13 @@ public override void Initialize()
         private void OnRelayPlayerAttached(Entity<RelayInputMoverComponent> entity, ref PlayerAttachedEvent args)
         {
             if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
-                SetMoveInput((entity.Owner, inputMover), MoveButtons.None);
+                SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
         }
 
         private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref PlayerDetachedEvent args)
         {
             if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
-                SetMoveInput((entity.Owner, inputMover), MoveButtons.None);
+                SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
         }
 
         private void OnPlayerAttached(Entity<InputMoverComponent> entity, ref PlayerAttachedEvent args)
diff --git a/Content.Server/Power/PowerWireAction.cs b/Content.Server/Power/PowerWireAction.cs
index 43d1de6e4d..52cbaeb41e 100644
--- a/Content.Server/Power/PowerWireAction.cs
+++ b/Content.Server/Power/PowerWireAction.cs
@@ -18,7 +18,7 @@ public sealed partial class PowerWireAction : BaseWireAction
     [DataField("pulseTimeout")]
     private int _pulseTimeout = 30;
 
-    private ElectrocutionSystem _electrocutionSystem = default!;
+    private ElectrocutionSystem _electrocution = default!;
 
     public override object StatusKey { get; } = PowerWireActionKey.Status;
 
@@ -109,8 +109,8 @@ private void SetElectrified(EntityUid used, bool setting, ElectrifiedComponent?
             && !EntityManager.TryGetComponent(used, out electrified))
             return;
 
-        _electrocutionSystem.SetElectrifiedWireCut((used, electrified), setting);
-        electrified.Enabled = setting;
+        _electrocution.SetElectrifiedWireCut((used, electrified), setting);
+        _electrocution.SetElectrified((used, electrified), setting);
     }
 
     /// <returns>false if failed, true otherwise, or if the entity cannot be electrified</returns>
@@ -124,7 +124,7 @@ private bool TrySetElectrocution(EntityUid user, Wire wire, bool timed = false)
         // always set this to true
         SetElectrified(wire.Owner, true, electrified);
 
-        var electrifiedAttempt = _electrocutionSystem.TryDoElectrifiedAct(wire.Owner, user);
+        var electrifiedAttempt = _electrocution.TryDoElectrifiedAct(wire.Owner, user);
 
         // if we were electrified, then return false
         return !electrifiedAttempt;
@@ -165,7 +165,7 @@ public override void Initialize()
     {
         base.Initialize();
 
-        _electrocutionSystem = EntitySystem.Get<ElectrocutionSystem>();
+        _electrocution = EntityManager.System<ElectrocutionSystem>();
     }
 
     // This should add a wire into the entity's state, whether it be
diff --git a/Content.Server/Speech/EntitySystems/VocalSystem.cs b/Content.Server/Speech/EntitySystems/VocalSystem.cs
index 63a47c6c86..964b043451 100644
--- a/Content.Server/Speech/EntitySystems/VocalSystem.cs
+++ b/Content.Server/Speech/EntitySystems/VocalSystem.cs
@@ -2,12 +2,14 @@
 using Content.Server.Chat.Systems;
 using Content.Server.Speech.Components;
 using Content.Shared.ActionBlocker;
+using Content.Shared.CCVar;
 using Content.Shared.Chat.Prototypes;
 using Content.Shared.Humanoid;
 using Content.Shared.Speech;
 using Content.Shared.Speech.Components;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Systems;
+using Robust.Shared.Configuration;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 
@@ -21,6 +23,7 @@ public sealed class VocalSystem : EntitySystem
     [Dependency] private readonly ChatSystem _chat = default!;
     [Dependency] private readonly ActionsSystem _actions = default!;
     [Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
+    [Dependency] private readonly IConfigurationManager _config = default!;
 
     [ValidatePrototypeId<ReplacementAccentPrototype>]
     private const string MuzzleAccent = "mumble";
@@ -38,8 +41,9 @@ public override void Initialize()
 
     private void OnMapInit(EntityUid uid, VocalComponent component, MapInitEvent args)
     {
-        // try to add scream action when vocal comp added
-        _actions.AddAction(uid, ref component.ScreamActionEntity, component.ScreamAction);
+        if (_config.GetCVar(CCVars.AllowScreamAction))
+            _actions.AddAction(uid, ref component.ScreamActionEntity, component.ScreamAction);
+
         LoadSounds(uid, component);
     }
 
@@ -78,7 +82,7 @@ private void OnEmote(EntityUid uid, VocalComponent component, ref EmoteEvent arg
 
     private void OnScreamAction(EntityUid uid, VocalComponent component, ScreamActionEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !_config.GetCVar(CCVars.AllowScreamAction))
             return;
 
         _chat.TryEmoteWithChat(uid, component.ScreamId);
diff --git a/Content.Server/Speech/Muting/MutingSystem.cs b/Content.Server/Speech/Muting/MutingSystem.cs
index fc3349a938..fc993ead05 100644
--- a/Content.Server/Speech/Muting/MutingSystem.cs
+++ b/Content.Server/Speech/Muting/MutingSystem.cs
@@ -4,10 +4,12 @@
 using Content.Server.Popups;
 using Content.Server.Speech.Components;
 using Content.Server.Speech.EntitySystems;
+using Content.Shared.CCVar;
 using Content.Shared.Chat.Prototypes;
 using Content.Shared.Puppet;
 using Content.Shared.Speech;
 using Content.Shared.Speech.Muting;
+using Robust.Shared.Configuration;
 
 namespace Content.Server.Speech.Muting
 {
@@ -15,6 +17,7 @@ public sealed class MutingSystem : EntitySystem
     {
         [Dependency] private readonly LanguageSystem _languages = default!;
         [Dependency] private readonly PopupSystem _popupSystem = default!;
+        [Dependency] private readonly IConfigurationManager _config = default!;
 
         public override void Initialize()
         {
@@ -36,7 +39,7 @@ private void OnEmote(EntityUid uid, MutedComponent component, ref EmoteEvent arg
 
         private void OnScreamAction(EntityUid uid, MutedComponent component, ScreamActionEvent args)
         {
-            if (args.Handled)
+            if (args.Handled || !_config.GetCVar(CCVars.AllowScreamAction))
                 return;
 
             if (HasComp<MimePowersComponent>(uid))
diff --git a/Content.Shared/Access/Systems/AccessReaderSystem.cs b/Content.Shared/Access/Systems/AccessReaderSystem.cs
index 181af53893..f670ac860b 100644
--- a/Content.Shared/Access/Systems/AccessReaderSystem.cs
+++ b/Content.Shared/Access/Systems/AccessReaderSystem.cs
@@ -154,7 +154,12 @@ public bool IsAllowed(
             return IsAllowedInternal(access, stationKeys, reader);
 
         if (!_containerSystem.TryGetContainer(target, reader.ContainerAccessProvider, out var container))
-            return Paused(target); // when mapping, containers with electronics arent spawned
+            return false;
+
+        // If entity is paused then always allow it at this point.
+        // Door electronics is kind of a mess but yeah, it should only be an unpaused ent interacting with it
+        if (Paused(target))
+            return true;
 
         foreach (var entity in container.ContainedEntities)
         {
diff --git a/Content.Shared/CCVar/CCVars.Accessibility.cs b/Content.Shared/CCVar/CCVars.Accessibility.cs
new file mode 100644
index 0000000000..9a08af59bd
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Accessibility.cs
@@ -0,0 +1,47 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Chat window opacity slider, controlling the alpha of the chat window background.
+    ///     Goes from to 0 (completely transparent) to 1 (completely opaque)
+    /// </summary>
+    public static readonly CVarDef<float> ChatWindowOpacity =
+        CVarDef.Create("accessibility.chat_window_transparency", 0.85f, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Toggle for visual effects that may potentially cause motion sickness.
+    ///     Where reasonable, effects affected by this CVar should use an alternate effect.
+    ///     Please do not use this CVar as a bandaid for effects that could otherwise be made accessible without issue.
+    /// </summary>
+    public static readonly CVarDef<bool> ReducedMotion =
+        CVarDef.Create("accessibility.reduced_motion", false, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<bool> ChatEnableColorName =
+        CVarDef.Create("accessibility.enable_color_name",
+            true,
+            CVar.CLIENTONLY | CVar.ARCHIVE,
+            "Toggles displaying names with individual colors.");
+
+    /// <summary>
+    ///     Screen shake intensity slider, controlling the intensity of the CameraRecoilSystem.
+    ///     Goes from 0 (no recoil at all) to 1 (regular amounts of recoil)
+    /// </summary>
+    public static readonly CVarDef<float> ScreenShakeIntensity =
+        CVarDef.Create("accessibility.screen_shake_intensity", 1f, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     A generic toggle for various visual effects that are color sensitive.
+    ///     As of 2/16/24, only applies to progress bar colors.
+    /// </summary>
+    public static readonly CVarDef<bool> AccessibilityColorblindFriendly =
+        CVarDef.Create("accessibility.colorblind_friendly", false, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    /// Disables all vision filters for species like Vulpkanin or Harpies. There are good reasons someone might want to disable these.
+    /// </summary>
+    public static readonly CVarDef<bool> NoVisionFilters =
+        CVarDef.Create("accessibility.no_vision_filters", true, CVar.CLIENTONLY | CVar.ARCHIVE);
+}
diff --git a/Content.Shared/CCVar/CCVars.Admin.Ahelp.cs b/Content.Shared/CCVar/CCVars.Admin.Ahelp.cs
new file mode 100644
index 0000000000..1211fd8b8e
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Admin.Ahelp.cs
@@ -0,0 +1,79 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Ahelp rate limit values are accounted in periods of this size (seconds).
+    ///     After the period has passed, the count resets.
+    /// </summary>
+    /// <seealso cref="AhelpRateLimitCount"/>
+    public static readonly CVarDef<float> AhelpRateLimitPeriod =
+        CVarDef.Create("ahelp.rate_limit_period", 2f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     How many ahelp messages are allowed in a single rate limit period.
+    /// </summary>
+    /// <seealso cref="AhelpRateLimitPeriod"/>
+    public static readonly CVarDef<int> AhelpRateLimitCount =
+        CVarDef.Create("ahelp.rate_limit_count", 10, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Should the administrator's position be displayed in ahelp.
+    ///     If it is is false, only the admin's ckey will be displayed in the ahelp.
+    /// </summary>
+    /// <seealso cref="AdminUseCustomNamesAdminRank"/>
+    /// <seealso cref="AhelpAdminPrefixWebhook"/>
+    public static readonly CVarDef<bool> AhelpAdminPrefix =
+        CVarDef.Create("ahelp.admin_prefix", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Should the administrator's position be displayed in the webhook.
+    ///     If it is is false, only the admin's ckey will be displayed in webhook.
+    /// </summary>
+    /// <seealso cref="AdminUseCustomNamesAdminRank"/>
+    /// <seealso cref="AhelpAdminPrefix"/>
+    public static readonly CVarDef<bool> AhelpAdminPrefixWebhook =
+        CVarDef.Create("ahelp.admin_prefix_webhook", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If an admin replies to users from discord, should it use their discord role color? (if applicable)
+    ///     Overrides DiscordReplyColor and AdminBwoinkColor.
+    /// </summary>
+    public static readonly CVarDef<bool> UseDiscordRoleColor =
+        CVarDef.Create("admin.use_discord_role_color", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If an admin replies to users from discord, should it use their discord role color? (if applicable)
+    ///     Overrides DiscordReplyColor and AdminBwoinkColor.
+    /// </summary>
+    public static readonly CVarDef<bool> UseDiscordRoleName =
+        CVarDef.Create("admin.use_discord_role_name", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The text before an admin's name when replying from discord to indicate they're speaking from discord.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordReplyPrefix =
+        CVarDef.Create("admin.discord_reply_prefix", "(DC) ", CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The color of the names of admins. This is the fallback color for admins.
+    /// </summary>
+    public static readonly CVarDef<string> AdminBwoinkColor =
+        CVarDef.Create("admin.admin_bwoink_color", "red", CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The color of the names of admins who reply from discord. Leave empty to disable.
+    ///     Overrides AdminBwoinkColor.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordReplyColor =
+        CVarDef.Create("admin.discord_reply_color", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Use the admin's Admin OOC color in bwoinks.
+    ///     If either the ooc color or this is not set, uses the admin.admin_bwoink_color value.
+    /// </summary>
+    public static readonly CVarDef<bool> UseAdminOOCColorInBwoinks =
+        CVarDef.Create("admin.bwoink_use_admin_ooc_color", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Admin.Logs.cs b/Content.Shared/CCVar/CCVars.Admin.Logs.cs
new file mode 100644
index 0000000000..862456ddfd
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Admin.Logs.cs
@@ -0,0 +1,42 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Controls if admin logs are enabled. Highly recommended to shut this off for development.
+    /// </summary>
+    public static readonly CVarDef<bool> AdminLogsEnabled =
+        CVarDef.Create("adminlogs.enabled", true, CVar.SERVERONLY);
+
+    public static readonly CVarDef<float> AdminLogsQueueSendDelay =
+        CVarDef.Create("adminlogs.queue_send_delay_seconds", 5f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     When to skip the waiting time to save in-round admin logs, if no admin logs are currently being saved
+    /// </summary>
+    public static readonly CVarDef<int> AdminLogsQueueMax =
+        CVarDef.Create("adminlogs.queue_max", 5000, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     When to skip the waiting time to save pre-round admin logs, if no admin logs are currently being saved
+    /// </summary>
+    public static readonly CVarDef<int> AdminLogsPreRoundQueueMax =
+        CVarDef.Create("adminlogs.pre_round_queue_max", 5000, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     When to start dropping logs
+    /// </summary>
+    public static readonly CVarDef<int> AdminLogsDropThreshold =
+        CVarDef.Create("adminlogs.drop_threshold", 20000, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     How many logs to send to the client at once
+    /// </summary>
+    public static readonly CVarDef<int> AdminLogsClientBatchSize =
+        CVarDef.Create("adminlogs.client_batch_size", 1000, CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> AdminLogsServerName =
+        CVarDef.Create("adminlogs.server_name", "unknown", CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Admin.Rules.cs b/Content.Shared/CCVar/CCVars.Admin.Rules.cs
new file mode 100644
index 0000000000..b87074288f
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Admin.Rules.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Time that players have to wait before rules can be accepted.
+    /// </summary>
+    public static readonly CVarDef<float> RulesWaitTime =
+        CVarDef.Create("rules.time", 45f, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Don't show rules to localhost/loopback interface.
+    /// </summary>
+    public static readonly CVarDef<bool> RulesExemptLocal =
+        CVarDef.Create("rules.exempt_local", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Admin.cs b/Content.Shared/CCVar/CCVars.Admin.cs
new file mode 100644
index 0000000000..3a4eb7b065
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Admin.cs
@@ -0,0 +1,172 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> AdminAnnounceLogin =
+        CVarDef.Create("admin.announce_login", true, CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> AdminAnnounceLogout =
+        CVarDef.Create("admin.announce_logout", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The token used to authenticate with the admin API. Leave empty to disable the admin API. This is a secret! Do not share!
+    /// </summary>
+    public static readonly CVarDef<string> AdminApiToken =
+        CVarDef.Create("admin.api_token", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+    /// <summary>
+    ///     Should users be able to see their own notes? Admins will be able to see and set notes regardless
+    /// </summary>
+    public static readonly CVarDef<bool> SeeOwnNotes =
+        CVarDef.Create("admin.see_own_notes", false, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Should the server play a quick sound to the active admins whenever a new player joins?
+    /// </summary>
+    public static readonly CVarDef<bool> AdminNewPlayerJoinSound =
+        CVarDef.Create("admin.new_player_join_sound", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The amount of days before the note starts fading. It will slowly lose opacity until it reaches stale. Set to 0 to disable.
+    /// </summary>
+    public static readonly CVarDef<double> NoteFreshDays =
+        CVarDef.Create("admin.note_fresh_days", 91.31055, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     The amount of days before the note completely fades, and can only be seen by admins if they press "see more notes". Set to 0
+    ///     if you want the note to immediately disappear without fading.
+    /// </summary>
+    public static readonly CVarDef<double> NoteStaleDays =
+        CVarDef.Create("admin.note_stale_days", 365.2422, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     How much time does the user have to wait in seconds before confirming that they saw an admin message?
+    /// </summary>
+    public static readonly CVarDef<float> MessageWaitTime =
+        CVarDef.Create("admin.message_wait_time", 3f, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Default severity for role bans
+    /// </summary>
+    public static readonly CVarDef<string> RoleBanDefaultSeverity =
+        CVarDef.Create("admin.role_ban_default_severity", "medium", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Default severity for department bans
+    /// </summary>
+    public static readonly CVarDef<string> DepartmentBanDefaultSeverity =
+        CVarDef.Create("admin.department_ban_default_severity", "medium", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Default severity for server bans
+    /// </summary>
+    public static readonly CVarDef<string> ServerBanDefaultSeverity =
+        CVarDef.Create("admin.server_ban_default_severity", "High", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether a server ban will ban the player's ip by default.
+    /// </summary>
+    public static readonly CVarDef<bool> ServerBanIpBanDefault =
+        CVarDef.Create("admin.server_ban_ip_ban_default", true, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether a server ban will ban the player's hardware id by default.
+    /// </summary>
+    public static readonly CVarDef<bool> ServerBanHwidBanDefault =
+        CVarDef.Create("admin.server_ban_hwid_ban_default", true, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether to use details from last connection for ip/hwid in the BanPanel.
+    /// </summary>
+    public static readonly CVarDef<bool> ServerBanUseLastDetails =
+        CVarDef.Create("admin.server_ban_use_last_details", true, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether to erase a player's chat messages and their entity from the game when banned.
+    /// </summary>
+    public static readonly CVarDef<bool> ServerBanErasePlayer =
+        CVarDef.Create("admin.server_ban_erase_player", false, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Minimum players sharing a connection required to create an alert. -1 to disable the alert.
+    /// </summary>
+    /// <remarks>
+    ///     If you set this to 0 or 1 then it will alert on every connection, so probably don't do that.
+    /// </remarks>
+    public static readonly CVarDef<int> AdminAlertMinPlayersSharingConnection =
+        CVarDef.Create("admin.alert.min_players_sharing_connection", -1, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Minimum explosion intensity to create an admin alert message. -1 to disable the alert.
+    /// </summary>
+    public static readonly CVarDef<int> AdminAlertExplosionMinIntensity =
+        CVarDef.Create("admin.alert.explosion_min_intensity", 60, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Minimum particle accelerator strength to create an admin alert message.
+    /// </summary>
+    public static readonly CVarDef<int> AdminAlertParticleAcceleratorMinPowerState =
+        CVarDef.Create("admin.alert.particle_accelerator_min_power_state", 3, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Should the ban details in admin channel include PII? (IP, HWID, etc)
+    /// </summary>
+    public static readonly CVarDef<bool> AdminShowPIIOnBan =
+        CVarDef.Create("admin.show_pii_onban", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If an admin joins a round by reading up or using the late join button, automatically
+    ///     de-admin them.
+    /// </summary>
+    public static readonly CVarDef<bool> AdminDeadminOnJoin =
+        CVarDef.Create("admin.deadmin_on_join", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Overrides the name the client sees in ahelps. Set empty to disable.
+    /// </summary>
+    public static readonly CVarDef<string> AdminAhelpOverrideClientName =
+        CVarDef.Create("admin.override_adminname_in_client_ahelp", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The threshold of minutes to appear as a "new player" in the ahelp menu
+    ///     If 0, appearing as a new player is disabled.
+    /// </summary>
+    public static readonly CVarDef<int> NewPlayerThreshold =
+        CVarDef.Create("admin.new_player_threshold", 0, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     How long an admin client can go without any input before being considered AFK.
+    /// </summary>
+    public static readonly CVarDef<float> AdminAfkTime =
+        CVarDef.Create("admin.afk_time", 600f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If true, admins are able to connect even if
+    ///     <see cref="SoftMaxPlayers"/> would otherwise block regular players.
+    /// </summary>
+    public static readonly CVarDef<bool> AdminBypassMaxPlayers =
+        CVarDef.Create("admin.bypass_max_players", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Determine if custom rank names are used.
+    ///     If it is false, it'd use the actual rank name regardless of the individual's title.
+    /// </summary>
+    /// <seealso cref="AhelpAdminPrefix"/>
+    /// <seealso cref="AhelpAdminPrefixWebhook"/>
+    public static readonly CVarDef<bool> AdminUseCustomNamesAdminRank =
+        CVarDef.Create("admin.use_custom_names_admin_rank", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Determines whether admins count towards the total playercount when determining whether the server is over <see cref="SoftMaxPlayers"/>
+    ///     Ideally this should be used in conjuction with <see cref="AdminBypassPlayers"/>.
+    ///     This also applies to playercount limits in whitelist conditions
+    ///     If false, then admins will not be considered when checking whether the playercount is already above the soft player cap
+    /// </summary>
+    public static readonly CVarDef<bool> AdminsCountForMaxPlayers =
+        CVarDef.Create("admin.admins_count_for_max_players", false, CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> BanHardwareIds =
+        CVarDef.Create("ban.hardware_ids", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Announcer.cs b/Content.Shared/CCVar/CCVars.Announcer.cs
new file mode 100644
index 0000000000..acccd7d0e4
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Announcer.cs
@@ -0,0 +1,37 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Weighted list of announcers to choose from
+    /// </summary>
+    public static readonly CVarDef<string> AnnouncerList =
+        CVarDef.Create("announcer.list", "RandomAnnouncers", CVar.REPLICATED);
+
+    /// <summary>
+    ///     Optionally force set an announcer
+    /// </summary>
+    public static readonly CVarDef<string> Announcer =
+        CVarDef.Create("announcer.announcer", "", CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Optionally blacklist announcers
+    ///     List of IDs separated by commas
+    /// </summary>
+    public static readonly CVarDef<string> AnnouncerBlacklist =
+        CVarDef.Create("announcer.blacklist", "", CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Changes how loud the announcers are for the client
+    /// </summary>
+    public static readonly CVarDef<float> AnnouncerVolume =
+        CVarDef.Create("announcer.volume", 0.5f, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    ///     Disables multiple announcement sounds from playing at once
+    /// </summary>
+    public static readonly CVarDef<bool> AnnouncerDisableMultipleSounds =
+        CVarDef.Create("announcer.disable_multiple_sounds", false, CVar.ARCHIVE | CVar.CLIENTONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Atmos.cs b/Content.Shared/CCVar/CCVars.Atmos.cs
new file mode 100644
index 0000000000..46890cea0c
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Atmos.cs
@@ -0,0 +1,188 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Whether gas differences will move entities.
+    /// </summary>
+    public static readonly CVarDef<bool> SpaceWind =
+        CVarDef.Create("atmos.space_wind", true, CVar.SERVERONLY);
+
+    public static readonly CVarDef<float> SpaceWindStrengthMultiplier =
+        CVarDef.Create("atmos.space_wind_strength_multiplier", 1f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Divisor from maxForce (pressureDifference * 2.25f) to force applied on objects.
+    /// </summary>
+    public static readonly CVarDef<float> SpaceWindPressureForceDivisorThrow =
+        CVarDef.Create("atmos.space_wind_pressure_force_divisor_throw", 15f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Divisor from maxForce (pressureDifference * 2.25f) to force applied on objects.
+    /// </summary>
+    public static readonly CVarDef<float> SpaceWindPressureForceDivisorPush =
+        CVarDef.Create("atmos.space_wind_pressure_force_divisor_push", 2500f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The maximum velocity (not force) that may be applied to an object by atmospheric pressure differences.
+    ///     Useful to prevent clipping through objects.
+    /// </summary>
+    public static readonly CVarDef<float> SpaceWindMaxVelocity =
+        CVarDef.Create("atmos.space_wind_max_velocity", 15f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The maximum force that may be applied to an object by pushing (i.e. not throwing) atmospheric pressure differences.
+    ///     A "throwing" atmospheric pressure difference ignores this limit, but not the max. velocity limit.
+    /// </summary>
+    public static readonly CVarDef<float> SpaceWindMaxPushForce =
+        CVarDef.Create("atmos.space_wind_max_push_force", 20f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If an object's mass is below this number, then this number is used in place of mass to determine whether air pressure can throw an object.
+    ///     This has nothing to do with throwing force, only acting as a way of reducing the odds of tiny 5 gram objects from being yeeted by people's breath
+    /// </summary>
+    /// <remarks>
+    ///     If you are reading this because you want to change it, consider looking into why almost every item in the game weighs only 5 grams
+    ///     And maybe do your part to fix that? :)
+    /// </remarks>
+    public static readonly CVarDef<float> SpaceWindMinimumCalculatedMass =
+        CVarDef.Create("atmos.space_wind_minimum_calculated_mass", 5f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// 	Calculated as 1/Mass, where Mass is the physics.Mass of the desired threshold.
+    /// 	If an object's inverse mass is lower than this, it is capped at this. Basically, an upper limit to how heavy an object can be before it stops resisting space wind more.
+    /// </summary>
+    public static readonly CVarDef<float> SpaceWindMaximumCalculatedInverseMass =
+        CVarDef.Create("atmos.space_wind_maximum_calculated_inverse_mass", 0.04f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether monstermos tile equalization is enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> MonstermosEqualization =
+        CVarDef.Create("atmos.monstermos_equalization", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether monstermos explosive depressurization is enabled.
+    ///     Needs <see cref="MonstermosEqualization"/> to be enabled to work.
+    /// </summary>
+    public static readonly CVarDef<bool> MonstermosDepressurization =
+        CVarDef.Create("atmos.monstermos_depressurization", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether monstermos explosive depressurization will rip tiles..
+    ///     Needs <see cref="MonstermosEqualization"/> and <see cref="MonstermosDepressurization"/> to be enabled to work.
+    ///     WARNING: This cvar causes MAJOR contrast issues, and usually tends to make any spaced scene look very cluttered.
+    ///     This not only usually looks strange, but can also reduce playability for people with impaired vision. Please think twice before enabling this on your server.
+    ///     Also looks weird on slow spacing for unrelated reasons. If you do want to enable this, you should probably turn on instaspacing.
+    /// </summary>
+    public static readonly CVarDef<bool> MonstermosRipTiles =
+        CVarDef.Create("atmos.monstermos_rip_tiles", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Taken as the cube of a tile's mass, this acts as a minimum threshold of mass for which air pressure calculates whether or not to rip a tile from the floor
+    ///     This should be set by default to the cube of the game's lowest mass tile as defined in their prototypes, but can be increased for server performance reasons
+    /// </summary>
+    public static readonly CVarDef<float> MonstermosRipTilesMinimumPressure =
+        CVarDef.Create("atmos.monstermos_rip_tiles_min_pressure", 20f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether explosive depressurization will cause the grid to gain an impulse.
+    ///     Needs <see cref="MonstermosEqualization"/> and <see cref="MonstermosDepressurization"/> to be enabled to work.
+    /// </summary>
+    public static readonly CVarDef<bool> AtmosGridImpulse =
+        CVarDef.Create("atmos.grid_impulse", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     What fraction of air from a spaced tile escapes every tick.
+    ///     1.0 for instant spacing, 0.2 means 20% of remaining air lost each time
+    /// </summary>
+    public static readonly CVarDef<float> AtmosSpacingEscapeRatio =
+        CVarDef.Create("atmos.mmos_spacing_speed", 0.05f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Minimum amount of air allowed on a spaced tile before it is reset to 0 immediately in kPa
+    ///     Since the decay due to SpacingEscapeRatio follows a curve, it would never reach 0.0 exactly
+    ///     unless we truncate it somewhere.
+    /// </summary>
+    public static readonly CVarDef<float> AtmosSpacingMinGas =
+        CVarDef.Create("atmos.mmos_min_gas", 2.0f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     How much wind can go through a single tile before that tile doesn't depressurize itself
+    ///     (I.e spacing is limited in large rooms heading into smaller spaces)
+    /// </summary>
+    public static readonly CVarDef<float> AtmosSpacingMaxWind =
+        CVarDef.Create("atmos.mmos_max_wind", 500f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Increases default airflow calculations to O(n^2) complexity, for use with heavy space wind optimizations. Potato servers BEWARE
+    /// This solves the problem of objects being trapped in an infinite loop of slamming into a wall repeatedly.
+    /// </summary>
+    public static readonly CVarDef<bool> MonstermosUseExpensiveAirflow =
+        CVarDef.Create("atmos.mmos_expensive_airflow", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether atmos superconduction is enabled.
+    /// </summary>
+    /// <remarks> Disabled by default, superconduction is awful. </remarks>
+    public static readonly CVarDef<bool> Superconduction =
+        CVarDef.Create("atmos.superconduction", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Heat loss per tile due to radiation at 20 degC, in W.
+    /// </summary>
+    public static readonly CVarDef<float> SuperconductionTileLoss =
+        CVarDef.Create("atmos.superconduction_tile_loss", 30f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether excited groups will be processed and created.
+    /// </summary>
+    public static readonly CVarDef<bool> ExcitedGroups =
+        CVarDef.Create("atmos.excited_groups", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether all tiles in an excited group will clear themselves once being exposed to space.
+    ///     Similar to <see cref="MonstermosDepressurization"/>, without none of the tile ripping or
+    ///     things being thrown around very violently.
+    ///     Needs <see cref="ExcitedGroups"/> to be enabled to work.
+    /// </summary>
+    public static readonly CVarDef<bool> ExcitedGroupsSpaceIsAllConsuming =
+        CVarDef.Create("atmos.excited_groups_space_is_all_consuming", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Maximum time in milliseconds that atmos can take processing.
+    /// </summary>
+    public static readonly CVarDef<float> AtmosMaxProcessTime =
+        CVarDef.Create("atmos.max_process_time", 3f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Atmos tickrate in TPS. Atmos processing will happen every 1/TPS seconds.
+    /// </summary>
+    public static readonly CVarDef<float> AtmosTickRate =
+        CVarDef.Create("atmos.tickrate", 15f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Scale factor for how fast things happen in our atmosphere
+    ///     simulation compared to real life. 1x means pumps run at 1x
+    ///     speed. Players typically expect things to happen faster
+    ///     in-game.
+    /// </summary>
+    public static readonly CVarDef<float> AtmosSpeedup =
+        CVarDef.Create("atmos.speedup", 8f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Like atmos.speedup, but only for gas and reaction heat values. 64x means
+    ///     gases heat up and cool down 64x faster than real life.
+    /// </summary>
+    public static readonly CVarDef<float> AtmosHeatScale =
+        CVarDef.Create("atmos.heat_scale", 8f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     A multiplier on the amount of force applied to Humanoid entities, as tracked by HumanoidAppearanceComponent
+    ///     This multiplier is added after all other checks are made, and applies to both throwing force, and how easy it is for an entity to be thrown.
+    /// </summary>
+    public static readonly CVarDef<float> AtmosHumanoidThrowMultiplier =
+        CVarDef.Create("atmos.humanoid_throw_multiplier", 2f, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Audio.cs b/Content.Shared/CCVar/CCVars.Audio.cs
new file mode 100644
index 0000000000..308383781a
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Audio.cs
@@ -0,0 +1,60 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    /// How long we'll wait until re-sampling nearby objects for ambience. Should be pretty fast, but doesn't have to match the tick rate.
+    /// </summary>
+    public static readonly CVarDef<float> AmbientCooldown =
+        CVarDef.Create("ambience.cooldown", 0.1f, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    /// How large of a range to sample for ambience.
+    /// </summary>
+    public static readonly CVarDef<float> AmbientRange =
+        CVarDef.Create("ambience.range", 8f, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    /// Maximum simultaneous ambient sounds.
+    /// </summary>
+    public static readonly CVarDef<int> MaxAmbientSources =
+        CVarDef.Create("ambience.max_sounds", 16, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    /// The minimum value the user can set for ambience.max_sounds
+    /// </summary>
+    public static readonly CVarDef<int> MinMaxAmbientSourcesConfigured =
+        CVarDef.Create("ambience.min_max_sounds_configured", 16, CVar.REPLICATED | CVar.SERVER | CVar.CHEAT);
+
+    /// <summary>
+    /// The maximum value the user can set for ambience.max_sounds
+    /// </summary>
+    public static readonly CVarDef<int> MaxMaxAmbientSourcesConfigured =
+        CVarDef.Create("ambience.max_max_sounds_configured", 64, CVar.REPLICATED | CVar.SERVER | CVar.CHEAT);
+
+    /// <summary>
+    /// Ambience volume.
+    /// </summary>
+    public static readonly CVarDef<float> AmbienceVolume =
+        CVarDef.Create("ambience.volume", 1.5f, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    /// Ambience music volume.
+    /// </summary>
+    public static readonly CVarDef<float> AmbientMusicVolume =
+        CVarDef.Create("ambience.music_volume", 1.5f, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    /// Lobby / round end music volume.
+    /// </summary>
+    public static readonly CVarDef<float> LobbyMusicVolume =
+        CVarDef.Create("ambience.lobby_music_volume", 0.50f, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    /// UI volume.
+    /// </summary>
+    public static readonly CVarDef<float> InterfaceVolume =
+        CVarDef.Create("audio.interface_volume", 0.50f, CVar.ARCHIVE | CVar.CLIENTONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.AutoVote.cs b/Content.Shared/CCVar/CCVars.AutoVote.cs
new file mode 100644
index 0000000000..3154a67731
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.AutoVote.cs
@@ -0,0 +1,20 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// Enables the automatic voting system.
+    public static readonly CVarDef<bool> AutoVoteEnabled =
+        CVarDef.Create("vote.autovote_enabled", true, CVar.SERVERONLY);
+
+    /// Automatically starts a map vote when returning to the lobby.
+    /// Requires auto voting to be enabled.
+    public static readonly CVarDef<bool> MapAutoVoteEnabled =
+        CVarDef.Create("vote.map_autovote_enabled", true, CVar.SERVERONLY);
+
+    /// Automatically starts a gamemode vote when returning to the lobby.
+    /// Requires auto voting to be enabled.
+    public static readonly CVarDef<bool> PresetAutoVoteEnabled =
+        CVarDef.Create("vote.preset_autovote_enabled", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.CPR.cs b/Content.Shared/CCVar/CCVars.CPR.cs
new file mode 100644
index 0000000000..8d7a27ede3
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.CPR.cs
@@ -0,0 +1,54 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /*
+        * CPR System
+        */
+    /// <summary>
+    ///     Controls whether the entire CPR system runs. When false, nobody can perform CPR. You should probably remove the trait too
+    ///     if you are wishing to permanently disable the system on your server.
+    /// </summary>
+    public static readonly CVarDef<bool> EnableCPR =
+        CVarDef.Create("cpr.enable", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles whether or not CPR reduces rot timers(As an abstraction of delaying brain death, the IRL actual purpose of CPR)
+    /// </summary>
+    public static readonly CVarDef<bool> CPRReducesRot =
+        CVarDef.Create("cpr.reduces_rot", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles whether or not CPR heals airloss, included for completeness sake. I'm not going to stop you if your intention is to make CPR do nothing.
+    ///     I guess it might be funny to troll your players with? I won't judge.
+    /// </summary>
+    public static readonly CVarDef<bool> CPRHealsAirloss =
+        CVarDef.Create("cpr.heals_airloss", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     The chance for a patient to be resuscitated when CPR is successfully performed.
+    ///     Setting this above 0 isn't very realistic, but people who see CPR in movies and TV will expect CPR to work this way.
+    /// </summary>
+    public static readonly CVarDef<float> CPRResuscitationChance =
+        CVarDef.Create("cpr.resuscitation_chance", 0.05f, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     By default, CPR reduces rot timers by an amount of seconds equal to the time spent performing CPR. This is an optional multiplier that can increase or decrease the amount
+    ///     of rot reduction. Set it to 2 for if you want 3 seconds of CPR to reduce 6 seconds of rot.
+    /// </summary>
+    /// <remarks>
+    ///     If you're wondering why there isn't a CVar for setting the duration of the doafter, that's because it's not actually possible to have a timespan in cvar form
+    ///     Curiously, it's also not possible for **shared** systems to set variable timespans. Which is where this system lives.
+    /// </remarks>
+    public static readonly CVarDef<float> CPRRotReductionMultiplier =
+        CVarDef.Create("cpr.rot_reduction_multiplier", 1f, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     By default, CPR heals airloss by 1 point for every second spent performing CPR. Just like above, this directly multiplies the healing amount.
+    ///     Set it to 2 to get 6 points of airloss healing for every 3 seconds of CPR.
+    /// </summary>
+    public static readonly CVarDef<float> CPRAirlossReductionMultiplier =
+        CVarDef.Create("cpr.airloss_reduction_multiplier", 1f, CVar.REPLICATED | CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.Chat.Looc.cs b/Content.Shared/CCVar/CCVars.Chat.Looc.cs
new file mode 100644
index 0000000000..84ee2c2807
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Chat.Looc.cs
@@ -0,0 +1,26 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> LoocEnabled =
+        CVarDef.Create("looc.enabled", true, CVar.NOTIFY | CVar.REPLICATED);
+
+    public static readonly CVarDef<bool> AdminLoocEnabled =
+        CVarDef.Create("looc.enabled_admin", true, CVar.NOTIFY);
+
+    /// <summary>
+    ///     True: Dead players can use LOOC
+    ///     False: Dead player LOOC gets redirected to dead chat
+    /// </summary>
+    public static readonly CVarDef<bool> DeadLoocEnabled =
+        CVarDef.Create("looc.enabled_dead", false, CVar.NOTIFY | CVar.REPLICATED);
+
+    /// <summary>
+    ///     True: Crit players can use LOOC
+    ///     False: Crit player LOOC gets redirected to dead chat
+    /// </summary>
+    public static readonly CVarDef<bool> CritLoocEnabled =
+        CVarDef.Create("looc.enabled_crit", false, CVar.NOTIFY | CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Chat.Ooc.cs b/Content.Shared/CCVar/CCVars.Chat.Ooc.cs
new file mode 100644
index 0000000000..ba5e41053b
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Chat.Ooc.cs
@@ -0,0 +1,27 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool>
+        OocEnabled = CVarDef.Create("ooc.enabled", true, CVar.NOTIFY | CVar.REPLICATED);
+
+    public static readonly CVarDef<bool> AdminOocEnabled =
+        CVarDef.Create("ooc.enabled_admin", true, CVar.NOTIFY);
+
+    /// <summary>
+    ///     If true, whenever OOC is disabled the Discord OOC relay will also be disabled.
+    /// </summary>
+    public static readonly CVarDef<bool> DisablingOOCDisablesRelay =
+        CVarDef.Create("ooc.disabling_ooc_disables_relay", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether or not OOC chat should be enabled during a round.
+    /// </summary>
+    public static readonly CVarDef<bool> OocEnableDuringRound =
+        CVarDef.Create("ooc.enable_during_round", false, CVar.NOTIFY | CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<bool> ShowOocPatronColor =
+        CVarDef.Create("ooc.show_ooc_patron_color", true, CVar.ARCHIVE | CVar.REPLICATED | CVar.CLIENT);
+}
diff --git a/Content.Shared/CCVar/CCVars.Chat.cs b/Content.Shared/CCVar/CCVars.Chat.cs
new file mode 100644
index 0000000000..7950e5f35a
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Chat.cs
@@ -0,0 +1,71 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Chat rate limit values are accounted in periods of this size (seconds).
+    ///     After the period has passed, the count resets.
+    /// </summary>
+    /// <seealso cref="ChatRateLimitCount"/>
+    public static readonly CVarDef<float> ChatRateLimitPeriod =
+        CVarDef.Create("chat.rate_limit_period", 2f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     How many chat messages are allowed in a single rate limit period.
+    /// </summary>
+    /// <remarks>
+    ///     The total rate limit throughput per second is effectively
+    ///     <see cref="ChatRateLimitCount"/> divided by <see cref="ChatRateLimitCount"/>.
+    /// </remarks>
+    /// <seealso cref="ChatRateLimitPeriod"/>
+    public static readonly CVarDef<int> ChatRateLimitCount =
+        CVarDef.Create("chat.rate_limit_count", 10, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Minimum delay (in seconds) between notifying admins about chat message rate limit violations.
+    ///     A negative value disables admin announcements.
+    /// </summary>
+    public static readonly CVarDef<int> ChatRateLimitAnnounceAdminsDelay =
+        CVarDef.Create("chat.rate_limit_announce_admins_delay", 15, CVar.SERVERONLY);
+
+    public static readonly CVarDef<int> ChatMaxMessageLength =
+        CVarDef.Create("chat.max_message_length", 1000, CVar.SERVER | CVar.REPLICATED);
+
+    public static readonly CVarDef<int> ChatMaxAnnouncementLength =
+        CVarDef.Create("chat.max_announcement_length", 256, CVar.SERVER | CVar.REPLICATED);
+
+    public static readonly CVarDef<bool> ChatSanitizerEnabled =
+        CVarDef.Create("chat.chat_sanitizer_enabled", true, CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> ChatShowTypingIndicator =
+        CVarDef.Create("chat.show_typing_indicator", true, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<bool> ChatEnableFancyBubbles =
+        CVarDef.Create("chat.enable_fancy_bubbles",
+            true,
+            CVar.CLIENTONLY | CVar.ARCHIVE,
+            "Toggles displaying fancy speech bubbles, which display the speaking character's name.");
+
+    public static readonly CVarDef<bool> ChatFancyNameBackground =
+        CVarDef.Create("chat.fancy_name_background",
+            false,
+            CVar.CLIENTONLY | CVar.ARCHIVE,
+            "Toggles displaying a background under the speaking character's name.");
+
+    public static readonly CVarDef<int> ChatStackLastLines =
+        CVarDef.Create("chat.chatstack_last_lines", 1, CVar.CLIENTONLY | CVar.ARCHIVE, "How far into the chat history to look when looking for similiar messages to coalesce them.");
+
+    /// <summary>
+    ///     A message broadcast to each player that joins the lobby.
+    ///     May be changed by admins ingame through use of the "set-motd" command.
+    ///     In this case the new value, if not empty, is broadcast to all connected players and saved between rounds.
+    ///     May be requested by any player through use of the "get-motd" command.
+    /// </summary>
+    public static readonly CVarDef<string> MOTD =
+        CVarDef.Create("chat.motd",
+            "",
+            CVar.SERVER | CVar.SERVERONLY | CVar.ARCHIVE,
+            "A message broadcast to each player that joins the lobby.");
+}
diff --git a/Content.Shared/CCVar/CCVars.Cloning.cs b/Content.Shared/CCVar/CCVars.Cloning.cs
new file mode 100644
index 0000000000..72472b1f6a
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Cloning.cs
@@ -0,0 +1,60 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     How much should the cost to clone an entity be multiplied by.
+    /// </summary>
+    public static readonly CVarDef<float> CloningBiomassCostMultiplier =
+        CVarDef.Create("cloning.biomass_cost_multiplier", 1f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether or not the Biomass Reclaimer is allowed to roundremove bodies with a soul.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningReclaimSouledBodies =
+        CVarDef.Create("cloning.reclaim_souled_bodies", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis will potentially give people a sex change.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveSex =
+        CVarDef.Create("cloning.preserve_sex", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis preserves Pronouns when reincarnating people.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveGender =
+        CVarDef.Create("cloning.preserve_gender", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis preserves Age.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveAge =
+        CVarDef.Create("cloning.preserve_age", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis preserves height.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveHeight =
+        CVarDef.Create("cloning.preserve_height", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis preserves width.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveWidth =
+        CVarDef.Create("cloning.preserve_width", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis preserves Names. EG: Are you actually a new person?
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveName =
+        CVarDef.Create("cloning.preserve_name", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls whether or not Metempsychosis preserves Flavor Text.
+    /// </summary>
+    public static readonly CVarDef<bool> CloningPreserveFlavorText =
+        CVarDef.Create("cloning.preserve_flavor_text", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Config.cs b/Content.Shared/CCVar/CCVars.Config.cs
new file mode 100644
index 0000000000..4e11f09ee7
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Config.cs
@@ -0,0 +1,35 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    // These are server-only for now since I don't foresee a client use yet,
+    // and I don't wanna have to start coming up with like .client suffixes and stuff like that.
+
+    /// <summary>
+    ///     Configuration presets to load during startup.
+    ///     Multiple presets can be separated by comma and are loaded in order.
+    /// </summary>
+    /// <remarks>
+    ///     Loaded presets must be located under the <c>ConfigPresets/</c> resource directory and end with the <c>.toml</c> extension.
+    ///     Only the file name (without extension) must be given for this variable.
+    /// </remarks>
+    public static readonly CVarDef<string> ConfigPresets =
+        CVarDef.Create("config.presets", "", CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether to load the preset development CVars.
+    ///     This disables some things like lobby to make development easier.
+    ///     Even when true, these are only loaded if the game is compiled with <c>DEVELOPMENT</c> set.
+    /// </summary>
+    public static readonly CVarDef<bool> ConfigPresetDevelopment =
+        CVarDef.Create("config.preset_development", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether to load the preset debug CVars.
+    ///     Even when true, these are only loaded if the game is compiled with <c>DEBUG</c> set.
+    /// </summary>
+    public static readonly CVarDef<bool> ConfigPresetDebug =
+        CVarDef.Create("config.preset_debug", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Console.cs b/Content.Shared/CCVar/CCVars.Console.cs
new file mode 100644
index 0000000000..e670b9f836
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Console.cs
@@ -0,0 +1,15 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> ConsoleLoginLocal =
+        CVarDef.Create("console.loginlocal", true, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Automatically log in the given user as host, equivalent to the <c>promotehost</c> command.
+    /// </summary>
+    public static readonly CVarDef<string> ConsoleLoginHostUser =
+        CVarDef.Create("console.login_host_user", "", CVar.ARCHIVE | CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Contests.cs b/Content.Shared/CCVar/CCVars.Contests.cs
new file mode 100644
index 0000000000..bfdab3e776
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Contests.cs
@@ -0,0 +1,57 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     The MASTER TOGGLE for the entire Contests System.
+    ///     ALL CONTESTS BELOW, regardless of type or setting will output 1f when false.
+    /// </summary>
+    public static readonly CVarDef<bool> DoContestsSystem =
+        CVarDef.Create("contests.do_contests_system", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Contest functions normally include an optional override to bypass the clamp set by max_percentage.
+    ///     This CVar disables the bypass when false, forcing all implementations to comply with max_percentage.
+    /// </summary>
+    public static readonly CVarDef<bool> AllowClampOverride =
+        CVarDef.Create("contests.allow_clamp_override", true, CVar.REPLICATED | CVar.SERVER);
+    /// <summary>
+    ///     Toggles all MassContest functions. All mass contests output 1f when false
+    /// </summary>
+    public static readonly CVarDef<bool> DoMassContests =
+        CVarDef.Create("contests.do_mass_contests", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles all StaminaContest functions. All stamina contests output 1f when false
+    /// </summary>
+    public static readonly CVarDef<bool> DoStaminaContests =
+        CVarDef.Create("contests.do_stamina_contests", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles all HealthContest functions. All health contests output 1f when false
+    /// </summary>
+    public static readonly CVarDef<bool> DoHealthContests =
+        CVarDef.Create("contests.do_health_contests", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles all MindContest functions. All mind contests output 1f when false.
+    ///     MindContests are not currently implemented, and are awaiting completion of the Psionic Refactor
+    /// </summary>
+    public static readonly CVarDef<bool> DoMindContests =
+        CVarDef.Create("contests.do_mind_contests", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles all MoodContest functions. All mood contests output 1f when false.
+    /// </summary>
+    public static readonly CVarDef<bool> DoMoodContests =
+        CVarDef.Create("contests.do_mood_contests", true, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     The maximum amount that Mass Contests can modify a physics multiplier, given as a +/- percentage
+    ///     Default of 0.25f outputs between * 0.75f and 1.25f
+    /// </summary>
+    public static readonly CVarDef<float> MassContestsMaxPercentage =
+        CVarDef.Create("contests.max_percentage", 0.25f, CVar.REPLICATED | CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.Crewmanifest.cs b/Content.Shared/CCVar/CCVars.Crewmanifest.cs
new file mode 100644
index 0000000000..d6251886b9
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Crewmanifest.cs
@@ -0,0 +1,24 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Setting this allows a crew manifest to be opened from any window
+    ///     that has a crew manifest button, and sends the correct message.
+    ///     If this is false, only in-game entities will allow you to see
+    ///     the crew manifest, if the functionality is coded in.
+    ///     Having administrator priveledge ignores this, but will still
+    ///     hide the button in UI windows.
+    /// </summary>
+    public static readonly CVarDef<bool> CrewManifestWithoutEntity =
+        CVarDef.Create("crewmanifest.no_entity", true, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Setting this allows the crew manifest to be viewed from 'unsecure'
+    ///     entities, such as the PDA.
+    /// </summary>
+    public static readonly CVarDef<bool> CrewManifestUnsecure =
+        CVarDef.Create("crewmanifest.unsecure", true, CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Database.cs b/Content.Shared/CCVar/CCVars.Database.cs
new file mode 100644
index 0000000000..cf36bc5ba9
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Database.cs
@@ -0,0 +1,76 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<string> DatabaseEngine =
+        CVarDef.Create("database.engine", "sqlite", CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> DatabaseSqliteDbPath =
+        CVarDef.Create("database.sqlite_dbpath", "preferences.db", CVar.SERVERONLY);
+
+    /// <summary>
+    /// Milliseconds to asynchronously delay all SQLite database acquisitions with.
+    /// </summary>
+    /// <remarks>
+    /// Defaults to 1 on DEBUG, 0 on RELEASE.
+    /// This is intended to help catch .Result deadlock bugs that only happen on postgres
+    /// (because SQLite is not actually asynchronous normally)
+    /// </remarks>
+    public static readonly CVarDef<int> DatabaseSqliteDelay =
+        CVarDef.Create("database.sqlite_delay", DefaultSqliteDelay, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Amount of concurrent SQLite database operations.
+    /// </summary>
+    /// <remarks>
+    /// Note that SQLite is not a properly asynchronous database and also has limited read/write concurrency.
+    /// Increasing this number may allow more concurrent reads, but it probably won't matter much.
+    /// SQLite operations are normally ran on the thread pool, which may cause thread pool starvation if the concurrency is too high.
+    /// </remarks>
+    public static readonly CVarDef<int> DatabaseSqliteConcurrency =
+        CVarDef.Create("database.sqlite_concurrency", 3, CVar.SERVERONLY);
+
+#if DEBUG
+    private const int DefaultSqliteDelay = 1;
+#else
+    private const int DefaultSqliteDelay = 0;
+#endif
+
+
+    public static readonly CVarDef<string> DatabasePgHost =
+        CVarDef.Create("database.pg_host", "localhost", CVar.SERVERONLY);
+
+    public static readonly CVarDef<int> DatabasePgPort =
+        CVarDef.Create("database.pg_port", 5432, CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> DatabasePgDatabase =
+        CVarDef.Create("database.pg_database", "ss14", CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> DatabasePgUsername =
+        CVarDef.Create("database.pg_username", "postgres", CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> DatabasePgPassword =
+        CVarDef.Create("database.pg_password", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+    /// <summary>
+    /// Max amount of concurrent Postgres database operations.
+    /// </summary>
+    public static readonly CVarDef<int> DatabasePgConcurrency =
+        CVarDef.Create("database.pg_concurrency", 8, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Milliseconds to asynchronously delay all PostgreSQL database operations with.
+    /// </summary>
+    /// <remarks>
+    /// This is intended for performance testing. It works different from <see cref="DatabaseSqliteDelay"/>,
+    /// as the lag is applied after acquiring the database lock.
+    /// </remarks>
+    public static readonly CVarDef<int> DatabasePgFakeLag =
+        CVarDef.Create("database.pg_fake_lag", 0, CVar.SERVERONLY);
+
+    // Basically only exists for integration tests to avoid race conditions.
+    public static readonly CVarDef<bool> DatabaseSynchronous =
+        CVarDef.Create("database.sync", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Discord.cs b/Content.Shared/CCVar/CCVars.Discord.cs
new file mode 100644
index 0000000000..10fe6e1f44
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Discord.cs
@@ -0,0 +1,72 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    /// The role that will get mentioned if a new SOS ahelp comes in.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordAhelpMention =
+        CVarDef.Create("discord.on_call_ping", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+    /// <summary>
+    /// URL of the discord webhook to relay unanswered ahelp messages.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordOnCallWebhook =
+        CVarDef.Create("discord.on_call_webhook", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+    /// <summary>
+    /// URL of the Discord webhook which will relay all ahelp messages.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordAHelpWebhook =
+        CVarDef.Create("discord.ahelp_webhook", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+    /// <summary>
+    /// The server icon to use in the Discord ahelp embed footer.
+    /// Valid values are specified at https://discord.com/developers/docs/resources/channel#embed-object-embed-footer-structure.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordAHelpFooterIcon =
+        CVarDef.Create("discord.ahelp_footer_icon", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The avatar to use for the webhook. Should be an URL.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordAHelpAvatar =
+        CVarDef.Create("discord.ahelp_avatar", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    /// URL of the Discord webhook which will relay all custom votes. If left empty, disables the webhook.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordVoteWebhook =
+        CVarDef.Create("discord.vote_webhook", string.Empty, CVar.SERVERONLY);
+
+    /// URL of the Discord webhook which will relay round restart messages.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordRoundUpdateWebhook =
+        CVarDef.Create("discord.round_update_webhook", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+    /// <summary>
+    /// Role id for the Discord webhook to ping when the round ends.
+    /// </summary>
+    public static readonly CVarDef<string> DiscordRoundEndRoleWebhook =
+        CVarDef.Create("discord.round_end_role", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Enable Discord linking, show linking button and modal window
+    /// </summary>
+    public static readonly CVarDef<bool> DiscordAuthEnabled =
+        CVarDef.Create("discord.auth_enabled", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     URL of the Discord auth server API
+    /// </summary>
+    public static readonly CVarDef<string> DiscordAuthApiUrl =
+        CVarDef.Create("discord.auth_api_url", "", CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Secret key of the Discord auth server API
+    /// </summary>
+    public static readonly CVarDef<string> DiscordAuthApiKey =
+        CVarDef.Create("discord.auth_api_key", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
+}
diff --git a/Content.Shared/CCVar/CCVars.Events.cs b/Content.Shared/CCVar/CCVars.Events.cs
new file mode 100644
index 0000000000..61e4ae173d
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Events.cs
@@ -0,0 +1,26 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Controls if the game should run station events
+    /// </summary>
+    public static readonly CVarDef<bool>
+        EventsEnabled = CVarDef.Create("events.enabled", true, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Average time (in minutes) for when the ramping event scheduler should stop increasing the chaos modifier.
+    ///     Close to how long you expect a round to last, so you'll probably have to tweak this on downstreams.
+    /// </summary>
+    public static readonly CVarDef<float>
+        EventsRampingAverageEndTime = CVarDef.Create("events.ramping_average_end_time", 40f, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Average ending chaos modifier for the ramping event scheduler.
+    ///     Max chaos chosen for a round will deviate from this
+    /// </summary>
+    public static readonly CVarDef<float>
+        EventsRampingAverageChaos = CVarDef.Create("events.ramping_average_chaos", 6f, CVar.ARCHIVE | CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Explosion.cs b/Content.Shared/CCVar/CCVars.Explosion.cs
new file mode 100644
index 0000000000..51d93456b7
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Explosion.cs
@@ -0,0 +1,108 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     How many tiles the explosion system will process per tick
+    /// </summary>
+    /// <remarks>
+    ///     Setting this too high will put a large load on a single tick. Setting this too low will lead to
+    ///     unnaturally "slow" explosions.
+    /// </remarks>
+    public static readonly CVarDef<int> ExplosionTilesPerTick =
+        CVarDef.Create("explosion.tiles_per_tick", 100, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Upper limit on the size of an explosion before physics-throwing is disabled.
+    /// </summary>
+    /// <remarks>
+    ///     Large nukes tend to generate a lot of shrapnel that flies through space. This can functionally cripple
+    ///     the server TPS for a while after an explosion (or even during, if the explosion is processed
+    ///     incrementally.
+    /// </remarks>
+    public static readonly CVarDef<int> ExplosionThrowLimit =
+        CVarDef.Create("explosion.throw_limit", 400, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If this is true, explosion processing will pause the NodeGroupSystem to pause updating.
+    /// </summary>
+    /// <remarks>
+    ///     This only takes effect if an explosion needs more than one tick to process (i.e., covers more than <see
+    ///     cref="ExplosionTilesPerTick"/> tiles). If this is not enabled, the node-system will rebuild its graph
+    ///     every tick as the explosion shreds the station, causing significant slowdown.
+    /// </remarks>
+    public static readonly CVarDef<bool> ExplosionSleepNodeSys =
+        CVarDef.Create("explosion.node_sleep", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Upper limit on the total area that an explosion can affect before the neighbor-finding algorithm just
+    ///     stops. Defaults to a 60-rile radius explosion.
+    /// </summary>
+    /// <remarks>
+    ///     Actual area may be larger, as it currently doesn't terminate mid neighbor finding. I.e., area may be that of a ~51 tile radius circle instead.
+    /// </remarks>
+    public static readonly CVarDef<int> ExplosionMaxArea =
+        CVarDef.Create("explosion.max_area", (int)3.14f * 256 * 256, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Upper limit on the number of neighbor finding steps for the explosion system neighbor-finding algorithm.
+    /// </summary>
+    /// <remarks>
+    ///     Effectively places an upper limit on the range that any explosion can have. In the vast majority of
+    ///     instances, <see cref="ExplosionMaxArea"/> will likely be hit before this becomes a limiting factor.
+    /// </remarks>
+    public static readonly CVarDef<int> ExplosionMaxIterations =
+        CVarDef.Create("explosion.max_iterations", 500, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Max Time in milliseconds to spend processing explosions every tick.
+    /// </summary>
+    /// <remarks>
+    ///     This time limiting is not perfectly implemented. Firstly, a significant chunk of processing time happens
+    ///     due to queued entity deletions, which happen outside of the system update code. Secondly, explosion
+    ///     spawning cannot currently be interrupted & resumed, and may lead to exceeding this time limit.
+    /// </remarks>
+    public static readonly CVarDef<float> ExplosionMaxProcessingTime =
+        CVarDef.Create("explosion.max_tick_time", 7f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If the explosion is being processed incrementally over several ticks, this variable determines whether
+    ///     updating the grid tiles should be done incrementally at the end of every tick, or only once the explosion has finished processing.
+    /// </summary>
+    /// <remarks>
+    ///     The most notable consequence of this change is that explosions will only punch a hole in the station &
+    ///     create a vacumm once they have finished exploding. So airlocks will no longer slam shut as the explosion
+    ///     expands, just suddenly at the end.
+    /// </remarks>
+    public static readonly CVarDef<bool> ExplosionIncrementalTileBreaking =
+        CVarDef.Create("explosion.incremental_tile", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     This determines for how many seconds an explosion should stay visible once it has finished expanding.
+    /// </summary>
+    public static readonly CVarDef<float> ExplosionPersistence =
+        CVarDef.Create("explosion.persistence", 1.0f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If an explosion covers a larger area than this number, the damaging/processing will always start during
+    ///     the next tick, instead of during the same tick that the explosion was generated in.
+    /// </summary>
+    /// <remarks>
+    ///     This value can be used to ensure that for large explosions the area/tile calculation and the explosion
+    ///     processing/damaging occurs in separate ticks. This helps reduce the single-tick lag if both <see
+    ///     cref="ExplosionMaxProcessingTime"/> and <see cref="ExplosionTilesPerTick"/> are large. I.e., instead of
+    ///     a single tick explosion, this cvar allows for a configuration that results in a two-tick explosion,
+    ///     though most of the computational cost is still in the second tick.
+    /// </remarks>
+    public static readonly CVarDef<int> ExplosionSingleTickAreaLimit =
+        CVarDef.Create("explosion.single_tick_area_limit", 400, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether or not explosions are allowed to create tiles that have
+    ///     <see cref="ContentTileDefinition.MapAtmosphere"/> set to true.
+    /// </summary>
+    public static readonly CVarDef<bool> ExplosionCanCreateVacuum =
+        CVarDef.Create("explosion.can_create_vacuum", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.FOV.cs b/Content.Shared/CCVar/CCVars.FOV.cs
new file mode 100644
index 0000000000..7983a8525f
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.FOV.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     The number by which the current FOV size is divided for each level.
+    /// </summary>
+    public static readonly CVarDef<float> ZoomLevelStep =
+        CVarDef.Create("fov.zoom_step", 1.2f, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     How many times the player can zoom in until they reach the minimum zoom.
+    ///     This does not affect the maximum zoom.
+    /// </summary>
+    public static readonly CVarDef<int> ZoomLevels =
+        CVarDef.Create("fov.zoom_levels", 7, CVar.SERVER | CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Game.Infolinks.cs b/Content.Shared/CCVar/CCVars.Game.Infolinks.cs
new file mode 100644
index 0000000000..fa8332b497
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Game.Infolinks.cs
@@ -0,0 +1,54 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Link to Discord server to show in the launcher.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksDiscord =
+        CVarDef.Create("infolinks.discord", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to website to show in the launcher.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksForum =
+        CVarDef.Create("infolinks.forum", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to GitHub page to show in the launcher.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksGithub =
+        CVarDef.Create("infolinks.github", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to website to show in the launcher.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksWebsite =
+        CVarDef.Create("infolinks.website", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to wiki to show in the launcher.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksWiki =
+        CVarDef.Create("infolinks.wiki", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to Patreon. Not shown in the launcher currently.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksPatreon =
+        CVarDef.Create("infolinks.patreon", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to the bug report form.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksBugReport =
+        CVarDef.Create("infolinks.bug_report", "", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Link to site handling ban appeals. Shown in ban disconnect messages.
+    /// </summary>
+    public static readonly CVarDef<string> InfoLinksAppeal =
+        CVarDef.Create("infolinks.appeal", "", CVar.SERVER | CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Game.cs b/Content.Shared/CCVar/CCVars.Game.cs
new file mode 100644
index 0000000000..a1ee8ef8e6
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Game.cs
@@ -0,0 +1,396 @@
+using Content.Shared.Roles;
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Disables most functionality in the GameTicker.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameDummyTicker = CVarDef.Create("game.dummyticker", false, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls if the lobby is enabled. If it is not, and there are no available jobs, you may get stuck on a black screen.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameLobbyEnabled = CVarDef.Create("game.lobbyenabled", true, CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Controls the duration of the lobby timer in seconds. Defaults to 2 minutes and 30 seconds.
+    /// </summary>
+    public static readonly CVarDef<int>
+        GameLobbyDuration = CVarDef.Create("game.lobbyduration", 150, CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Controls if players can latejoin at all.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameDisallowLateJoins = CVarDef.Create("game.disallowlatejoins", false, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls the default game preset.
+    /// </summary>
+    public static readonly CVarDef<string>
+        GameLobbyDefaultPreset = CVarDef.Create("game.defaultpreset", "secret", CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Controls if the game can force a different preset if the current preset's criteria are not met.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameLobbyFallbackEnabled = CVarDef.Create("game.fallbackenabled", true, CVar.ARCHIVE);
+
+    /// <summary>
+    ///     The preset for the game to fall back to if the selected preset could not be used, and fallback is enabled.
+    /// </summary>
+    public static readonly CVarDef<string>
+        GameLobbyFallbackPreset = CVarDef.Create("game.fallbackpreset", "Traitor,Extended", CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Controls if people can win the game in Suspicion or Deathmatch.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameLobbyEnableWin = CVarDef.Create("game.enablewin", true, CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Minimum time between Basic station events in seconds
+    /// </summary>
+    public static readonly CVarDef<int> // 5 Minutes
+        GameEventsBasicMinimumTime = CVarDef.Create("game.events_basic_minimum_time", 300, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Maximum time between Basic station events in seconds
+    /// </summary>
+    public static readonly CVarDef<int> // 25 Minutes
+        GameEventsBasicMaximumTime = CVarDef.Create("game.events_basic_maximum_time", 1500, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Minimum time between Ramping station events in seconds
+    /// </summary>
+    public static readonly CVarDef<int> // 4 Minutes
+        GameEventsRampingMinimumTime = CVarDef.Create("game.events_ramping_minimum_time", 240, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Maximum time between Ramping station events in seconds
+    /// </summary>
+    public static readonly CVarDef<int> // 12 Minutes
+        GameEventsRampingMaximumTime = CVarDef.Create("game.events_ramping_maximum_time", 720, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Minimum time between Oscillating station events in seconds. This is the bare minimum which will never be violated, unlike with ramping events.
+    /// </summary>
+    public static readonly CVarDef<int> // 40 seconds
+        GameEventsOscillatingMinimumTime = CVarDef.Create("game.events_oscillating_minimum_time", 40, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Time between Oscillating station events in seconds at 1x chaos level. Events may occur at larger intervals if current chaos is lower than that.
+    /// </summary>
+    public static readonly CVarDef<int> // 20 Minutes - which constitutes a minimum of 120 seconds between events in Irregular and 280 seconds in Extended Irregular
+        GameEventsOscillatingAverageTime = CVarDef.Create("game.events_oscillating_average_time", 1200, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Controls the maximum number of character slots a player is allowed to have.
+    /// </summary>
+    public static readonly CVarDef<int>
+        GameMaxCharacterSlots = CVarDef.Create("game.maxcharacterslots", 30, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Controls the game map prototype to load. SS14 stores these prototypes in Prototypes/Maps.
+    /// </summary>
+    public static readonly CVarDef<string>
+        GameMap = CVarDef.Create("game.map", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    /// If roles should be restricted based on whether or not they are whitelisted.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameRoleWhitelist = CVarDef.Create("game.role_whitelist", true, CVar.SERVER | CVar.REPLICATED);
+
+
+    /// <summary>
+    ///     Controls whether to use world persistence or not.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        UsePersistence = CVarDef.Create("game.usepersistence", false, CVar.ARCHIVE);
+
+    /// <summary>
+    ///     If world persistence is used, what map prototype should be initially loaded.
+    ///     If the save file exists, it replaces MapPath but everything else stays the same (station name and such).
+    /// </summary>
+    public static readonly CVarDef<string>
+        PersistenceMap = CVarDef.Create("game.persistencemap", "Empty", CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Prototype to use for map pool.
+    /// </summary>
+    public static readonly CVarDef<string>
+        GameMapPool = CVarDef.Create("game.map_pool", "DefaultMapPool", CVar.SERVERONLY);
+
+    /// <summary>
+    /// The depth of the queue used to calculate which map is next in rotation.
+    /// This is how long the game "remembers" that some map was put in play. Default is 16 rounds.
+    /// </summary>
+    public static readonly CVarDef<int>
+        GameMapMemoryDepth = CVarDef.Create("game.map_memory_depth", 16, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Is map rotation enabled?
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameMapRotation = CVarDef.Create("game.map_rotation", true, CVar.SERVERONLY);
+
+    /// <summary>
+    /// If roles should be restricted based on time.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameRoleTimers = CVarDef.Create("game.role_timers", true, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    /// Whether or not disconnecting inside of a cryopod should remove the character or just store them until they reconnect.
+    /// </summary>
+    public static readonly CVarDef<bool>
+        GameCryoSleepRejoining = CVarDef.Create("game.cryo_sleep_rejoining", false, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     When enabled, guests will be assigned permanent UIDs and will have their preferences stored.
+    /// </summary>
+    public static readonly CVarDef<bool> GamePersistGuests =
+        CVarDef.Create("game.persistguests", true, CVar.ARCHIVE | CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> GameDiagonalMovement =
+        CVarDef.Create("game.diagonalmovement", true, CVar.ARCHIVE);
+
+    public static readonly CVarDef<int> SoftMaxPlayers =
+        CVarDef.Create("game.soft_max_players", 30, CVar.SERVERONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    /// If a player gets denied connection to the server,
+    /// how long they are forced to wait before attempting to reconnect.
+    /// </summary>
+    public static readonly CVarDef<int> GameServerFullReconnectDelay =
+        CVarDef.Create("game.server_full_reconnect_delay", 30, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether or not panic bunker is currently enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> PanicBunkerEnabled =
+        CVarDef.Create("game.panic_bunker.enabled", false, CVar.NOTIFY | CVar.REPLICATED);
+
+    /// <summary>
+    /// Whether or not the panic bunker will disable when an admin comes online.
+    /// </summary>
+    public static readonly CVarDef<bool> PanicBunkerDisableWithAdmins =
+        CVarDef.Create("game.panic_bunker.disable_with_admins", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether or not the panic bunker will enable when no admins are online.
+    /// </summary>
+    public static readonly CVarDef<bool> PanicBunkerEnableWithoutAdmins =
+        CVarDef.Create("game.panic_bunker.enable_without_admins", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether or not the panic bunker will count deadminned admins for
+    /// <see cref="PanicBunkerDisableWithAdmins"/> and
+    /// <see cref="PanicBunkerEnableWithoutAdmins"/>
+    /// </summary>
+    public static readonly CVarDef<bool> PanicBunkerCountDeadminnedAdmins =
+        CVarDef.Create("game.panic_bunker.count_deadminned_admins", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Show reason of disconnect for user or not.
+    /// </summary>
+    public static readonly CVarDef<bool> PanicBunkerShowReason =
+        CVarDef.Create("game.panic_bunker.show_reason", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Minimum age of the account (from server's PoV, so from first-seen date) in hours.
+    /// </summary>
+    public static readonly CVarDef<int> PanicBunkerMinAccountAge =
+        CVarDef.Create("game.panic_bunker.min_account_age", 24, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Minimal overall played time.
+    /// </summary>
+    public static readonly CVarDef<int> PanicBunkerMinOverallHours =
+        CVarDef.Create("game.panic_bunker.min_overall_hours", 10, CVar.SERVERONLY);
+
+    /// <summary>
+    /// A custom message that will be used for connections denied to the panic bunker
+    /// If not empty, then will overwrite <see cref="PanicBunkerShowReason"/>
+    /// </summary>
+    public static readonly CVarDef<string> PanicBunkerCustomReason =
+        CVarDef.Create("game.panic_bunker.custom_reason", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Allow bypassing the panic bunker if the user is whitelisted.
+    /// </summary>
+    public static readonly CVarDef<bool> BypassBunkerWhitelist =
+        CVarDef.Create("game.panic_bunker.whitelisted_can_bypass", true, CVar.SERVERONLY);
+
+    /*
+        * TODO: Remove baby jail code once a more mature gateway process is established. This code is only being issued as a stopgap to help with potential tiding in the immediate future.
+        */
+
+    /// <summary>
+    /// Whether the baby jail is currently enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> BabyJailEnabled  =
+        CVarDef.Create("game.baby_jail.enabled", false, CVar.NOTIFY | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    /// Show reason of disconnect for user or not.
+    /// </summary>
+    public static readonly CVarDef<bool> BabyJailShowReason =
+        CVarDef.Create("game.baby_jail.show_reason", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Maximum age of the account (from server's PoV, so from first-seen date) in hours that can access baby
+    /// jailed servers.
+    /// </summary>
+    public static readonly CVarDef<int> BabyJailMaxAccountAge =
+        CVarDef.Create("game.baby_jail.max_account_age", 24, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Maximum overall played time allowed to access baby jailed servers.
+    /// </summary>
+    public static readonly CVarDef<int> BabyJailMaxOverallHours =
+        CVarDef.Create("game.baby_jail.max_overall_hours", 2, CVar.SERVERONLY);
+
+    /// <summary>
+    /// A custom message that will be used for connections denied due to the baby jail.
+    /// If not empty, then will overwrite <see cref="BabyJailShowReason"/>
+    /// </summary>
+    public static readonly CVarDef<string> BabyJailCustomReason =
+        CVarDef.Create("game.baby_jail.custom_reason", string.Empty, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Allow bypassing the baby jail if the user is whitelisted.
+    /// </summary>
+    public static readonly CVarDef<bool> BypassBabyJailWhitelist =
+        CVarDef.Create("game.baby_jail.whitelisted_can_bypass", true, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Make people bonk when trying to climb certain objects like tables.
+    /// </summary>
+    public static readonly CVarDef<bool> GameTableBonk =
+        CVarDef.Create("game.table_bonk", false, CVar.REPLICATED);
+
+    /// <summary>
+    /// Whether or not status icons are rendered for everyone.
+    /// </summary>
+    public static readonly CVarDef<bool> GlobalStatusIconsEnabled =
+        CVarDef.Create("game.global_status_icons_enabled", true, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    /// Whether or not status icons are rendered on this specific client.
+    /// </summary>
+    public static readonly CVarDef<bool> LocalStatusIconsEnabled =
+        CVarDef.Create("game.local_status_icons_enabled", true, CVar.CLIENTONLY);
+
+    /// <summary>
+    /// Whether or not coordinates on the Debug overlay should only be available to admins.
+    /// </summary>
+    public static readonly CVarDef<bool> DebugCoordinatesAdminOnly =
+        CVarDef.Create("game.debug_coordinates_admin_only", true, CVar.SERVER | CVar.REPLICATED);
+
+
+    /// <summary>
+    ///     Whether to allow characters to select traits.
+    /// </summary>
+    public static readonly CVarDef<bool> GameTraitsEnabled =
+        CVarDef.Create("game.traits_enabled", true, CVar.REPLICATED);
+
+    /// <summary>
+    ///     How many traits a character can have at most.
+    /// </summary>
+    public static readonly CVarDef<int> GameTraitsMax =
+        CVarDef.Create("game.traits_max", 14, CVar.REPLICATED);
+
+    /// <summary>
+    ///     How many points a character should start with.
+    /// </summary>
+    public static readonly CVarDef<int> GameTraitsDefaultPoints =
+        CVarDef.Create("game.traits_default_points", 10, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether the game will SMITE people who used cheat engine to spawn with all of the traits.
+    ///     Illegal trait totals will still be logged even if this is disabled.
+    ///     If you are intending to decrease the trait points availability, or modify the costs of traits, consider temporarily disabling this.
+    /// </summary>
+    public static readonly CVarDef<bool> TraitsPunishCheaters =
+        CVarDef.Create("game.traits_punish_cheaters", false, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether to allow characters to select loadout items.
+    /// </summary>
+    public static readonly CVarDef<bool> GameLoadoutsEnabled =
+        CVarDef.Create("game.loadouts_enabled", true, CVar.REPLICATED);
+
+    /// <summary>
+    ///     How many points to give to each player for loadouts.
+    /// </summary>
+    public static readonly CVarDef<int> GameLoadoutsPoints =
+        CVarDef.Create("game.loadouts_points", 14, CVar.REPLICATED);
+
+
+    /// <summary>
+    ///     Whether to repeat eating doafters after completion
+    /// </summary>
+    public static readonly CVarDef<bool> GameAutoEatFood =
+        CVarDef.Create("game.auto_eat_food", false, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether to repeat drinking doafters after completion
+    /// </summary>
+    public static readonly CVarDef<bool> GameAutoEatDrinks =
+        CVarDef.Create("game.auto_eat_drinks", false, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether item slots, such as power cell slots or AME fuel cell slots, should support quick swap if it is not otherwise specified in their YAML prototype.
+    /// </summary>
+    public static readonly CVarDef<bool> AllowSlotQuickSwap =
+        CVarDef.Create("game.slot_quick_swap", false, CVar.REPLICATED);
+
+#if EXCEPTION_TOLERANCE
+    /// <summary>
+    ///     Amount of times round start must fail before the server is shut down.
+    ///     Set to 0 or a negative number to disable.
+    /// </summary>
+    public static readonly CVarDef<int> RoundStartFailShutdownCount =
+        CVarDef.Create("game.round_start_fail_shutdown_count", 5, CVar.SERVERONLY | CVar.SERVER);
+#endif
+
+    /// <summary>
+    /// Delay between station alert level changes.
+    /// </summary>
+    public static readonly CVarDef<int> GameAlertLevelChangeDelay =
+        CVarDef.Create("game.alert_level_change_delay", 30, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The time in seconds that the server should wait before restarting the round.
+    /// Defaults to 2 minutes.
+    /// </summary>
+    public static readonly CVarDef<float> RoundRestartTime =
+        CVarDef.Create("game.round_restart_time", 120f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The prototype to use for secret weights.
+    /// </summary>
+    public static readonly CVarDef<string> SecretWeightPrototype =
+        CVarDef.Create("game.secret_weight_prototype", "Secret", CVar.SERVERONLY);
+
+    /// <summary>
+    /// The id of the sound collection to randomly choose a sound from and play when the round ends.
+    /// </summary>
+    public static readonly CVarDef<string> RoundEndSoundCollection =
+        CVarDef.Create("game.round_end_sound_collection", "RoundEnd", CVar.SERVERONLY);
+
+    /// <summary>
+    /// Set to true to enable the dynamic hostname system.
+    /// Automatically updates the hostname to include current map and preset.
+    /// Configure what that looks like for you in Resources/Prototypes/Locale/en-US/dynamichostname/hostname.ftl
+    /// </summary>
+    public static readonly CVarDef<bool> UseDynamicHostname =
+        CVarDef.Create("game.use_dynamic_hostname", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Ghost.cs b/Content.Shared/CCVar/CCVars.Ghost.cs
new file mode 100644
index 0000000000..c0a91668ae
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Ghost.cs
@@ -0,0 +1,24 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     The time you must spend reading the rules, before the "Request" button is enabled
+    /// </summary>
+    public static readonly CVarDef<float> GhostRoleTime =
+        CVarDef.Create("ghost.role_time", 8f, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     If ghost role lotteries should be made near-instanteous.
+    /// </summary>
+    public static readonly CVarDef<bool> GhostQuickLottery =
+        CVarDef.Create("ghost.quick_lottery", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether or not to kill the player's mob on ghosting, when it is in a critical health state.
+    /// </summary>
+    public static readonly CVarDef<bool> GhostKillCrit =
+        CVarDef.Create("ghost.kill_crit", true, CVar.REPLICATED | CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.GhostRespawn.cs b/Content.Shared/CCVar/CCVars.GhostRespawn.cs
new file mode 100644
index 0000000000..9eb3e6aa46
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.GhostRespawn.cs
@@ -0,0 +1,15 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<double> GhostRespawnTime =
+        CVarDef.Create("ghost.respawn_time", 15d, CVar.SERVERONLY);
+
+    public static readonly CVarDef<int> GhostRespawnMaxPlayers =
+        CVarDef.Create("ghost.respawn_max_players", 40, CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> GhostAllowSameCharacter =
+        CVarDef.Create("ghost.allow_same_character", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.HeightSliders.cs b/Content.Shared/CCVar/CCVars.HeightSliders.cs
new file mode 100644
index 0000000000..c49ae5d512
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.HeightSliders.cs
@@ -0,0 +1,27 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Whether height & width sliders adjust a character's Fixture Component
+    /// </summary>
+    public static readonly CVarDef<bool> HeightAdjustModifiesHitbox =
+        CVarDef.Create("heightadjust.modifies_hitbox", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether height & width sliders adjust a player's max view distance
+    /// </summary>
+    public static readonly CVarDef<bool> HeightAdjustModifiesZoom =
+        CVarDef.Create("heightadjust.modifies_zoom", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether height & width sliders adjust a player's bloodstream volume.
+    /// </summary>
+    /// <remarks>
+    ///     This can be configured more precisely by modifying BloodstreamAffectedByMassComponent.
+    /// </remarks>
+    public static readonly CVarDef<bool> HeightAdjustModifiesBloodstream =
+        CVarDef.Create("heightadjust.modifies_bloodstream", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Hud.cs b/Content.Shared/CCVar/CCVars.Hud.cs
new file mode 100644
index 0000000000..f1adbb1851
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Hud.cs
@@ -0,0 +1,27 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<int> HudTheme =
+        CVarDef.Create("hud.theme", 0, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> HudHeldItemShow =
+        CVarDef.Create("hud.held_item_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> OfferModeIndicatorsPointShow =
+        CVarDef.Create("hud.offer_mode_indicators_point_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> CombatModeIndicatorsPointShow =
+        CVarDef.Create("hud.combat_mode_indicators_point_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> LoocAboveHeadShow =
+        CVarDef.Create("hud.show_looc_above_head", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<float> HudHeldItemOffset =
+        CVarDef.Create("hud.held_item_offset", 28f, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> HudFpsCounterVisible =
+        CVarDef.Create("hud.fps_counter_visible", false, CVar.CLIENTONLY | CVar.ARCHIVE);
+}
diff --git a/Content.Shared/CCVar/CCVars.Ic.cs b/Content.Shared/CCVar/CCVars.Ic.cs
new file mode 100644
index 0000000000..51839030c5
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Ic.cs
@@ -0,0 +1,48 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Restricts IC character names to alphanumeric chars.
+    /// </summary>
+    public static readonly CVarDef<bool> RestrictedNames =
+        CVarDef.Create("ic.restricted_names", true, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Allows flavor text (character descriptions)
+    /// </summary>
+    public static readonly CVarDef<bool> FlavorText =
+        CVarDef.Create("ic.flavor_text", true, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Adds a period at the end of a sentence if the sentence ends in a letter.
+    /// </summary>
+    public static readonly CVarDef<bool> ChatPunctuation =
+        CVarDef.Create("ic.punctuation", true, CVar.SERVER);
+
+    /// <summary>
+    ///     Enables automatically forcing IC name rules. Uppercases the first letter of the first and last words of the name
+    /// </summary>
+    public static readonly CVarDef<bool> ICNameCase =
+        CVarDef.Create("ic.name_case", true, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Whether or not players' characters are randomly generated rather than using their selected characters in the creator.
+    /// </summary>
+    public static readonly CVarDef<bool> ICRandomCharacters =
+        CVarDef.Create("ic.random_characters", false, CVar.SERVER);
+
+    /// <summary>
+    ///     A weighted random prototype used to determine the species selected for random characters.
+    /// </summary>
+    public static readonly CVarDef<string> ICRandomSpeciesWeights =
+        CVarDef.Create("ic.random_species_weights", "SpeciesWeights", CVar.SERVER);
+
+    /// <summary>
+    ///     Control displaying SSD indicators near players
+    /// </summary>
+    public static readonly CVarDef<bool> ICShowSSDIndicator =
+        CVarDef.Create("ic.show_ssd_indicator", false, CVar.CLIENTONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Interactions.cs b/Content.Shared/CCVar/CCVars.Interactions.cs
new file mode 100644
index 0000000000..6838dde363
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Interactions.cs
@@ -0,0 +1,60 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Deadzone for drag-drop interactions.
+    /// </summary>
+    public static readonly CVarDef<float> DragDropDeadZone =
+        CVarDef.Create("control.drag_dead_zone", 12f, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Toggles whether the walking key is a toggle or a held key.
+    /// </summary>
+    public static readonly CVarDef<bool> ToggleWalk =
+        CVarDef.Create("control.toggle_walk", false, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    /// Whether the player mob is walking by default instead of running.
+    /// </summary>
+    public static readonly CVarDef<bool> DefaultWalk =
+        CVarDef.Create("control.default_walk", true, CVar.CLIENT | CVar.REPLICATED | CVar.ARCHIVE);
+
+    // The rationale behind the default limit is simply that I can easily get to 7 interactions per second by just
+    // trying to spam toggle a light switch or lever (though the UseDelay component limits the actual effect of the
+    // interaction).  I don't want to accidentally spam admins with alerts just because somebody is spamming a
+    // key manually, nor do we want to alert them just because the player is having network issues and the server
+    // receives multiple interactions at once. But we also want to try catch people with modified clients that spam
+    // many interactions on the same tick. Hence, a very short period, with a relatively high count.
+
+    /// <summary>
+    ///     Maximum number of interactions that a player can perform within <see cref="InteractionRateLimitCount"/> seconds
+    /// </summary>
+    public static readonly CVarDef<int> InteractionRateLimitCount =
+        CVarDef.Create("interaction.rate_limit_count", 5, CVar.SERVER | CVar.REPLICATED);
+
+    /// <seealso cref="InteractionRateLimitCount"/>
+    public static readonly CVarDef<float> InteractionRateLimitPeriod =
+        CVarDef.Create("interaction.rate_limit_period", 0.5f, CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Minimum delay (in seconds) between notifying admins about interaction rate limit violations. A negative
+    ///     value disables admin announcements.
+    /// </summary>
+    public static readonly CVarDef<int> InteractionRateLimitAnnounceAdminsDelay =
+        CVarDef.Create("interaction.rate_limit_announce_admins_delay", 120, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether or not the storage UI is static and bound to the hotbar, or unbound and allowed to be dragged anywhere.
+    /// </summary>
+    public static readonly CVarDef<bool> StaticStorageUI =
+        CVarDef.Create("control.static_storage_ui", true, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Whether or not the storage window uses a transparent or opaque sprite.
+    /// </summary>
+    public static readonly CVarDef<bool> OpaqueStorageWindow =
+        CVarDef.Create("control.opaque_storage_background", false, CVar.CLIENTONLY | CVar.ARCHIVE);
+}
diff --git a/Content.Shared/CCVar/CCVars.Interface.cs b/Content.Shared/CCVar/CCVars.Interface.cs
new file mode 100644
index 0000000000..542b3e796c
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Interface.cs
@@ -0,0 +1,27 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<string> UIClickSound =
+        CVarDef.Create("interface.click_sound", "/Audio/UserInterface/click.ogg", CVar.REPLICATED);
+
+    public static readonly CVarDef<string> UIHoverSound =
+        CVarDef.Create("interface.hover_sound", "/Audio/UserInterface/hover.ogg", CVar.REPLICATED);
+
+    public static readonly CVarDef<string> UILayout =
+        CVarDef.Create("ui.layout", "Separated", CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<string> OverlayScreenChatSize =
+        CVarDef.Create("ui.overlay_chat_size", "", CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<string> DefaultScreenChatSize =
+        CVarDef.Create("ui.default_chat_size", "", CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<string> SeparatedScreenChatSize =
+        CVarDef.Create("ui.separated_chat_size", "0.6,0", CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<bool> OutlineEnabled =
+        CVarDef.Create("outline.enabled", true, CVar.CLIENTONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Jetpack.cs b/Content.Shared/CCVar/CCVars.Jetpack.cs
new file mode 100644
index 0000000000..638ba414c8
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Jetpack.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     When true, Jetpacks can be enabled anywhere, even in gravity.
+    /// </summary>
+    public static readonly CVarDef<bool> JetpackEnableAnywhere =
+        CVarDef.Create("jetpack.enable_anywhere", false, CVar.REPLICATED);
+
+    /// <summary>
+    ///     When true, jetpacks can be enabled on grids that have zero gravity.
+    /// </summary>
+    public static readonly CVarDef<bool> JetpackEnableInNoGravity =
+        CVarDef.Create("jetpack.enable_in_no_gravity", true, CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.LayingDown.cs b/Content.Shared/CCVar/CCVars.LayingDown.cs
new file mode 100644
index 0000000000..aebd59b9f1
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.LayingDown.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> AutoGetUp =
+        CVarDef.Create("rest.auto_get_up", true, CVar.CLIENT | CVar.ARCHIVE | CVar.REPLICATED);
+
+    public static readonly CVarDef<bool> HoldLookUp =
+        CVarDef.Create("rest.hold_look_up", false, CVar.CLIENT | CVar.ARCHIVE);
+
+    /// <summary>
+    ///     When true, players can choose to crawl under tables while laying down, using the designated keybind.
+    /// </summary>
+    public static readonly CVarDef<bool> CrawlUnderTables =
+        CVarDef.Create("rest.crawlundertables", true, CVar.SERVER | CVar.ARCHIVE);
+}
diff --git a/Content.Shared/CCVar/CCVars.Mapping.cs b/Content.Shared/CCVar/CCVars.Mapping.cs
new file mode 100644
index 0000000000..06cd2870ba
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Mapping.cs
@@ -0,0 +1,24 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Will mapping mode enable autosaves when it's activated?
+    /// </summary>
+    public static readonly CVarDef<bool>
+        AutosaveEnabled = CVarDef.Create("mapping.autosave", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Autosave interval in seconds.
+    /// </summary>
+    public static readonly CVarDef<float>
+        AutosaveInterval = CVarDef.Create("mapping.autosave_interval", 600f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Directory in server user data to save to. Saves will be inside folders in this directory.
+    /// </summary>
+    public static readonly CVarDef<string>
+        AutosaveDirectory = CVarDef.Create("mapping.autosave_dir", "Autosaves", CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.MaterialReclaimer.cs b/Content.Shared/CCVar/CCVars.MaterialReclaimer.cs
new file mode 100644
index 0000000000..79e28d2323
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.MaterialReclaimer.cs
@@ -0,0 +1,12 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Whether or not a Material Reclaimer is allowed to eat people when emagged.
+    /// </summary>
+    public static readonly CVarDef<bool> ReclaimerAllowGibbing =
+        CVarDef.Create("reclaimer.allow_gibbing", true, CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.MaterialSilo.cs b/Content.Shared/CCVar/CCVars.MaterialSilo.cs
new file mode 100644
index 0000000000..ab7710f83d
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.MaterialSilo.cs
@@ -0,0 +1,12 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Is ore material enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> SiloEnabled =
+        CVarDef.Create("silo.silo_enabled", true, CVar.SERVER | CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Midi.cs b/Content.Shared/CCVar/CCVars.Midi.cs
new file mode 100644
index 0000000000..4ca4bfd6f8
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Midi.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<int> MaxMidiEventsPerSecond =
+        CVarDef.Create("midi.max_events_per_second", 1000, CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<int> MaxMidiEventsPerBatch =
+        CVarDef.Create("midi.max_events_per_batch", 60, CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<int> MaxMidiBatchesDropped =
+        CVarDef.Create("midi.max_batches_dropped", 1, CVar.SERVERONLY);
+
+    public static readonly CVarDef<int> MaxMidiLaggedBatches =
+        CVarDef.Create("midi.max_lagged_batches", 8, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Misc.cs b/Content.Shared/CCVar/CCVars.Misc.cs
new file mode 100644
index 0000000000..1cc71a8177
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Misc.cs
@@ -0,0 +1,106 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> HolidaysEnabled = CVarDef.Create("holidays.enabled", true, CVar.SERVERONLY);
+    public static readonly CVarDef<bool> BrandingSteam = CVarDef.Create("branding.steam", false, CVar.CLIENTONLY);
+    public static readonly CVarDef<int> EntityMenuGroupingType = CVarDef.Create("entity_menu", 0, CVar.CLIENTONLY);
+
+    /// <summary>
+    ///     Should we pre-load all of the procgen atlasses.
+    /// </summary>
+    public static readonly CVarDef<bool> ProcgenPreload =
+        CVarDef.Create("procgen.preload", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Enabled: Cloning has 70% cost and reclaimer will refuse to reclaim corpses with souls. (For LRP).
+    ///     Disabled: Cloning has full biomass cost and reclaimer can reclaim corpses with souls. (Playtested and balanced for MRP+).
+    /// </summary>
+    public static readonly CVarDef<bool> BiomassEasyMode =
+        CVarDef.Create("biomass.easy_mode", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     A scale factor applied to a grid's bounds when trying to find a spot to randomly generate an anomaly.
+    /// </summary>
+    public static readonly CVarDef<float> AnomalyGenerationGridBoundsScale =
+        CVarDef.Create("anomaly.generation_grid_bounds_scale", 0.6f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     How long a client can go without any input before being considered AFK.
+    /// </summary>
+    public static readonly CVarDef<float> AfkTime =
+        CVarDef.Create("afk.time", 60f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Flavor limit. This is to ensure that having a large mass of flavors in
+    ///     some food object won't spam a user with flavors.
+    /// </summary>
+    public static readonly CVarDef<int>
+        FlavorLimit = CVarDef.Create("flavor.limit", 10, CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> DestinationFile =
+        CVarDef.Create("autogen.destination_file", "", CVar.SERVER | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether uploaded files will be stored in the server's database.
+    ///     This is useful to keep "logs" on what files admins have uploaded in the past.
+    /// </summary>
+    public static readonly CVarDef<bool> ResourceUploadingStoreEnabled =
+        CVarDef.Create("netres.store_enabled", true, CVar.SERVER | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Numbers of days before stored uploaded files are deleted. Set to zero or negative to disable auto-delete.
+    ///     This is useful to free some space automatically. Auto-deletion runs only on server boot.
+    /// </summary>
+    public static readonly CVarDef<int> ResourceUploadingStoreDeletionDays =
+        CVarDef.Create("netres.store_deletion_days", 30, CVar.SERVER | CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If a server update restart is pending, the delay after the last player leaves before we actually restart. In seconds.
+    /// </summary>
+    public static readonly CVarDef<float> UpdateRestartDelay =
+        CVarDef.Create("update.restart_delay", 20f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If fire alarms should have all access, or if activating/resetting these
+    ///     should be restricted to what is dictated on a player's access card.
+    ///     Defaults to true.
+    /// </summary>
+    public static readonly CVarDef<bool> FireAlarmAllAccess =
+        CVarDef.Create("firealarm.allaccess", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Time between play time autosaves, in seconds.
+    /// </summary>
+    public static readonly CVarDef<float>
+        PlayTimeSaveInterval = CVarDef.Create("playtime.save_interval", 900f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The maximum amount of time the entity GC can process, in ms.
+    /// </summary>
+    public static readonly CVarDef<int> GCMaximumTimeMs =
+        CVarDef.Create("entgc.maximum_time_ms", 5, CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> GatewayGeneratorEnabled =
+        CVarDef.Create("gateway.generator_enabled", true);
+
+    public static readonly CVarDef<string> TippyEntity =
+        CVarDef.Create("tippy.entity", "Tippy", CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     The number of seconds that must pass for a single entity to be able to point at something again.
+    /// </summary>
+    public static readonly CVarDef<float> PointingCooldownSeconds =
+        CVarDef.Create("pointing.cooldown_seconds", 0.5f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The amount of time between NPC Silicons draining their battery in seconds.
+    /// </summary>
+    public static readonly CVarDef<float> SiliconNpcUpdateTime =
+        CVarDef.Create("silicon.npcupdatetime", 1.5f, CVar.SERVERONLY);
+
+    public static readonly CVarDef<bool> AllowScreamAction =
+        CVarDef.Create("vocal.allow_scream_action", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Mood.cs b/Content.Shared/CCVar/CCVars.Mood.cs
new file mode 100644
index 0000000000..3775a6b0e5
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Mood.cs
@@ -0,0 +1,26 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /*
+        * Mood System
+        */
+
+    public static readonly CVarDef<bool> MoodEnabled =
+#if RELEASE
+        CVarDef.Create("mood.enabled", true, CVar.SERVER);
+#else
+        CVarDef.Create("mood.enabled", false, CVar.SERVER);
+#endif
+
+    public static readonly CVarDef<bool> MoodIncreasesSpeed =
+        CVarDef.Create("mood.increases_speed", true, CVar.SERVER);
+
+    public static readonly CVarDef<bool> MoodDecreasesSpeed =
+        CVarDef.Create("mood.decreases_speed", true, CVar.SERVER);
+
+    public static readonly CVarDef<bool> MoodModifiesThresholds =
+        CVarDef.Create("mood.modify_thresholds", false, CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.NPC.cs b/Content.Shared/CCVar/CCVars.NPC.cs
new file mode 100644
index 0000000000..f0d5520195
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.NPC.cs
@@ -0,0 +1,16 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<int> NPCMaxUpdates =
+        CVarDef.Create("npc.max_updates", 128);
+
+    public static readonly CVarDef<bool> NPCEnabled = CVarDef.Create("npc.enabled", true);
+
+    /// <summary>
+    ///     Should NPCs pathfind when steering. For debug purposes.
+    /// </summary>
+    public static readonly CVarDef<bool> NPCPathfinding = CVarDef.Create("npc.pathfinding", true);
+}
diff --git a/Content.Shared/CCVar/CCVars.Net.cs b/Content.Shared/CCVar/CCVars.Net.cs
new file mode 100644
index 0000000000..b7465def2e
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Net.cs
@@ -0,0 +1,15 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<float> NetAtmosDebugOverlayTickRate =
+        CVarDef.Create("net.atmosdbgoverlaytickrate", 3.0f);
+
+    public static readonly CVarDef<float> NetGasOverlayTickRate =
+        CVarDef.Create("net.gasoverlaytickrate", 3.0f);
+
+    public static readonly CVarDef<int> GasOverlayThresholds =
+        CVarDef.Create("net.gasoverlaythresholds", 20);
+}
diff --git a/Content.Shared/CCVar/CCVars.Parallax.cs b/Content.Shared/CCVar/CCVars.Parallax.cs
new file mode 100644
index 0000000000..9b19c8f494
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Parallax.cs
@@ -0,0 +1,15 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> ParallaxEnabled =
+        CVarDef.Create("parallax.enabled", true, CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> ParallaxDebug =
+        CVarDef.Create("parallax.debug", false, CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> ParallaxLowQuality =
+        CVarDef.Create("parallax.low_quality", false, CVar.ARCHIVE | CVar.CLIENTONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Physics.cs b/Content.Shared/CCVar/CCVars.Physics.cs
new file mode 100644
index 0000000000..379676b5df
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Physics.cs
@@ -0,0 +1,27 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     When a mob is walking should its X / Y movement be relative to its parent (true) or the map (false).
+    /// </summary>
+    public static readonly CVarDef<bool> RelativeMovement =
+        CVarDef.Create("physics.relative_movement", true, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<float> TileFrictionModifier =
+        CVarDef.Create("physics.tile_friction", 40.0f, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<float> StopSpeed =
+        CVarDef.Create("physics.stop_speed", 0.1f, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Whether mobs can push objects like lockers.
+    /// </summary>
+    /// <remarks>
+    ///     Technically client doesn't need to know about it but this may prevent a bug in the distant future so it stays.
+    /// </remarks>
+    public static readonly CVarDef<bool> MobPushing =
+        CVarDef.Create("physics.mob_pushing", false, CVar.REPLICATED | CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.Psionics.cs b/Content.Shared/CCVar/CCVars.Psionics.cs
new file mode 100644
index 0000000000..71c8a19495
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Psionics.cs
@@ -0,0 +1,40 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///    Whether glimmer is enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> GlimmerEnabled =
+        CVarDef.Create("glimmer.enabled", true, CVar.REPLICATED);
+
+    /// <summary>
+    ///     The rate at which glimmer linearly decays. Since glimmer increases (usually) follow a logistic curve, this means glimmer
+    ///     becomes increasingly harder to raise after ~502 points.
+    /// </summary>
+    public static readonly CVarDef<float> GlimmerLinearDecayPerMinute =
+        CVarDef.Create("glimmer.linear_decay_per_minute", 6f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether random rolls for psionics are allowed.
+    ///     Guaranteed psionics will still go through.
+    /// </summary>
+    public static readonly CVarDef<bool> PsionicRollsEnabled =
+        CVarDef.Create("psionics.rolls_enabled", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     When mindbroken, permanently eject the player from their own body, and turn their character into an NPC.
+    ///     Congratulations, now they *actually* aren't a person anymore.
+    ///     For people who complained that it wasn't obvious enough from the text that Mindbreaking is a form of Murder.
+    /// </summary>
+    public static readonly CVarDef<bool> ScarierMindbreaking =
+        CVarDef.Create("psionics.scarier_mindbreaking", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Allow Ethereal Ent to PassThrough Walls/Objects while in Ethereal.
+    /// </summary>
+    public static readonly CVarDef<bool> EtherealPassThrough =
+        CVarDef.Create("ic.EtherealPassThrough", false, CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.Queue.cs b/Content.Shared/CCVar/CCVars.Queue.cs
new file mode 100644
index 0000000000..170cefce5e
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Queue.cs
@@ -0,0 +1,13 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Controls if the connections queue is enabled
+    ///     If enabled plyaers will be added to a queue instead of being kicked after SoftMaxPlayers is reached
+    /// </summary>
+    public static readonly CVarDef<bool> QueueEnabled =
+        CVarDef.Create("queue.enabled", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Radiation.cs b/Content.Shared/CCVar/CCVars.Radiation.cs
new file mode 100644
index 0000000000..dfcce15b2f
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Radiation.cs
@@ -0,0 +1,32 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     What is the smallest radiation dose in rads that can be received by object.
+    ///     Extremely small values may impact performance.
+    /// </summary>
+    public static readonly CVarDef<float> RadiationMinIntensity =
+        CVarDef.Create("radiation.min_intensity", 0.1f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Rate of radiation system update in seconds.
+    /// </summary>
+    public static readonly CVarDef<float> RadiationGridcastUpdateRate =
+        CVarDef.Create("radiation.gridcast.update_rate", 1.0f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     If both radiation source and receiver are placed on same grid, ignore grids between them.
+    ///     May get inaccurate result in some cases, but greatly boost performance in general.
+    /// </summary>
+    public static readonly CVarDef<bool> RadiationGridcastSimplifiedSameGrid =
+        CVarDef.Create("radiation.gridcast.simplified_same_grid", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Max distance that radiation ray can travel in meters.
+    /// </summary>
+    public static readonly CVarDef<float> RadiationGridcastMaxDistance =
+        CVarDef.Create("radiation.gridcast.max_distance", 50f, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Replays.cs b/Content.Shared/CCVar/CCVars.Replays.cs
new file mode 100644
index 0000000000..64f47e8ad8
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Replays.cs
@@ -0,0 +1,43 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Whether or not to record admin chat. If replays are being publicly distributes, this should probably be
+    ///     false.
+    /// </summary>
+    public static readonly CVarDef<bool> ReplayRecordAdminChat =
+        CVarDef.Create("replay.record_admin_chat", false, CVar.ARCHIVE);
+
+    /// <summary>
+    ///     Automatically record full rounds as replays.
+    /// </summary>
+    public static readonly CVarDef<bool> ReplayAutoRecord =
+        CVarDef.Create("replay.auto_record", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The file name to record automatic replays to. The path is relative to <see cref="CVars.ReplayDirectory"/>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    ///     If the path includes slashes, directories will be automatically created if necessary.
+    /// </para>
+    /// <para>
+    ///     A number of substitutions can be used to automatically fill in the file name: <c>{year}</c>, <c>{month}</c>, <c>{day}</c>, <c>{hour}</c>, <c>{minute}</c>, <c>{round}</c>.
+    /// </para>
+    /// </remarks>
+    public static readonly CVarDef<string> ReplayAutoRecordName =
+        CVarDef.Create("replay.auto_record_name",
+            "{year}_{month}_{day}-{hour}_{minute}-round_{round}.zip",
+            CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Path that, if provided, automatic replays are initially recorded in.
+    ///     When the recording is done, the file is moved into its final destination.
+    ///     Unless this path is rooted, it will be relative to <see cref="CVars.ReplayDirectory"/>.
+    /// </summary>
+    public static readonly CVarDef<string> ReplayAutoRecordTempDir =
+        CVarDef.Create("replay.auto_record_temp_dir", "", CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Salvage.cs b/Content.Shared/CCVar/CCVars.Salvage.cs
new file mode 100644
index 0000000000..ddc332786b
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Salvage.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Duration for missions
+    /// </summary>
+    public static readonly CVarDef<float>
+        SalvageExpeditionDuration = CVarDef.Create("salvage.expedition_duration", 660f, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Cooldown for missions.
+    /// </summary>
+    public static readonly CVarDef<float>
+        SalvageExpeditionCooldown = CVarDef.Create("salvage.expedition_cooldown", 780f, CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Server.cs b/Content.Shared/CCVar/CCVars.Server.cs
new file mode 100644
index 0000000000..2c861584af
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Server.cs
@@ -0,0 +1,43 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /*
+     * Server
+     */
+
+    /// <summary>
+    ///     Change this to have the changelog and rules "last seen" date stored separately.
+    /// </summary>
+    public static readonly CVarDef<string> ServerId =
+        CVarDef.Create("server.id", "unknown_server_id", CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Guide Entry Prototype ID to be displayed as the server rules.
+    /// </summary>
+    public static readonly CVarDef<string> RulesFile =
+        CVarDef.Create("server.rules_file", "DefaultRuleset", CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     Guide entry that is displayed by default when a guide is opened.
+    /// </summary>
+    public static readonly CVarDef<string> DefaultGuide =
+        CVarDef.Create("server.default_guide", "NewPlayer", CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     If greater than 0, automatically restart the server after this many minutes of uptime.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    ///     This is intended to work around various bugs and performance issues caused by long continuous server uptime.
+    /// </para>
+    /// <para>
+    ///     This uses the same non-disruptive logic as update restarts,
+    ///     i.e. the game will only restart at round end or when there is nobody connected.
+    /// </para>
+    /// </remarks>
+    public static readonly CVarDef<int> ServerUptimeRestartMinutes =
+        CVarDef.Create("server.uptime_restart_minutes", 0, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Shuttle.cs b/Content.Shared/CCVar/CCVars.Shuttle.cs
new file mode 100644
index 0000000000..485343a834
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Shuttle.cs
@@ -0,0 +1,189 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    // Look this is technically eye behavior but its main impact is shuttles so I just dumped it here.
+    /// <summary>
+    /// If true then the camera will match the grid / map and is unchangeable.
+    /// - When traversing grids it will snap to 0 degrees rotation.
+    /// False means the player has control over the camera rotation.
+    /// - When traversing grids it will snap to the nearest cardinal which will generally be imperceptible.
+    /// </summary>
+    public static readonly CVarDef<bool> CameraRotationLocked =
+        CVarDef.Create("shuttle.camera_rotation_locked", false, CVar.REPLICATED);
+
+    /// <summary>
+    /// Whether the arrivals terminal should be on a planet map.
+    /// </summary>
+    public static readonly CVarDef<bool> ArrivalsPlanet =
+        CVarDef.Create("shuttle.arrivals_planet", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether the arrivals shuttle is enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> ArrivalsShuttles =
+        CVarDef.Create("shuttle.arrivals", true, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The map to use for the arrivals station.
+    /// </summary>
+    public static readonly CVarDef<string> ArrivalsMap =
+        CVarDef.Create("shuttle.arrivals_map", "/Maps/Misc/terminal.yml", CVar.SERVERONLY);
+
+    /// <summary>
+    /// Cooldown between arrivals departures. This should be longer than the FTL time or it will double cycle.
+    /// </summary>
+    public static readonly CVarDef<float> ArrivalsCooldown =
+        CVarDef.Create("shuttle.arrivals_cooldown", 50f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Time it takes the shuttle to spin up it's hyper drive and jump
+    /// </summary>
+    public static readonly CVarDef<float> ArrivalsStartupTime=
+        CVarDef.Create("shuttle.arrivals_startup_time", 5.5f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Time spent in hyperspace
+    /// </summary>
+    public static readonly CVarDef<float> ArrivalsHyperspaceTime =
+        CVarDef.Create("shuttle.arrivals_hyperspace_time", 20f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Are players allowed to return on the arrivals shuttle.
+    /// </summary>
+    public static readonly CVarDef<bool> ArrivalsReturns =
+        CVarDef.Create("shuttle.arrivals_returns", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Should all players who spawn at arrivals have godmode until they leave the map?
+    /// </summary>
+    public static readonly CVarDef<bool> GodmodeArrivals =
+        CVarDef.Create("shuttle.godmode_arrivals", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// If a grid is split then hide any smaller ones under this mass (kg) from the map.
+    /// This is useful to avoid split grids spamming out labels.
+    /// </summary>
+    public static readonly CVarDef<int> HideSplitGridsUnder =
+        CVarDef.Create("shuttle.hide_split_grids_under", 30, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether to automatically spawn escape shuttles.
+    /// </summary>
+    public static readonly CVarDef<bool> GridFill =
+        CVarDef.Create("shuttle.grid_fill", true, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether to automatically preloading grids by GridPreloaderSystem
+    /// </summary>
+    public static readonly CVarDef<bool> PreloadGrids =
+        CVarDef.Create("shuttle.preload_grids", true, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How long the warmup time before FTL start should be.
+    /// </summary>
+    public static readonly CVarDef<float> FTLStartupTime =
+        CVarDef.Create("shuttle.startup_time", 5.5f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How long a shuttle spends in FTL.
+    /// </summary>
+    public static readonly CVarDef<float> FTLTravelTime =
+        CVarDef.Create("shuttle.travel_time", 20f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How long the final stage of FTL before arrival should be.
+    /// </summary>
+    public static readonly CVarDef<float> FTLArrivalTime =
+        CVarDef.Create("shuttle.arrival_time", 5f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How much time needs to pass before a shuttle can FTL again.
+    /// </summary>
+    public static readonly CVarDef<float> FTLCooldown =
+        CVarDef.Create("shuttle.cooldown", 10f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The maximum <see cref="PhysicsComponent.Mass"/> a grid can have before it becomes unable to FTL.
+    /// Any value equal to or less than zero will disable this check.
+    /// </summary>
+    public static readonly CVarDef<float> FTLMassLimit =
+        CVarDef.Create("shuttle.mass_limit", 300f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How long to knock down entities for if they aren't buckled when FTL starts and stops.
+    /// </summary>
+    public static readonly CVarDef<float> HyperspaceKnockdownTime =
+        CVarDef.Create("shuttle.hyperspace_knockdown_time", 5f, CVar.SERVERONLY);
+
+    ///<summary>
+    /// the Entropic decay of energy combined with the minimal but existent particles that would slow the vessel down
+    ///</summary>
+    public static readonly CVarDef<float> SpaceFrictionStrength =
+        CVarDef.Create("shuttle.space_friction_strength", 0.0015f, CVar.REPLICATED);
+
+    ///<summary>
+    /// the strength of drag when the inertia dampeners are set to anchor to slow the vessel down and hold it in place
+    ///</summary>
+    public static readonly CVarDef<float> AnchorDampeningStrength =
+        CVarDef.Create("shuttle.ancho_dampening_strength", 0.5f, CVar.REPLICATED);
+
+    /// <summary>
+    /// Is the emergency shuttle allowed to be early launched.
+    /// </summary>
+    public static readonly CVarDef<bool> EmergencyEarlyLaunchAllowed =
+        CVarDef.Create("shuttle.emergency_early_launch_allowed", false, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How long the emergency shuttle remains docked with the station, in seconds.
+    /// </summary>
+    public static readonly CVarDef<float> EmergencyShuttleDockTime =
+        CVarDef.Create("shuttle.emergency_dock_time", 240f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// How long after the console is authorized for the shuttle to early launch.
+    /// </summary>
+    public static readonly CVarDef<float> EmergencyShuttleAuthorizeTime =
+        CVarDef.Create("shuttle.emergency_authorize_time", 10f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The minimum time for the emergency shuttle to arrive at centcomm.
+    /// Actual minimum travel time cannot be less than <see cref="ShuttleSystem.DefaultArrivalTime"/>
+    /// </summary>
+    public static readonly CVarDef<float> EmergencyShuttleMinTransitTime =
+        CVarDef.Create("shuttle.emergency_transit_time_min", 90f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// The maximum time for the emergency shuttle to arrive at centcomm.
+    /// </summary>
+    public static readonly CVarDef<float> EmergencyShuttleMaxTransitTime =
+        CVarDef.Create("shuttle.emergency_transit_time_max", 180f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether the emergency shuttle is enabled or should the round just end.
+    /// </summary>
+    public static readonly CVarDef<bool> EmergencyShuttleEnabled =
+        CVarDef.Create("shuttle.emergency", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The percentage of time passed from the initial call to when the shuttle can no longer be recalled.
+    ///     ex. a call time of 10min and turning point of 0.5 means the shuttle cannot be recalled after 5 minutes.
+    /// </summary>
+    public static readonly CVarDef<float> EmergencyRecallTurningPoint =
+        CVarDef.Create("shuttle.recall_turning_point", 0.5f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Time in minutes after round start to auto-call the shuttle. Set to zero to disable.
+    /// </summary>
+    public static readonly CVarDef<int> EmergencyShuttleAutoCallTime =
+        CVarDef.Create("shuttle.auto_call_time", 120, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Time in minutes after the round was extended (by recalling the shuttle) to call
+    ///     the shuttle again.
+    /// </summary>
+    public static readonly CVarDef<int> EmergencyShuttleAutoCallExtensionTime =
+        CVarDef.Create("shuttle.auto_call_extension_time", 30, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.SoftCrit.cs b/Content.Shared/CCVar/CCVars.SoftCrit.cs
new file mode 100644
index 0000000000..2e3d141249
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.SoftCrit.cs
@@ -0,0 +1,25 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Used for basic Soft-Crit implementation. Entities are allowed to crawl when in crit, as this CVar intercepts the mover controller check for incapacitation,
+    ///     and prevents it from stopping movement if this CVar is set to true and the user is Crit but Not Dead. This is only for movement,
+    ///     you still can't stand up while crit, and you're still more or less helpless.
+    /// </summary>
+    public static readonly CVarDef<bool> AllowMovementWhileCrit =
+        CVarDef.Create("mobstate.allow_movement_while_crit", true, CVar.REPLICATED);
+
+    public static readonly CVarDef<bool> AllowTalkingWhileCrit =
+        CVarDef.Create("mobstate.allow_talking_while_crit", true, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Currently does nothing because I would have to figure out WHERE I would even put this check, and the mover controller is fairly complicated.
+    ///     The goal is to make it so that attempting to move while in 'soft crit' can potentially cause further injury, causing you to die faster. Ideally there would be special
+    ///     actions that can be performed in soft crit, such as applying pressure to your own injuries to slow down the bleedout, or other varieties of "Will To Live".
+    /// </summary>
+    public static readonly CVarDef<bool> DamageWhileCritMove =
+        CVarDef.Create("mobstate.damage_while_crit_move", false, CVar.REPLICATED);
+}
diff --git a/Content.Shared/CCVar/CCVars.Sounds.cs b/Content.Shared/CCVar/CCVars.Sounds.cs
new file mode 100644
index 0000000000..6e781d6e07
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Sounds.cs
@@ -0,0 +1,30 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> LobbyMusicEnabled =
+        CVarDef.Create("ambience.lobby_music_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> EventMusicEnabled =
+        CVarDef.Create("ambience.event_music_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    /// <summary>
+    ///     Round end sound (APC Destroyed)
+    /// </summary>
+    public static readonly CVarDef<bool> RestartSoundsEnabled =
+        CVarDef.Create("ambience.restart_sounds_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<bool> AdminSoundsEnabled =
+        CVarDef.Create("audio.admin_sounds_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
+
+    public static readonly CVarDef<string> AdminChatSoundPath =
+        CVarDef.Create("audio.admin_chat_sound_path", "/Audio/Items/pop.ogg", CVar.ARCHIVE | CVar.CLIENT | CVar.REPLICATED);
+
+    public static readonly CVarDef<float> AdminChatSoundVolume =
+        CVarDef.Create("audio.admin_chat_sound_volume", -5f, CVar.ARCHIVE | CVar.CLIENT | CVar.REPLICATED);
+
+    public static readonly CVarDef<string> AHelpSound =
+        CVarDef.Create("audio.ahelp_sound", "/Audio/Effects/adminhelp.ogg", CVar.ARCHIVE | CVar.CLIENTONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.StationGoals.cs b/Content.Shared/CCVar/CCVars.StationGoals.cs
new file mode 100644
index 0000000000..91090cd401
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.StationGoals.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Enables station goals
+    /// </summary>
+    public static readonly CVarDef<bool> StationGoalsEnabled =
+        CVarDef.Create("game.station_goals", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Chance for a station goal to be sent
+    /// </summary>
+    public static readonly CVarDef<float> StationGoalsChance =
+        CVarDef.Create("game.station_goals_chance", 0.1f, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Status.cs b/Content.Shared/CCVar/CCVars.Status.cs
new file mode 100644
index 0000000000..007f678106
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Status.cs
@@ -0,0 +1,13 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<string> StatusMoMMIUrl =
+        CVarDef.Create("status.mommiurl", "", CVar.SERVERONLY);
+
+    public static readonly CVarDef<string> StatusMoMMIPassword =
+        CVarDef.Create("status.mommipassword", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
+
+}
diff --git a/Content.Shared/CCVar/CCVars.Supermatter.cs b/Content.Shared/CCVar/CCVars.Supermatter.cs
new file mode 100644
index 0000000000..8aea6524ae
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Supermatter.cs
@@ -0,0 +1,52 @@
+using Content.Shared.Supermatter.Components;
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     With completely default supermatter values, Singuloose delamination will occur if engineers inject at least 900 moles of coolant per tile
+    ///     in the crystal chamber. For reference, a gas canister contains 1800 moles of air. This Cvar directly multiplies the amount of moles required to singuloose.
+    /// </summary>
+    public static readonly CVarDef<float> SupermatterSingulooseMolesModifier =
+        CVarDef.Create("supermatter.singuloose_moles_modifier", 1f, CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles whether or not Singuloose delaminations can occur. If both Singuloose and Tesloose are disabled, it will always delam into a Nuke.
+    /// </summary>
+    public static readonly CVarDef<bool> SupermatterDoSingulooseDelam =
+        CVarDef.Create("supermatter.do_singuloose", true, CVar.SERVER);
+
+    /// <summary>
+    ///     By default, Supermatter will "Tesloose" if the conditions for Singuloose are not met, and the core's power is at least 4000.
+    ///     The actual reasons for being at least this amount vary by how the core was screwed up, but traditionally it's caused by "The core is on fire".
+    ///     This Cvar multiplies said power threshold for the purpose of determining if the delam is a Tesloose.
+    /// </summary>
+    public static readonly CVarDef<float> SupermatterTesloosePowerModifier =
+        CVarDef.Create("supermatter.tesloose_power_modifier", 1f, CVar.SERVER);
+
+    /// <summary>
+    ///     Toggles whether or not Tesloose delaminations can occur. If both Singuloose and Tesloose are disabled, it will always delam into a Nuke.
+    /// </summary>
+    public static readonly CVarDef<bool> SupermatterDoTeslooseDelam =
+        CVarDef.Create("supermatter.do_tesloose", true, CVar.SERVER);
+
+    /// <summary>
+    ///     When true, bypass the normal checks to determine delam type, and instead use the type chosen by supermatter.forced_delam_type
+    /// </summary>
+    public static readonly CVarDef<bool> SupermatterDoForceDelam =
+        CVarDef.Create("supermatter.do_force_delam", false, CVar.SERVER);
+
+    /// <summary>
+    ///     If supermatter.do_force_delam is true, this determines the delamination type, bypassing the normal checks.
+    /// </summary>
+    public static readonly CVarDef<DelamType> SupermatterForcedDelamType =
+        CVarDef.Create("supermatter.forced_delam_type", DelamType.Singulo, CVar.SERVER);
+
+    /// <summary>
+    ///     Directly multiplies the amount of rads put out by the supermatter. Be VERY conservative with this.
+    /// </summary>
+    public static readonly CVarDef<float> SupermatterRadsModifier =
+        CVarDef.Create("supermatter.rads_modifier", 1f, CVar.SERVER);
+}
diff --git a/Content.Shared/CCVar/CCVars.Surgery.cs b/Content.Shared/CCVar/CCVars.Surgery.cs
new file mode 100644
index 0000000000..f3fcf83610
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Surgery.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> CanOperateOnSelf =
+        CVarDef.Create("surgery.can_operate_on_self", false, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Tips.cs b/Content.Shared/CCVar/CCVars.Tips.cs
new file mode 100644
index 0000000000..61e6342061
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Tips.cs
@@ -0,0 +1,40 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Whether tips being shown is enabled at all.
+    /// </summary>
+    public static readonly CVarDef<bool> TipsEnabled =
+        CVarDef.Create("tips.enabled", true);
+
+    /// <summary>
+    ///     The dataset prototype to use when selecting a random tip.
+    /// </summary>
+    public static readonly CVarDef<string> TipsDataset =
+        CVarDef.Create("tips.dataset", "Tips");
+
+    /// <summary>
+    ///     The number of seconds between each tip being displayed when the round is not actively going
+    ///     (i.e. postround or lobby)
+    /// </summary>
+    public static readonly CVarDef<float> TipFrequencyOutOfRound =
+        CVarDef.Create("tips.out_of_game_frequency", 60f * 1.5f);
+
+    /// <summary>
+    ///     The number of seconds between each tip being displayed when the round is actively going
+    /// </summary>
+    public static readonly CVarDef<float> TipFrequencyInRound =
+        CVarDef.Create("tips.in_game_frequency", 60f * 60);
+
+    public static readonly CVarDef<string> LoginTipsDataset =
+        CVarDef.Create("tips.login_dataset", "Tips");
+
+    /// <summary>
+    ///     The chance for Tippy to replace a normal tip message.
+    /// </summary>
+    public static readonly CVarDef<float> TipsTippyChance =
+        CVarDef.Create("tips.tippy_chance", 0.01f);
+}
diff --git a/Content.Shared/CCVar/CCVars.Viewport.cs b/Content.Shared/CCVar/CCVars.Viewport.cs
new file mode 100644
index 0000000000..d94394d2a7
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Viewport.cs
@@ -0,0 +1,33 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    public static readonly CVarDef<bool> ViewportStretch =
+        CVarDef.Create("viewport.stretch", true, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<int> ViewportFixedScaleFactor =
+        CVarDef.Create("viewport.fixed_scale_factor", 2, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<int> ViewportSnapToleranceMargin =
+        CVarDef.Create("viewport.snap_tolerance_margin", 64, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<int> ViewportSnapToleranceClip =
+        CVarDef.Create("viewport.snap_tolerance_clip", 32, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<bool> ViewportScaleRender =
+        CVarDef.Create("viewport.scale_render", true, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<int> ViewportMinimumWidth =
+        CVarDef.Create("viewport.minimum_width", 15, CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<int> ViewportMaximumWidth =
+        CVarDef.Create("viewport.maximum_width", 21, CVar.REPLICATED | CVar.SERVER);
+
+    public static readonly CVarDef<int> ViewportWidth =
+        CVarDef.Create("viewport.width", 21, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+    public static readonly CVarDef<bool> ViewportVerticalFit =
+        CVarDef.Create("viewport.vertical_fit", true, CVar.CLIENTONLY | CVar.ARCHIVE);
+}
diff --git a/Content.Shared/CCVar/CCVars.Vote.cs b/Content.Shared/CCVar/CCVars.Vote.cs
new file mode 100644
index 0000000000..dc99c4e5a0
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Vote.cs
@@ -0,0 +1,180 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Allows enabling/disabling player-started votes for ultimate authority
+    /// </summary>
+    public static readonly CVarDef<bool> VoteEnabled =
+        CVarDef.Create("vote.enabled", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     See vote.enabled, but specific to restart votes
+    /// </summary>
+    public static readonly CVarDef<bool> VoteRestartEnabled =
+        CVarDef.Create("vote.restart_enabled", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Config for when the restart vote should be allowed to be called regardless with less than this amount of players.
+    /// </summary>
+    public static readonly CVarDef<int> VoteRestartMaxPlayers =
+        CVarDef.Create("vote.restart_max_players", 20, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Config for when the restart vote should be allowed to be called based on percentage of ghosts.
+    /// </summary>
+    public static readonly CVarDef<int> VoteRestartGhostPercentage =
+        CVarDef.Create("vote.restart_ghost_percentage", 75, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     See vote.enabled, but specific to preset votes
+    /// </summary>
+    public static readonly CVarDef<bool> VotePresetEnabled =
+        CVarDef.Create("vote.preset_enabled", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     See vote.enabled, but specific to map votes
+    /// </summary>
+    public static readonly CVarDef<bool> VoteMapEnabled =
+        CVarDef.Create("vote.map_enabled", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The required ratio of the server that must agree for a restart round vote to go through.
+    /// </summary>
+    public static readonly CVarDef<float> VoteRestartRequiredRatio =
+        CVarDef.Create("vote.restart_required_ratio", 0.85f, CVar.SERVERONLY);
+
+    /// <summary>
+    /// Whether or not to prevent the restart vote from having any effect when there is an online admin
+    /// </summary>
+    public static readonly CVarDef<bool> VoteRestartNotAllowedWhenAdminOnline =
+        CVarDef.Create("vote.restart_not_allowed_when_admin_online", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The delay which two votes of the same type are allowed to be made by separate people, in seconds.
+    /// </summary>
+    public static readonly CVarDef<float> VoteSameTypeTimeout =
+        CVarDef.Create("vote.same_type_timeout", 240f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Sets the duration of the map vote timer.
+    /// </summary>
+    public static readonly CVarDef<int>
+        VoteTimerMap = CVarDef.Create("vote.timermap", 90, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Sets the duration of the restart vote timer.
+    /// </summary>
+    public static readonly CVarDef<int>
+        VoteTimerRestart = CVarDef.Create("vote.timerrestart", 60, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Sets the duration of the gamemode/preset vote timer.
+    /// </summary>
+    public static readonly CVarDef<int>
+        VoteTimerPreset = CVarDef.Create("vote.timerpreset", 30, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Sets the duration of the map vote timer when ALONE.
+    /// </summary>
+    public static readonly CVarDef<int>
+        VoteTimerAlone = CVarDef.Create("vote.timeralone", 10, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Allows enabling/disabling player-started votekick for ultimate authority
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickEnabled =
+        CVarDef.Create("votekick.enabled", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Config for when the votekick should be allowed to be called based on number of eligible voters.
+    /// </summary>
+    public static readonly CVarDef<int> VotekickEligibleNumberRequirement =
+        CVarDef.Create("votekick.eligible_number", 5, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether a votekick initiator must be a ghost or not.
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickInitiatorGhostRequirement =
+        CVarDef.Create("votekick.initiator_ghost_requirement", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Should the initiator be whitelisted to initiate a votekick?
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickInitiatorWhitelistedRequirement =
+        CVarDef.Create("votekick.initiator_whitelist_requirement", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Should the initiator be able to start a votekick if they are bellow the votekick.voter_playtime requirement?
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickInitiatorTimeRequirement =
+        CVarDef.Create("votekick.initiator_time_requirement", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether a votekick voter must be a ghost or not.
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickVoterGhostRequirement =
+        CVarDef.Create("votekick.voter_ghost_requirement", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Config for how many hours playtime a player must have to be able to vote on a votekick.
+    /// </summary>
+    public static readonly CVarDef<int> VotekickEligibleVoterPlaytime =
+        CVarDef.Create("votekick.voter_playtime", 100, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Config for how many seconds a player must have been dead to initiate a votekick / be able to vote on a votekick.
+    /// </summary>
+    public static readonly CVarDef<int> VotekickEligibleVoterDeathtime =
+        CVarDef.Create("votekick.voter_deathtime", 30, CVar.REPLICATED | CVar.SERVER);
+
+    /// <summary>
+    ///     The required ratio of eligible voters that must agree for a votekick to go through.
+    /// </summary>
+    public static readonly CVarDef<float> VotekickRequiredRatio =
+        CVarDef.Create("votekick.required_ratio", 0.6f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether or not to prevent the votekick from having any effect when there is an online admin.
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickNotAllowedWhenAdminOnline =
+        CVarDef.Create("votekick.not_allowed_when_admin_online", true, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The delay for which two votekicks are allowed to be made by separate people, in seconds.
+    /// </summary>
+    public static readonly CVarDef<float> VotekickTimeout =
+        CVarDef.Create("votekick.timeout", 120f, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Sets the duration of the votekick vote timer.
+    /// </summary>
+    public static readonly CVarDef<int>
+        VotekickTimer = CVarDef.Create("votekick.timer", 60, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Config for how many hours playtime a player must have to get protection from the Raider votekick type when playing as an antag.
+    /// </summary>
+    public static readonly CVarDef<int> VotekickAntagRaiderProtection =
+        CVarDef.Create("votekick.antag_raider_protection", 10, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Default severity for votekick bans
+    /// </summary>
+    public static readonly CVarDef<string> VotekickBanDefaultSeverity =
+        CVarDef.Create("votekick.ban_default_severity", "High", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
+
+    /// <summary>
+    ///     Duration of a ban caused by a votekick (in minutes).
+    /// </summary>
+    public static readonly CVarDef<int> VotekickBanDuration =
+        CVarDef.Create("votekick.ban_duration", 180, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     Whether the ghost requirement settings for votekicks should be ignored for the lobby.
+    /// </summary>
+    public static readonly CVarDef<bool> VotekickIgnoreGhostReqInLobby =
+        CVarDef.Create("votekick.ignore_ghost_req_in_lobby", true, CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Whitelist.cs b/Content.Shared/CCVar/CCVars.Whitelist.cs
new file mode 100644
index 0000000000..b731276493
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Whitelist.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Controls whether the server will deny any players that are not whitelisted in the DB.
+    /// </summary>
+    public static readonly CVarDef<bool> WhitelistEnabled =
+        CVarDef.Create("whitelist.enabled", false, CVar.REPLICATED);
+
+    /// <summary>
+    ///     Specifies the whitelist prototypes to be used by the server. This should be a comma-separated list of prototypes.
+    ///     If a whitelists conditions to be active fail (for example player count), the next whitelist will be used instead. If no whitelist is valid, the player will be allowed to connect.
+    /// </summary>
+    public static readonly CVarDef<string> WhitelistPrototypeList =
+        CVarDef.Create("whitelist.prototype_list", "basicWhitelist", CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.Worldgen.cs b/Content.Shared/CCVar/CCVars.Worldgen.cs
new file mode 100644
index 0000000000..da165ce74a
--- /dev/null
+++ b/Content.Shared/CCVar/CCVars.Worldgen.cs
@@ -0,0 +1,18 @@
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+    /// <summary>
+    ///     Whether or not world generation is enabled.
+    /// </summary>
+    public static readonly CVarDef<bool> WorldgenEnabled =
+        CVarDef.Create("worldgen.enabled", false, CVar.SERVERONLY);
+
+    /// <summary>
+    ///     The worldgen config to use.
+    /// </summary>
+    public static readonly CVarDef<string> WorldgenConfig =
+        CVarDef.Create("worldgen.worldgen_config", "Default", CVar.SERVERONLY);
+}
diff --git a/Content.Shared/CCVar/CCVars.cs b/Content.Shared/CCVar/CCVars.cs
index 62b0850955..316d9b8690 100644
--- a/Content.Shared/CCVar/CCVars.cs
+++ b/Content.Shared/CCVar/CCVars.cs
@@ -1,3091 +1,28 @@
-using Content.Shared.Maps;
-using Content.Shared.Supermatter.Components;
 using Robust.Shared;
 using Robust.Shared.Configuration;
-using Robust.Shared.Physics.Components;
 
-namespace Content.Shared.CCVar
-{
-    // ReSharper disable once InconsistentNaming
-    [CVarDefs]
-    public sealed class CCVars : CVars
-    {
-        #region Server
-        /*
-         * Server
-         */
-
-        /// <summary>
-        ///     Change this to have the changelog and rules "last seen" date stored separately.
-        /// </summary>
-        public static readonly CVarDef<string> ServerId =
-            CVarDef.Create("server.id", "unknown_server_id", CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Guide Entry Prototype ID to be displayed as the server rules.
-        /// </summary>
-        public static readonly CVarDef<string> RulesFile =
-            CVarDef.Create("server.rules_file", "DefaultRuleset", CVar.REPLICATED | CVar.SERVER);
-
-        #endregion
-        #region Ambience
-        /*
-         * Ambience
-         */
-
-        /// <summary>
-        /// How long we'll wait until re-sampling nearby objects for ambience. Should be pretty fast, but doesn't have to match the tick rate.
-        /// </summary>
-        public static readonly CVarDef<float> AmbientCooldown =
-            CVarDef.Create("ambience.cooldown", 0.1f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        /// <summary>
-        /// How large of a range to sample for ambience.
-        /// </summary>
-        public static readonly CVarDef<float> AmbientRange =
-            CVarDef.Create("ambience.range", 8f, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// Maximum simultaneous ambient sounds.
-        /// </summary>
-        public static readonly CVarDef<int> MaxAmbientSources =
-            CVarDef.Create("ambience.max_sounds", 16, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        /// <summary>
-        /// The minimum value the user can set for ambience.max_sounds
-        /// </summary>
-        public static readonly CVarDef<int> MinMaxAmbientSourcesConfigured =
-            CVarDef.Create("ambience.min_max_sounds_configured", 16, CVar.REPLICATED | CVar.SERVER | CVar.CHEAT);
-
-        /// <summary>
-        /// The maximum value the user can set for ambience.max_sounds
-        /// </summary>
-        public static readonly CVarDef<int> MaxMaxAmbientSourcesConfigured =
-            CVarDef.Create("ambience.max_max_sounds_configured", 64, CVar.REPLICATED | CVar.SERVER | CVar.CHEAT);
-
-        /// <summary>
-        /// Ambience volume.
-        /// </summary>
-        public static readonly CVarDef<float> AmbienceVolume =
-            CVarDef.Create("ambience.volume", 1.5f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        /// <summary>
-        /// Ambience music volume.
-        /// </summary>
-        public static readonly CVarDef<float> AmbientMusicVolume =
-            CVarDef.Create("ambience.music_volume", 1.5f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        /// <summary>
-        /// Lobby / round end music volume.
-        /// </summary>
-        public static readonly CVarDef<float> LobbyMusicVolume =
-            CVarDef.Create("ambience.lobby_music_volume", 0.50f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        /// <summary>
-        /// UI volume.
-        /// </summary>
-        public static readonly CVarDef<float> InterfaceVolume =
-            CVarDef.Create("audio.interface_volume", 0.50f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        #endregion
-        #region Status
-        /*
-         * Status
-         */
-
-        public static readonly CVarDef<string> StatusMoMMIUrl =
-            CVarDef.Create("status.mommiurl", "", CVar.SERVERONLY);
-
-        public static readonly CVarDef<string> StatusMoMMIPassword =
-            CVarDef.Create("status.mommipassword", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        #endregion
-        #region Events
-        /*
-         * Events
-         */
-
-        /// <summary>
-        ///     Controls if the game should run station events
-        /// </summary>
-        public static readonly CVarDef<bool>
-            EventsEnabled = CVarDef.Create("events.enabled", true, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Average time (in minutes) for when the ramping event scheduler should stop increasing the chaos modifier.
-        ///     Close to how long you expect a round to last, so you'll probably have to tweak this on downstreams.
-        /// </summary>
-        public static readonly CVarDef<float>
-            EventsRampingAverageEndTime = CVarDef.Create("events.ramping_average_end_time", 40f, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Average ending chaos modifier for the ramping event scheduler.
-        ///     Max chaos chosen for a round will deviate from this
-        /// </summary>
-        public static readonly CVarDef<float>
-            EventsRampingAverageChaos = CVarDef.Create("events.ramping_average_chaos", 6f, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        #endregion
-        #region Game
-        /*
-         * Game
-         */
-
-        /// <summary>
-        ///     Disables most functionality in the GameTicker.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameDummyTicker = CVarDef.Create("game.dummyticker", false, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls if the lobby is enabled. If it is not, and there are no available jobs, you may get stuck on a black screen.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameLobbyEnabled = CVarDef.Create("game.lobbyenabled", true, CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Controls the duration of the lobby timer in seconds. Defaults to 2 minutes and 30 seconds.
-        /// </summary>
-        public static readonly CVarDef<int>
-            GameLobbyDuration = CVarDef.Create("game.lobbyduration", 150, CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Controls if players can latejoin at all.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameDisallowLateJoins = CVarDef.Create("game.disallowlatejoins", false, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls the default game preset.
-        /// </summary>
-        public static readonly CVarDef<string>
-            GameLobbyDefaultPreset = CVarDef.Create("game.defaultpreset", "secret", CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Controls if the game can force a different preset if the current preset's criteria are not met.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameLobbyFallbackEnabled = CVarDef.Create("game.fallbackenabled", true, CVar.ARCHIVE);
-
-        /// <summary>
-        ///     The preset for the game to fall back to if the selected preset could not be used, and fallback is enabled.
-        /// </summary>
-        public static readonly CVarDef<string>
-            GameLobbyFallbackPreset = CVarDef.Create("game.fallbackpreset", "Traitor,Extended", CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Controls if people can win the game in Suspicion or Deathmatch.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameLobbyEnableWin = CVarDef.Create("game.enablewin", true, CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Minimum time between Basic station events in seconds
-        /// </summary>
-        public static readonly CVarDef<int> // 5 Minutes
-            GameEventsBasicMinimumTime = CVarDef.Create("game.events_basic_minimum_time", 300, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Maximum time between Basic station events in seconds
-        /// </summary>
-        public static readonly CVarDef<int> // 25 Minutes
-            GameEventsBasicMaximumTime = CVarDef.Create("game.events_basic_maximum_time", 1500, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Minimum time between Ramping station events in seconds
-        /// </summary>
-        public static readonly CVarDef<int> // 4 Minutes
-            GameEventsRampingMinimumTime = CVarDef.Create("game.events_ramping_minimum_time", 240, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Maximum time between Ramping station events in seconds
-        /// </summary>
-        public static readonly CVarDef<int> // 12 Minutes
-            GameEventsRampingMaximumTime = CVarDef.Create("game.events_ramping_maximum_time", 720, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Minimum time between Oscillating station events in seconds. This is the bare minimum which will never be violated, unlike with ramping events.
-        /// </summary>
-        public static readonly CVarDef<int> // 40 seconds
-            GameEventsOscillatingMinimumTime = CVarDef.Create("game.events_oscillating_minimum_time", 40, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Time between Oscillating station events in seconds at 1x chaos level. Events may occur at larger intervals if current chaos is lower than that.
-        /// </summary>
-        public static readonly CVarDef<int> // 20 Minutes - which constitutes a minimum of 120 seconds between events in Irregular and 280 seconds in Extended Irregular
-            GameEventsOscillatingAverageTime = CVarDef.Create("game.events_oscillating_average_time", 1200, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Controls the maximum number of character slots a player is allowed to have.
-        /// </summary>
-        public static readonly CVarDef<int>
-            GameMaxCharacterSlots = CVarDef.Create("game.maxcharacterslots", 30, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls the game map prototype to load. SS14 stores these prototypes in Prototypes/Maps.
-        /// </summary>
-        public static readonly CVarDef<string>
-            GameMap = CVarDef.Create("game.map", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        /// If roles should be restricted based on whether or not they are whitelisted.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameRoleWhitelist = CVarDef.Create("game.role_whitelist", true, CVar.SERVER | CVar.REPLICATED);
-
-
-        /// <summary>
-        ///     Controls whether to use world persistence or not.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            UsePersistence = CVarDef.Create("game.usepersistence", false, CVar.ARCHIVE);
-
-        /// <summary>
-        ///     If world persistence is used, what map prototype should be initially loaded.
-        ///     If the save file exists, it replaces MapPath but everything else stays the same (station name and such).
-        /// </summary>
-        public static readonly CVarDef<string>
-            PersistenceMap = CVarDef.Create("game.persistencemap", "Empty", CVar.ARCHIVE);
-
-        /// <summary>
-        ///     Prototype to use for map pool.
-        /// </summary>
-        public static readonly CVarDef<string>
-            GameMapPool = CVarDef.Create("game.map_pool", "DefaultMapPool", CVar.SERVERONLY);
-
-        /// <summary>
-        /// The depth of the queue used to calculate which map is next in rotation.
-        /// This is how long the game "remembers" that some map was put in play. Default is 16 rounds.
-        /// </summary>
-        public static readonly CVarDef<int>
-            GameMapMemoryDepth = CVarDef.Create("game.map_memory_depth", 16, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Is map rotation enabled?
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameMapRotation = CVarDef.Create("game.map_rotation", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// If roles should be restricted based on time.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameRoleTimers = CVarDef.Create("game.role_timers", true, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether or not disconnecting inside of a cryopod should remove the character or just store them until they reconnect.
-        /// </summary>
-        public static readonly CVarDef<bool>
-            GameCryoSleepRejoining = CVarDef.Create("game.cryo_sleep_rejoining", false, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        ///     When enabled, guests will be assigned permanent UIDs and will have their preferences stored.
-        /// </summary>
-        public static readonly CVarDef<bool> GamePersistGuests =
-            CVarDef.Create("game.persistguests", true, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        public static readonly CVarDef<bool> GameDiagonalMovement =
-            CVarDef.Create("game.diagonalmovement", true, CVar.ARCHIVE);
-
-        public static readonly CVarDef<int> SoftMaxPlayers =
-            CVarDef.Create("game.soft_max_players", 30, CVar.SERVERONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// If a player gets denied connection to the server,
-        /// how long they are forced to wait before attempting to reconnect.
-        /// </summary>
-        public static readonly CVarDef<int> GameServerFullReconnectDelay =
-            CVarDef.Create("game.server_full_reconnect_delay", 30, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether or not panic bunker is currently enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> PanicBunkerEnabled =
-            CVarDef.Create("game.panic_bunker.enabled", false, CVar.NOTIFY | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether or not the panic bunker will disable when an admin comes online.
-        /// </summary>
-        public static readonly CVarDef<bool> PanicBunkerDisableWithAdmins =
-            CVarDef.Create("game.panic_bunker.disable_with_admins", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether or not the panic bunker will enable when no admins are online.
-        /// </summary>
-        public static readonly CVarDef<bool> PanicBunkerEnableWithoutAdmins =
-            CVarDef.Create("game.panic_bunker.enable_without_admins", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether or not the panic bunker will count deadminned admins for
-        /// <see cref="PanicBunkerDisableWithAdmins"/> and
-        /// <see cref="PanicBunkerEnableWithoutAdmins"/>
-        /// </summary>
-        public static readonly CVarDef<bool> PanicBunkerCountDeadminnedAdmins =
-            CVarDef.Create("game.panic_bunker.count_deadminned_admins", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Show reason of disconnect for user or not.
-        /// </summary>
-        public static readonly CVarDef<bool> PanicBunkerShowReason =
-            CVarDef.Create("game.panic_bunker.show_reason", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Minimum age of the account (from server's PoV, so from first-seen date) in hours.
-        /// </summary>
-        public static readonly CVarDef<int> PanicBunkerMinAccountAge =
-            CVarDef.Create("game.panic_bunker.min_account_age", 24, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Minimal overall played time.
-        /// </summary>
-        public static readonly CVarDef<int> PanicBunkerMinOverallHours =
-            CVarDef.Create("game.panic_bunker.min_overall_hours", 10, CVar.SERVERONLY);
-
-        /// <summary>
-        /// A custom message that will be used for connections denied to the panic bunker
-        /// If not empty, then will overwrite <see cref="PanicBunkerShowReason"/>
-        /// </summary>
-        public static readonly CVarDef<string> PanicBunkerCustomReason =
-            CVarDef.Create("game.panic_bunker.custom_reason", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Allow bypassing the panic bunker if the user is whitelisted.
-        /// </summary>
-        public static readonly CVarDef<bool> BypassBunkerWhitelist =
-            CVarDef.Create("game.panic_bunker.whitelisted_can_bypass", true, CVar.SERVERONLY);
-
-        /*
-         * TODO: Remove baby jail code once a more mature gateway process is established. This code is only being issued as a stopgap to help with potential tiding in the immediate future.
-         */
-
-        /// <summary>
-        /// Whether the baby jail is currently enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> BabyJailEnabled  =
-            CVarDef.Create("game.baby_jail.enabled", false, CVar.NOTIFY | CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// Show reason of disconnect for user or not.
-        /// </summary>
-        public static readonly CVarDef<bool> BabyJailShowReason =
-            CVarDef.Create("game.baby_jail.show_reason", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Maximum age of the account (from server's PoV, so from first-seen date) in hours that can access baby
-        /// jailed servers.
-        /// </summary>
-        public static readonly CVarDef<int> BabyJailMaxAccountAge =
-            CVarDef.Create("game.baby_jail.max_account_age", 24, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Maximum overall played time allowed to access baby jailed servers.
-        /// </summary>
-        public static readonly CVarDef<int> BabyJailMaxOverallHours =
-            CVarDef.Create("game.baby_jail.max_overall_hours", 2, CVar.SERVERONLY);
-
-        /// <summary>
-        /// A custom message that will be used for connections denied due to the baby jail.
-        /// If not empty, then will overwrite <see cref="BabyJailShowReason"/>
-        /// </summary>
-        public static readonly CVarDef<string> BabyJailCustomReason =
-            CVarDef.Create("game.baby_jail.custom_reason", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Allow bypassing the baby jail if the user is whitelisted.
-        /// </summary>
-        public static readonly CVarDef<bool> BypassBabyJailWhitelist =
-            CVarDef.Create("game.baby_jail.whitelisted_can_bypass", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Make people bonk when trying to climb certain objects like tables.
-        /// </summary>
-        public static readonly CVarDef<bool> GameTableBonk =
-            CVarDef.Create("game.table_bonk", false, CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether or not status icons are rendered for everyone.
-        /// </summary>
-        public static readonly CVarDef<bool> GlobalStatusIconsEnabled =
-            CVarDef.Create("game.global_status_icons_enabled", true, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether or not status icons are rendered on this specific client.
-        /// </summary>
-        public static readonly CVarDef<bool> LocalStatusIconsEnabled =
-            CVarDef.Create("game.local_status_icons_enabled", true, CVar.CLIENTONLY);
-
-        /// <summary>
-        /// Whether or not coordinates on the Debug overlay should only be available to admins.
-        /// </summary>
-        public static readonly CVarDef<bool> DebugCoordinatesAdminOnly =
-            CVarDef.Create("game.debug_coordinates_admin_only", true, CVar.SERVER | CVar.REPLICATED);
-
-
-        /// <summary>
-        ///     Whether to allow characters to select traits.
-        /// </summary>
-        public static readonly CVarDef<bool> GameTraitsEnabled =
-            CVarDef.Create("game.traits_enabled", true, CVar.REPLICATED);
-
-        /// <summary>
-        ///     How many traits a character can have at most.
-        /// </summary>
-        public static readonly CVarDef<int> GameTraitsMax =
-            CVarDef.Create("game.traits_max", 14, CVar.REPLICATED);
-
-        /// <summary>
-        ///     How many points a character should start with.
-        /// </summary>
-        public static readonly CVarDef<int> GameTraitsDefaultPoints =
-            CVarDef.Create("game.traits_default_points", 10, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Whether the game will SMITE people who used cheat engine to spawn with all of the traits.
-        ///     Illegal trait totals will still be logged even if this is disabled.
-        ///     If you are intending to decrease the trait points availability, or modify the costs of traits, consider temporarily disabling this.
-        /// </summary>
-        public static readonly CVarDef<bool> TraitsPunishCheaters =
-            CVarDef.Create("game.traits_punish_cheaters", false, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Whether to allow characters to select loadout items.
-        /// </summary>
-        public static readonly CVarDef<bool> GameLoadoutsEnabled =
-            CVarDef.Create("game.loadouts_enabled", true, CVar.REPLICATED);
-
-        /// <summary>
-        ///     How many points to give to each player for loadouts.
-        /// </summary>
-        public static readonly CVarDef<int> GameLoadoutsPoints =
-            CVarDef.Create("game.loadouts_points", 14, CVar.REPLICATED);
-
-
-        /// <summary>
-        ///     Whether to repeat eating doafters after completion
-        /// </summary>
-        public static readonly CVarDef<bool> GameAutoEatFood =
-            CVarDef.Create("game.auto_eat_food", false, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Whether to repeat drinking doafters after completion
-        /// </summary>
-        public static readonly CVarDef<bool> GameAutoEatDrinks =
-            CVarDef.Create("game.auto_eat_drinks", false, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Whether item slots, such as power cell slots or AME fuel cell slots, should support quick swap if it is not otherwise specified in their YAML prototype.
-        /// </summary>
-        public static readonly CVarDef<bool> AllowSlotQuickSwap =
-            CVarDef.Create("game.slot_quick_swap", false, CVar.REPLICATED);
-
-#if EXCEPTION_TOLERANCE
-        /// <summary>
-        ///     Amount of times round start must fail before the server is shut down.
-        ///     Set to 0 or a negative number to disable.
-        /// </summary>
-        public static readonly CVarDef<int> RoundStartFailShutdownCount =
-            CVarDef.Create("game.round_start_fail_shutdown_count", 5, CVar.SERVERONLY | CVar.SERVER);
-#endif
-
-        /// <summary>
-        /// Delay between station alert level changes.
-        /// </summary>
-        public static readonly CVarDef<int> GameAlertLevelChangeDelay =
-            CVarDef.Create("game.alert_level_change_delay", 30, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The time in seconds that the server should wait before restarting the round.
-        /// Defaults to 2 minutes.
-        /// </summary>
-        public static readonly CVarDef<float> RoundRestartTime =
-            CVarDef.Create("game.round_restart_time", 120f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The prototype to use for secret weights.
-        /// </summary>
-        public static readonly CVarDef<string> SecretWeightPrototype =
-            CVarDef.Create("game.secret_weight_prototype", "Secret", CVar.SERVERONLY);
-
-        /// <summary>
-        /// The id of the sound collection to randomly choose a sound from and play when the round ends.
-        /// </summary>
-        public static readonly CVarDef<string> RoundEndSoundCollection =
-            CVarDef.Create("game.round_end_sound_collection", "RoundEnd", CVar.SERVERONLY);
-
-        #endregion
-        #region Announcers
-
-        /*
-         * Announcers
-         */
-
-        /// <summary>
-        ///     Weighted list of announcers to choose from
-        /// </summary>
-        public static readonly CVarDef<string> AnnouncerList =
-            CVarDef.Create("announcer.list", "RandomAnnouncers", CVar.REPLICATED);
-
-        /// <summary>
-        ///     Optionally force set an announcer
-        /// </summary>
-        public static readonly CVarDef<string> Announcer =
-            CVarDef.Create("announcer.announcer", "", CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Optionally blacklist announcers
-        ///     List of IDs separated by commas
-        /// </summary>
-        public static readonly CVarDef<string> AnnouncerBlacklist =
-            CVarDef.Create("announcer.blacklist", "", CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Changes how loud the announcers are for the client
-        /// </summary>
-        public static readonly CVarDef<float> AnnouncerVolume =
-            CVarDef.Create("announcer.volume", 0.5f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        /// <summary>
-        ///     Disables multiple announcement sounds from playing at once
-        /// </summary>
-        public static readonly CVarDef<bool> AnnouncerDisableMultipleSounds =
-            CVarDef.Create("announcer.disable_multiple_sounds", false, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-
-        #endregion
-        #region Queue
-        /*
-         * Queue
-         */
-
-        /// <summary>
-        ///     Controls if the connections queue is enabled
-        ///     If enabled plyaers will be added to a queue instead of being kicked after SoftMaxPlayers is reached
-        /// </summary>
-        public static readonly CVarDef<bool> QueueEnabled =
-            CVarDef.Create("queue.enabled", false, CVar.SERVERONLY);
-
-        #endregion
-        #region Discord
-
-        /*
-         * Discord
-         */
-
-        /// <summary>
-        /// The role that will get mentioned if a new SOS ahelp comes in.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordAhelpMention =
-            CVarDef.Create("discord.on_call_ping", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        /// <summary>
-        /// URL of the discord webhook to relay unanswered ahelp messages.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordOnCallWebhook =
-            CVarDef.Create("discord.on_call_webhook", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        /// <summary>
-        /// URL of the Discord webhook which will relay all ahelp messages.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordAHelpWebhook =
-            CVarDef.Create("discord.ahelp_webhook", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        /// <summary>
-        /// The server icon to use in the Discord ahelp embed footer.
-        /// Valid values are specified at https://discord.com/developers/docs/resources/channel#embed-object-embed-footer-structure.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordAHelpFooterIcon =
-            CVarDef.Create("discord.ahelp_footer_icon", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The avatar to use for the webhook. Should be an URL.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordAHelpAvatar =
-            CVarDef.Create("discord.ahelp_avatar", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        /// URL of the Discord webhook which will relay all custom votes. If left empty, disables the webhook.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordVoteWebhook =
-            CVarDef.Create("discord.vote_webhook", string.Empty, CVar.SERVERONLY);
-
-        /// URL of the Discord webhook which will relay round restart messages.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordRoundUpdateWebhook =
-            CVarDef.Create("discord.round_update_webhook", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        /// <summary>
-        /// Role id for the Discord webhook to ping when the round ends.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordRoundEndRoleWebhook =
-            CVarDef.Create("discord.round_end_role", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Enable Discord linking, show linking button and modal window
-        /// </summary>
-        public static readonly CVarDef<bool> DiscordAuthEnabled =
-            CVarDef.Create("discord.auth_enabled", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     URL of the Discord auth server API
-        /// </summary>
-        public static readonly CVarDef<string> DiscordAuthApiUrl =
-            CVarDef.Create("discord.auth_api_url", "", CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Secret key of the Discord auth server API
-        /// </summary>
-        public static readonly CVarDef<string> DiscordAuthApiKey =
-            CVarDef.Create("discord.auth_api_key", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        #endregion
-        #region Tips
-        /*
-         * Tips
-         */
-
-        /// <summary>
-        ///     Whether tips being shown is enabled at all.
-        /// </summary>
-        public static readonly CVarDef<bool> TipsEnabled =
-            CVarDef.Create("tips.enabled", true);
-
-        /// <summary>
-        ///     The dataset prototype to use when selecting a random tip.
-        /// </summary>
-        public static readonly CVarDef<string> TipsDataset =
-            CVarDef.Create("tips.dataset", "Tips");
-
-        /// <summary>
-        ///     The number of seconds between each tip being displayed when the round is not actively going
-        ///     (i.e. postround or lobby)
-        /// </summary>
-        public static readonly CVarDef<float> TipFrequencyOutOfRound =
-            CVarDef.Create("tips.out_of_game_frequency", 60f * 1.5f);
-
-        /// <summary>
-        ///     The number of seconds between each tip being displayed when the round is actively going
-        /// </summary>
-        public static readonly CVarDef<float> TipFrequencyInRound =
-            CVarDef.Create("tips.in_game_frequency", 60f * 60);
-
-        public static readonly CVarDef<string> LoginTipsDataset =
-            CVarDef.Create("tips.login_dataset", "Tips");
-
-        /// <summary>
-        ///     The chance for Tippy to replace a normal tip message.
-        /// </summary>
-        public static readonly CVarDef<float> TipsTippyChance =
-            CVarDef.Create("tips.tippy_chance", 0.01f);
-
-        #endregion
-        #region Console
-        /*
-         * Console
-         */
-
-        public static readonly CVarDef<bool> ConsoleLoginLocal =
-            CVarDef.Create("console.loginlocal", true, CVar.ARCHIVE | CVar.SERVERONLY);
-
-        /// <summary>
-        /// Automatically log in the given user as host, equivalent to the <c>promotehost</c> command.
-        /// </summary>
-        public static readonly CVarDef<string> ConsoleLoginHostUser =
-            CVarDef.Create("console.login_host_user", "", CVar.ARCHIVE | CVar.SERVERONLY);
-
-
-        #endregion
-        #region Database stuff
-        /*
-         * Database stuff
-         */
-
-        public static readonly CVarDef<string> DatabaseEngine =
-            CVarDef.Create("database.engine", "sqlite", CVar.SERVERONLY);
-
-        public static readonly CVarDef<string> DatabaseSqliteDbPath =
-            CVarDef.Create("database.sqlite_dbpath", "preferences.db", CVar.SERVERONLY);
-
-        /// <summary>
-        /// Milliseconds to asynchronously delay all SQLite database acquisitions with.
-        /// </summary>
-        /// <remarks>
-        /// Defaults to 1 on DEBUG, 0 on RELEASE.
-        /// This is intended to help catch .Result deadlock bugs that only happen on postgres
-        /// (because SQLite is not actually asynchronous normally)
-        /// </remarks>
-        public static readonly CVarDef<int> DatabaseSqliteDelay =
-            CVarDef.Create("database.sqlite_delay", DefaultSqliteDelay, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Amount of concurrent SQLite database operations.
-        /// </summary>
-        /// <remarks>
-        /// Note that SQLite is not a properly asynchronous database and also has limited read/write concurrency.
-        /// Increasing this number may allow more concurrent reads, but it probably won't matter much.
-        /// SQLite operations are normally ran on the thread pool, which may cause thread pool starvation if the concurrency is too high.
-        /// </remarks>
-        public static readonly CVarDef<int> DatabaseSqliteConcurrency =
-            CVarDef.Create("database.sqlite_concurrency", 3, CVar.SERVERONLY);
-
-#if DEBUG
-        private const int DefaultSqliteDelay = 1;
-#else
-        private const int DefaultSqliteDelay = 0;
-#endif
-
-
-        public static readonly CVarDef<string> DatabasePgHost =
-            CVarDef.Create("database.pg_host", "localhost", CVar.SERVERONLY);
-
-        public static readonly CVarDef<int> DatabasePgPort =
-            CVarDef.Create("database.pg_port", 5432, CVar.SERVERONLY);
-
-        public static readonly CVarDef<string> DatabasePgDatabase =
-            CVarDef.Create("database.pg_database", "ss14", CVar.SERVERONLY);
-
-        public static readonly CVarDef<string> DatabasePgUsername =
-            CVarDef.Create("database.pg_username", "postgres", CVar.SERVERONLY);
-
-        public static readonly CVarDef<string> DatabasePgPassword =
-            CVarDef.Create("database.pg_password", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-        /// <summary>
-        /// Max amount of concurrent Postgres database operations.
-        /// </summary>
-        public static readonly CVarDef<int> DatabasePgConcurrency =
-            CVarDef.Create("database.pg_concurrency", 8, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Milliseconds to asynchronously delay all PostgreSQL database operations with.
-        /// </summary>
-        /// <remarks>
-        /// This is intended for performance testing. It works different from <see cref="DatabaseSqliteDelay"/>,
-        /// as the lag is applied after acquiring the database lock.
-        /// </remarks>
-        public static readonly CVarDef<int> DatabasePgFakeLag =
-            CVarDef.Create("database.pg_fake_lag", 0, CVar.SERVERONLY);
-
-        // Basically only exists for integration tests to avoid race conditions.
-        public static readonly CVarDef<bool> DatabaseSynchronous =
-            CVarDef.Create("database.sync", false, CVar.SERVERONLY);
-
-        #endregion
-        #region Interface
-        /*
-         * Interface
-         */
-
-        public static readonly CVarDef<string> UIClickSound =
-            CVarDef.Create("interface.click_sound", "/Audio/UserInterface/click.ogg", CVar.REPLICATED);
-
-        public static readonly CVarDef<string> UIHoverSound =
-            CVarDef.Create("interface.hover_sound", "/Audio/UserInterface/hover.ogg", CVar.REPLICATED);
-
-        #endregion
-        #region Outline
-        /*
-         * Outline
-         */
-
-        public static readonly CVarDef<bool> OutlineEnabled =
-            CVarDef.Create("outline.enabled", true, CVar.CLIENTONLY);
-
-
-        #endregion
-        #region Parallax
-        /*
-         * Parallax
-         */
-
-        public static readonly CVarDef<bool> ParallaxEnabled =
-            CVarDef.Create("parallax.enabled", true, CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> ParallaxDebug =
-            CVarDef.Create("parallax.debug", false, CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> ParallaxLowQuality =
-            CVarDef.Create("parallax.low_quality", false, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        #endregion
-        #region Physics
-        /*
-         * Physics
-         */
-
-        /// <summary>
-        /// When a mob is walking should its X / Y movement be relative to its parent (true) or the map (false).
-        /// </summary>
-        public static readonly CVarDef<bool> RelativeMovement =
-            CVarDef.Create("physics.relative_movement", true, CVar.ARCHIVE | CVar.REPLICATED);
-
-        public static readonly CVarDef<float> TileFrictionModifier =
-            CVarDef.Create("physics.tile_friction", 40.0f, CVar.ARCHIVE | CVar.REPLICATED);
-
-        public static readonly CVarDef<float> StopSpeed =
-            CVarDef.Create("physics.stop_speed", 0.1f, CVar.ARCHIVE | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether mobs can push objects like lockers.
-        /// </summary>
-        /// <remarks>
-        /// Technically client doesn't need to know about it but this may prevent a bug in the distant future so it stays.
-        /// </remarks>
-        public static readonly CVarDef<bool> MobPushing =
-            CVarDef.Create("physics.mob_pushing", false, CVar.REPLICATED);
-
-        #endregion
-        #region Music
-        /*
-         * Music
-         */
-
-        public static readonly CVarDef<bool> LobbyMusicEnabled =
-            CVarDef.Create("ambience.lobby_music_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> EventMusicEnabled =
-            CVarDef.Create("ambience.event_music_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        #endregion
-        #region Specific Sounds
-
-        /*
-         * Specific Sounds
-         */
-        // Round  end sound (APC Destroyed)
-        public static readonly CVarDef<bool> RestartSoundsEnabled =
-            CVarDef.Create("ambience.restart_sounds_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-
-        #endregion
-        #region Admin Sounds
-        /*
-         * Admin sounds
-         */
-
-        public static readonly CVarDef<bool> AdminSoundsEnabled =
-            CVarDef.Create("audio.admin_sounds_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-        public static readonly CVarDef<string> AdminChatSoundPath =
-            CVarDef.Create("audio.admin_chat_sound_path", "/Audio/Items/pop.ogg", CVar.ARCHIVE | CVar.CLIENT | CVar.REPLICATED);
-        public static readonly CVarDef<float> AdminChatSoundVolume =
-            CVarDef.Create("audio.admin_chat_sound_volume", -5f, CVar.ARCHIVE | CVar.CLIENT | CVar.REPLICATED);
-
-        #endregion
-        #region HUD
-        /*
-         * HUD
-         */
-
-        public static readonly CVarDef<int> HudTheme =
-            CVarDef.Create("hud.theme", 0, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> HudHeldItemShow =
-            CVarDef.Create("hud.held_item_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> CombatModeIndicatorsPointShow =
-            CVarDef.Create("hud.combat_mode_indicators_point_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> OfferModeIndicatorsPointShow =
-            CVarDef.Create("hud.offer_mode_indicators_point_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-        public static readonly CVarDef<bool> LoocAboveHeadShow =
-            CVarDef.Create("hud.show_looc_above_head", true, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        public static readonly CVarDef<float> HudHeldItemOffset =
-            CVarDef.Create("hud.held_item_offset", 28f, CVar.ARCHIVE | CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> HudFpsCounterVisible =
-            CVarDef.Create("hud.fps_counter_visible", false, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        #endregion
-        #region NPCs
-        /*
-         * NPCs
-         */
-
-        public static readonly CVarDef<int> NPCMaxUpdates =
-            CVarDef.Create("npc.max_updates", 128);
-
-        public static readonly CVarDef<bool> NPCEnabled = CVarDef.Create("npc.enabled", true);
-
-        /// <summary>
-        /// Should NPCs pathfind when steering. For debug purposes.
-        /// </summary>
-        public static readonly CVarDef<bool> NPCPathfinding = CVarDef.Create("npc.pathfinding", true);
-
-        #endregion
-        #region Net
-        /*
-         * Net
-         */
-
-        public static readonly CVarDef<float> NetAtmosDebugOverlayTickRate =
-            CVarDef.Create("net.atmosdbgoverlaytickrate", 3.0f);
-
-        public static readonly CVarDef<float> NetGasOverlayTickRate =
-            CVarDef.Create("net.gasoverlaytickrate", 3.0f);
-
-        public static readonly CVarDef<int> GasOverlayThresholds =
-            CVarDef.Create("net.gasoverlaythresholds", 20);
-
-        #endregion
-        #region Admin
-        /*
-         * Admin
-         */
-
-        public static readonly CVarDef<bool> AdminAnnounceLogin =
-            CVarDef.Create("admin.announce_login", true, CVar.SERVERONLY);
-
-        public static readonly CVarDef<bool> AdminAnnounceLogout =
-            CVarDef.Create("admin.announce_logout", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The token used to authenticate with the admin API. Leave empty to disable the admin API. This is a secret! Do not share!
-        /// </summary>
-        public static readonly CVarDef<string> AdminApiToken =
-            CVarDef.Create("admin.api_token", string.Empty, CVar.SERVERONLY | CVar.CONFIDENTIAL);
-
-
-        /// <summary>
-        /// Should users be able to see their own notes? Admins will be able to see and set notes regardless
-        /// </summary>
-        public static readonly CVarDef<bool> SeeOwnNotes =
-            CVarDef.Create("admin.see_own_notes", false, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// Should the server play a quick sound to the active admins whenever a new player joins?
-        /// </summary>
-        public static readonly CVarDef<bool> AdminNewPlayerJoinSound =
-            CVarDef.Create("admin.new_player_join_sound", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The amount of days before the note starts fading. It will slowly lose opacity until it reaches stale. Set to 0 to disable.
-        /// </summary>
-        public static readonly CVarDef<double> NoteFreshDays =
-            CVarDef.Create("admin.note_fresh_days", 91.31055, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// The amount of days before the note completely fades, and can only be seen by admins if they press "see more notes". Set to 0
-        /// if you want the note to immediately disappear without fading.
-        /// </summary>
-        public static readonly CVarDef<double> NoteStaleDays =
-            CVarDef.Create("admin.note_stale_days", 365.2422, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// How much time does the user have to wait in seconds before confirming that they saw an admin message?
-        /// </summary>
-        public static readonly CVarDef<float> MessageWaitTime =
-            CVarDef.Create("admin.message_wait_time", 3f, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// Default severity for role bans
-        /// </summary>
-        public static readonly CVarDef<string> RoleBanDefaultSeverity =
-            CVarDef.Create("admin.role_ban_default_severity", "medium", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Default severity for department bans
-        /// </summary>
-        public static readonly CVarDef<string> DepartmentBanDefaultSeverity =
-            CVarDef.Create("admin.department_ban_default_severity", "medium", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Default severity for server bans
-        /// </summary>
-        public static readonly CVarDef<string> ServerBanDefaultSeverity =
-            CVarDef.Create("admin.server_ban_default_severity", "High", CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether a server ban will ban the player's ip by default.
-        /// </summary>
-        public static readonly CVarDef<bool> ServerBanIpBanDefault =
-            CVarDef.Create("admin.server_ban_ip_ban_default", true, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether a server ban will ban the player's hardware id by default.
-        /// </summary>
-        public static readonly CVarDef<bool> ServerBanHwidBanDefault =
-            CVarDef.Create("admin.server_ban_hwid_ban_default", true, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether to use details from last connection for ip/hwid in the BanPanel.
-        /// </summary>
-        public static readonly CVarDef<bool> ServerBanUseLastDetails =
-            CVarDef.Create("admin.server_ban_use_last_details", true, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether to erase a player's chat messages and their entity from the game when banned.
-        /// </summary>
-        public static readonly CVarDef<bool> ServerBanErasePlayer =
-            CVarDef.Create("admin.server_ban_erase_player", false, CVar.ARCHIVE | CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        ///     Minimum players sharing a connection required to create an alert. -1 to disable the alert.
-        /// </summary>
-        /// <remarks>
-        ///     If you set this to 0 or 1 then it will alert on every connection, so probably don't do that.
-        /// </remarks>
-        public static readonly CVarDef<int> AdminAlertMinPlayersSharingConnection =
-            CVarDef.Create("admin.alert.min_players_sharing_connection", -1, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Minimum explosion intensity to create an admin alert message. -1 to disable the alert.
-        /// </summary>
-        public static readonly CVarDef<int> AdminAlertExplosionMinIntensity =
-            CVarDef.Create("admin.alert.explosion_min_intensity", 60, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Minimum particle accelerator strength to create an admin alert message.
-        /// </summary>
-        public static readonly CVarDef<int> AdminAlertParticleAcceleratorMinPowerState =
-            CVarDef.Create("admin.alert.particle_accelerator_min_power_state", 3, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Should the ban details in admin channel include PII? (IP, HWID, etc)
-        /// </summary>
-        public static readonly CVarDef<bool> AdminShowPIIOnBan =
-            CVarDef.Create("admin.show_pii_onban", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// If an admin joins a round by reading up or using the late join button, automatically
-        /// de-admin them.
-        /// </summary>
-        public static readonly CVarDef<bool> AdminDeadminOnJoin =
-            CVarDef.Create("admin.deadmin_on_join", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Overrides the name the client sees in ahelps. Set empty to disable.
-        /// </summary>
-        public static readonly CVarDef<string> AdminAhelpOverrideClientName =
-            CVarDef.Create("admin.override_adminname_in_client_ahelp", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The threshold of minutes to appear as a "new player" in the ahelp menu
-        ///     If 0, appearing as a new player is disabled.
-        /// </summary>
-        public static readonly CVarDef<int> NewPlayerThreshold =
-            CVarDef.Create("admin.new_player_threshold", 0, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        /// How long an admin client can go without any input before being considered AFK.
-        /// </summary>
-        public static readonly CVarDef<float> AdminAfkTime =
-            CVarDef.Create("admin.afk_time", 600f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// If true, admins are able to connect even if
-        /// <see cref="SoftMaxPlayers"/> would otherwise block regular players.
-        /// </summary>
-        public static readonly CVarDef<bool> AdminBypassMaxPlayers =
-            CVarDef.Create("admin.bypass_max_players", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Determine if custom rank names are used.
-        /// If it is false, it'd use the actual rank name regardless of the individual's title.
-        /// </summary>
-        /// <seealso cref="AhelpAdminPrefix"/>
-        /// <seealso cref="AhelpAdminPrefixWebhook"/>
-        public static readonly CVarDef<bool> AdminUseCustomNamesAdminRank =
-            CVarDef.Create("admin.use_custom_names_admin_rank", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Determines whether admins count towards the total playercount when determining whether the server is over <see cref="SoftMaxPlayers"/>
-        ///     Ideally this should be used in conjuction with <see cref="AdminBypassPlayers"/>.
-        ///     This also applies to playercount limits in whitelist conditions
-        ///     If false, then admins will not be considered when checking whether the playercount is already above the soft player cap
-        /// </summary>
-        public static readonly CVarDef<bool> AdminsCountForMaxPlayers =
-            CVarDef.Create("admin.admins_count_for_max_players", false, CVar.SERVERONLY);
-
-        #endregion
-        #region AHELP
-        /*
-         * AHELP
-         */
-
-        /// <summary>
-        /// Ahelp rate limit values are accounted in periods of this size (seconds).
-        /// After the period has passed, the count resets.
-        /// </summary>
-        /// <seealso cref="AhelpRateLimitCount"/>
-        public static readonly CVarDef<float> AhelpRateLimitPeriod =
-            CVarDef.Create("ahelp.rate_limit_period", 2f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How many ahelp messages are allowed in a single rate limit period.
-        /// </summary>
-        /// <seealso cref="AhelpRateLimitPeriod"/>
-        public static readonly CVarDef<int> AhelpRateLimitCount =
-            CVarDef.Create("ahelp.rate_limit_count", 10, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Should the administrator's position be displayed in ahelp.
-        /// If it is is false, only the admin's ckey will be displayed in the ahelp.
-        /// </summary>
-        /// <seealso cref="AdminUseCustomNamesAdminRank"/>
-        /// <seealso cref="AhelpAdminPrefixWebhook"/>
-        public static readonly CVarDef<bool> AhelpAdminPrefix =
-            CVarDef.Create("ahelp.admin_prefix", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Should the administrator's position be displayed in the webhook.
-        /// If it is is false, only the admin's ckey will be displayed in webhook.
-        /// </summary>
-        /// <seealso cref="AdminUseCustomNamesAdminRank"/>
-        /// <seealso cref="AhelpAdminPrefix"/>
-        public static readonly CVarDef<bool> AhelpAdminPrefixWebhook =
-            CVarDef.Create("ahelp.admin_prefix_webhook", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If an admin replies to users from discord, should it use their discord role color? (if applicable)
-        ///     Overrides DiscordReplyColor and AdminBwoinkColor.
-        /// </summary>
-        public static readonly CVarDef<bool> UseDiscordRoleColor =
-            CVarDef.Create("admin.use_discord_role_color", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If an admin replies to users from discord, should it use their discord role color? (if applicable)
-        ///     Overrides DiscordReplyColor and AdminBwoinkColor.
-        /// </summary>
-        public static readonly CVarDef<bool> UseDiscordRoleName =
-            CVarDef.Create("admin.use_discord_role_name", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The text before an admin's name when replying from discord to indicate they're speaking from discord.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordReplyPrefix =
-            CVarDef.Create("admin.discord_reply_prefix", "(DC) ", CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The color of the names of admins. This is the fallback color for admins.
-        /// </summary>
-        public static readonly CVarDef<string> AdminBwoinkColor =
-            CVarDef.Create("admin.admin_bwoink_color", "red", CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The color of the names of admins who reply from discord. Leave empty to disable.
-        ///     Overrides AdminBwoinkColor.
-        /// </summary>
-        public static readonly CVarDef<string> DiscordReplyColor =
-            CVarDef.Create("admin.discord_reply_color", string.Empty, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Use the admin's Admin OOC color in bwoinks.
-        ///     If either the ooc color or this is not set, uses the admin.admin_bwoink_color value.
-        /// </summary>
-        public static readonly CVarDef<bool> UseAdminOOCColorInBwoinks =
-            CVarDef.Create("admin.bwoink_use_admin_ooc_color", false, CVar.SERVERONLY);
-
-        #endregion
-        #region Explosions
-        /*
-         * Explosions
-         */
-
-        /// <summary>
-        ///     How many tiles the explosion system will process per tick
-        /// </summary>
-        /// <remarks>
-        ///     Setting this too high will put a large load on a single tick. Setting this too low will lead to
-        ///     unnaturally "slow" explosions.
-        /// </remarks>
-        public static readonly CVarDef<int> ExplosionTilesPerTick =
-            CVarDef.Create("explosion.tiles_per_tick", 100, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Upper limit on the size of an explosion before physics-throwing is disabled.
-        /// </summary>
-        /// <remarks>
-        ///     Large nukes tend to generate a lot of shrapnel that flies through space. This can functionally cripple
-        ///     the server TPS for a while after an explosion (or even during, if the explosion is processed
-        ///     incrementally.
-        /// </remarks>
-        public static readonly CVarDef<int> ExplosionThrowLimit =
-            CVarDef.Create("explosion.throw_limit", 400, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If this is true, explosion processing will pause the NodeGroupSystem to pause updating.
-        /// </summary>
-        /// <remarks>
-        ///     This only takes effect if an explosion needs more than one tick to process (i.e., covers more than <see
-        ///     cref="ExplosionTilesPerTick"/> tiles). If this is not enabled, the node-system will rebuild its graph
-        ///     every tick as the explosion shreds the station, causing significant slowdown.
-        /// </remarks>
-        public static readonly CVarDef<bool> ExplosionSleepNodeSys =
-            CVarDef.Create("explosion.node_sleep", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Upper limit on the total area that an explosion can affect before the neighbor-finding algorithm just
-        ///     stops. Defaults to a 60-rile radius explosion.
-        /// </summary>
-        /// <remarks>
-        ///     Actual area may be larger, as it currently doesn't terminate mid neighbor finding. I.e., area may be that of a ~51 tile radius circle instead.
-        /// </remarks>
-        public static readonly CVarDef<int> ExplosionMaxArea =
-            CVarDef.Create("explosion.max_area", (int) 3.14f * 256 * 256, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Upper limit on the number of neighbor finding steps for the explosion system neighbor-finding algorithm.
-        /// </summary>
-        /// <remarks>
-        ///     Effectively places an upper limit on the range that any explosion can have. In the vast majority of
-        ///     instances, <see cref="ExplosionMaxArea"/> will likely be hit before this becomes a limiting factor.
-        /// </remarks>
-        public static readonly CVarDef<int> ExplosionMaxIterations =
-            CVarDef.Create("explosion.max_iterations", 500, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Max Time in milliseconds to spend processing explosions every tick.
-        /// </summary>
-        /// <remarks>
-        ///     This time limiting is not perfectly implemented. Firstly, a significant chunk of processing time happens
-        ///     due to queued entity deletions, which happen outside of the system update code. Secondly, explosion
-        ///     spawning cannot currently be interrupted & resumed, and may lead to exceeding this time limit.
-        /// </remarks>
-        public static readonly CVarDef<float> ExplosionMaxProcessingTime =
-            CVarDef.Create("explosion.max_tick_time", 7f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If the explosion is being processed incrementally over several ticks, this variable determines whether
-        ///     updating the grid tiles should be done incrementally at the end of every tick, or only once the explosion has finished processing.
-        /// </summary>
-        /// <remarks>
-        ///     The most notable consequence of this change is that explosions will only punch a hole in the station &
-        ///     create a vacumm once they have finished exploding. So airlocks will no longer slam shut as the explosion
-        ///     expands, just suddenly at the end.
-        /// </remarks>
-        public static readonly CVarDef<bool> ExplosionIncrementalTileBreaking =
-            CVarDef.Create("explosion.incremental_tile", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     This determines for how many seconds an explosion should stay visible once it has finished expanding.
-        /// </summary>
-        public static readonly CVarDef<float> ExplosionPersistence =
-            CVarDef.Create("explosion.persistence", 1.0f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If an explosion covers a larger area than this number, the damaging/processing will always start during
-        ///     the next tick, instead of during the same tick that the explosion was generated in.
-        /// </summary>
-        /// <remarks>
-        ///     This value can be used to ensure that for large explosions the area/tile calculation and the explosion
-        ///     processing/damaging occurs in separate ticks. This helps reduce the single-tick lag if both <see
-        ///     cref="ExplosionMaxProcessingTime"/> and <see cref="ExplosionTilesPerTick"/> are large. I.e., instead of
-        ///     a single tick explosion, this cvar allows for a configuration that results in a two-tick explosion,
-        ///     though most of the computational cost is still in the second tick.
-        /// </remarks>
-        public static readonly CVarDef<int> ExplosionSingleTickAreaLimit =
-            CVarDef.Create("explosion.single_tick_area_limit", 400, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether or not explosions are allowed to create tiles that have
-        ///     <see cref="ContentTileDefinition.MapAtmosphere"/> set to true.
-        /// </summary>
-        public static readonly CVarDef<bool> ExplosionCanCreateVacuum =
-            CVarDef.Create("explosion.can_create_vacuum", true, CVar.SERVERONLY);
-
-        #endregion
-        #region Radiation
-        /*
-         * Radiation
-         */
-
-        /// <summary>
-        ///     What is the smallest radiation dose in rads that can be received by object.
-        ///     Extremely small values may impact performance.
-        /// </summary>
-        public static readonly CVarDef<float> RadiationMinIntensity =
-            CVarDef.Create("radiation.min_intensity", 0.1f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Rate of radiation system update in seconds.
-        /// </summary>
-        public static readonly CVarDef<float> RadiationGridcastUpdateRate =
-            CVarDef.Create("radiation.gridcast.update_rate", 1.0f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If both radiation source and receiver are placed on same grid, ignore grids between them.
-        ///     May get inaccurate result in some cases, but greatly boost performance in general.
-        /// </summary>
-        public static readonly CVarDef<bool> RadiationGridcastSimplifiedSameGrid =
-            CVarDef.Create("radiation.gridcast.simplified_same_grid", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Max distance that radiation ray can travel in meters.
-        /// </summary>
-        public static readonly CVarDef<float> RadiationGridcastMaxDistance =
-            CVarDef.Create("radiation.gridcast.max_distance", 50f, CVar.SERVERONLY);
-
-        #endregion
-        #region Admin logs
-        /*
-         * Admin logs
-         */
-
-        /// <summary>
-        ///     Controls if admin logs are enabled. Highly recommended to shut this off for development.
-        /// </summary>
-        public static readonly CVarDef<bool> AdminLogsEnabled =
-            CVarDef.Create("adminlogs.enabled", true, CVar.SERVERONLY);
-
-        public static readonly CVarDef<float> AdminLogsQueueSendDelay =
-            CVarDef.Create("adminlogs.queue_send_delay_seconds", 5f, CVar.SERVERONLY);
-
-        // When to skip the waiting time to save in-round admin logs, if no admin logs are currently being saved
-        public static readonly CVarDef<int> AdminLogsQueueMax =
-            CVarDef.Create("adminlogs.queue_max", 5000, CVar.SERVERONLY);
-
-        // When to skip the waiting time to save pre-round admin logs, if no admin logs are currently being saved
-        public static readonly CVarDef<int> AdminLogsPreRoundQueueMax =
-            CVarDef.Create("adminlogs.pre_round_queue_max", 5000, CVar.SERVERONLY);
-
-        // When to start dropping logs
-        public static readonly CVarDef<int> AdminLogsDropThreshold =
-            CVarDef.Create("adminlogs.drop_threshold", 20000, CVar.SERVERONLY);
-
-        // How many logs to send to the client at once
-        public static readonly CVarDef<int> AdminLogsClientBatchSize =
-            CVarDef.Create("adminlogs.client_batch_size", 1000, CVar.SERVERONLY);
-
-        public static readonly CVarDef<string> AdminLogsServerName =
-            CVarDef.Create("adminlogs.server_name", "unknown", CVar.SERVERONLY);
-
-        #endregion
-        #region Atmos
-        /*
-         * Atmos
-         */
-
-        /// <summary>
-        ///     Whether gas differences will move entities.
-        /// </summary>
-        public static readonly CVarDef<bool> SpaceWind =
-            CVarDef.Create("atmos.space_wind", true, CVar.SERVERONLY);
-
-        public static readonly CVarDef<float> SpaceWindStrengthMultiplier =
-            CVarDef.Create("atmos.space_wind_strength_multiplier", 1f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Divisor from maxForce (pressureDifference * 2.25f) to force applied on objects.
-        /// </summary>
-        public static readonly CVarDef<float> SpaceWindPressureForceDivisorThrow =
-            CVarDef.Create("atmos.space_wind_pressure_force_divisor_throw", 15f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Divisor from maxForce (pressureDifference * 2.25f) to force applied on objects.
-        /// </summary>
-        public static readonly CVarDef<float> SpaceWindPressureForceDivisorPush =
-            CVarDef.Create("atmos.space_wind_pressure_force_divisor_push", 2500f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The maximum velocity (not force) that may be applied to an object by atmospheric pressure differences.
-        ///     Useful to prevent clipping through objects.
-        /// </summary>
-        public static readonly CVarDef<float> SpaceWindMaxVelocity =
-            CVarDef.Create("atmos.space_wind_max_velocity", 15f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The maximum force that may be applied to an object by pushing (i.e. not throwing) atmospheric pressure differences.
-        ///     A "throwing" atmospheric pressure difference ignores this limit, but not the max. velocity limit.
-        /// </summary>
-        public static readonly CVarDef<float> SpaceWindMaxPushForce =
-            CVarDef.Create("atmos.space_wind_max_push_force", 20f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     If an object's mass is below this number, then this number is used in place of mass to determine whether air pressure can throw an object.
-        ///     This has nothing to do with throwing force, only acting as a way of reducing the odds of tiny 5 gram objects from being yeeted by people's breath
-        /// </summary>
-        /// <remarks>
-        ///     If you are reading this because you want to change it, consider looking into why almost every item in the game weighs only 5 grams
-        ///     And maybe do your part to fix that? :)
-        /// </remarks>
-        public static readonly CVarDef<float> SpaceWindMinimumCalculatedMass =
-            CVarDef.Create("atmos.space_wind_minimum_calculated_mass", 5f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// 	Calculated as 1/Mass, where Mass is the physics.Mass of the desired threshold.
-        /// 	If an object's inverse mass is lower than this, it is capped at this. Basically, an upper limit to how heavy an object can be before it stops resisting space wind more.
-        /// </summary>
-        public static readonly CVarDef<float> SpaceWindMaximumCalculatedInverseMass =
-            CVarDef.Create("atmos.space_wind_maximum_calculated_inverse_mass", 0.04f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether monstermos tile equalization is enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> MonstermosEqualization =
-            CVarDef.Create("atmos.monstermos_equalization", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether monstermos explosive depressurization is enabled.
-        ///     Needs <see cref="MonstermosEqualization"/> to be enabled to work.
-        /// </summary>
-        public static readonly CVarDef<bool> MonstermosDepressurization =
-            CVarDef.Create("atmos.monstermos_depressurization", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether monstermos explosive depressurization will rip tiles..
-        ///     Needs <see cref="MonstermosEqualization"/> and <see cref="MonstermosDepressurization"/> to be enabled to work.
-		///     WARNING: This cvar causes MAJOR contrast issues, and usually tends to make any spaced scene look very cluttered.
-		///     This not only usually looks strange, but can also reduce playability for people with impaired vision. Please think twice before enabling this on your server.
-		///     Also looks weird on slow spacing for unrelated reasons. If you do want to enable this, you should probably turn on instaspacing.
-        /// </summary>
-        public static readonly CVarDef<bool> MonstermosRipTiles =
-            CVarDef.Create("atmos.monstermos_rip_tiles", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Taken as the cube of a tile's mass, this acts as a minimum threshold of mass for which air pressure calculates whether or not to rip a tile from the floor
-        ///     This should be set by default to the cube of the game's lowest mass tile as defined in their prototypes, but can be increased for server performance reasons
-        /// </summary>
-        public static readonly CVarDef<float> MonstermosRipTilesMinimumPressure =
-            CVarDef.Create("atmos.monstermos_rip_tiles_min_pressure", 20f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether explosive depressurization will cause the grid to gain an impulse.
-        ///     Needs <see cref="MonstermosEqualization"/> and <see cref="MonstermosDepressurization"/> to be enabled to work.
-        /// </summary>
-        public static readonly CVarDef<bool> AtmosGridImpulse =
-            CVarDef.Create("atmos.grid_impulse", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     What fraction of air from a spaced tile escapes every tick.
-        ///     1.0 for instant spacing, 0.2 means 20% of remaining air lost each time
-        /// </summary>
-        public static readonly CVarDef<float> AtmosSpacingEscapeRatio =
-            CVarDef.Create("atmos.mmos_spacing_speed", 0.05f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Minimum amount of air allowed on a spaced tile before it is reset to 0 immediately in kPa
-        ///     Since the decay due to SpacingEscapeRatio follows a curve, it would never reach 0.0 exactly
-        ///     unless we truncate it somewhere.
-        /// </summary>
-        public static readonly CVarDef<float> AtmosSpacingMinGas =
-            CVarDef.Create("atmos.mmos_min_gas", 2.0f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     How much wind can go through a single tile before that tile doesn't depressurize itself
-        ///     (I.e spacing is limited in large rooms heading into smaller spaces)
-        /// </summary>
-        public static readonly CVarDef<float> AtmosSpacingMaxWind =
-            CVarDef.Create("atmos.mmos_max_wind", 500f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Increases default airflow calculations to O(n^2) complexity, for use with heavy space wind optimizations. Potato servers BEWARE
-        /// This solves the problem of objects being trapped in an infinite loop of slamming into a wall repeatedly.
-        /// </summary>
-        public static readonly CVarDef<bool> MonstermosUseExpensiveAirflow =
-            CVarDef.Create("atmos.mmos_expensive_airflow", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether atmos superconduction is enabled.
-        /// </summary>
-        /// <remarks> Disabled by default, superconduction is awful. </remarks>
-        public static readonly CVarDef<bool> Superconduction =
-            CVarDef.Create("atmos.superconduction", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Heat loss per tile due to radiation at 20 degC, in W.
-        /// </summary>
-        public static readonly CVarDef<float> SuperconductionTileLoss =
-            CVarDef.Create("atmos.superconduction_tile_loss", 30f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether excited groups will be processed and created.
-        /// </summary>
-        public static readonly CVarDef<bool> ExcitedGroups =
-            CVarDef.Create("atmos.excited_groups", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether all tiles in an excited group will clear themselves once being exposed to space.
-        ///     Similar to <see cref="MonstermosDepressurization"/>, without none of the tile ripping or
-        ///     things being thrown around very violently.
-        ///     Needs <see cref="ExcitedGroups"/> to be enabled to work.
-        /// </summary>
-        public static readonly CVarDef<bool> ExcitedGroupsSpaceIsAllConsuming =
-            CVarDef.Create("atmos.excited_groups_space_is_all_consuming", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Maximum time in milliseconds that atmos can take processing.
-        /// </summary>
-        public static readonly CVarDef<float> AtmosMaxProcessTime =
-            CVarDef.Create("atmos.max_process_time", 3f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Atmos tickrate in TPS. Atmos processing will happen every 1/TPS seconds.
-        /// </summary>
-        public static readonly CVarDef<float> AtmosTickRate =
-            CVarDef.Create("atmos.tickrate", 15f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Scale factor for how fast things happen in our atmosphere
-        ///     simulation compared to real life. 1x means pumps run at 1x
-        ///     speed. Players typically expect things to happen faster
-        ///     in-game.
-        /// </summary>
-        public static readonly CVarDef<float> AtmosSpeedup =
-            CVarDef.Create("atmos.speedup", 8f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Like atmos.speedup, but only for gas and reaction heat values. 64x means
-        ///     gases heat up and cool down 64x faster than real life.
-        /// </summary>
-        public static readonly CVarDef<float> AtmosHeatScale =
-            CVarDef.Create("atmos.heat_scale", 8f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     A multiplier on the amount of force applied to Humanoid entities, as tracked by HumanoidAppearanceComponent
-        ///     This multiplier is added after all other checks are made, and applies to both throwing force, and how easy it is for an entity to be thrown.
-        /// </summary>
-        public static readonly CVarDef<float> AtmosHumanoidThrowMultiplier =
-            CVarDef.Create("atmos.humanoid_throw_multiplier", 2f, CVar.SERVERONLY);
-
-        #endregion
-        #region MIDI instruments
-        /*
-         * MIDI instruments
-         */
-
-        public static readonly CVarDef<int> MaxMidiEventsPerSecond =
-            CVarDef.Create("midi.max_events_per_second", 1000, CVar.REPLICATED | CVar.SERVER);
-
-        public static readonly CVarDef<int> MaxMidiEventsPerBatch =
-            CVarDef.Create("midi.max_events_per_batch", 60, CVar.REPLICATED | CVar.SERVER);
-
-        public static readonly CVarDef<int> MaxMidiBatchesDropped =
-            CVarDef.Create("midi.max_batches_dropped", 1, CVar.SERVERONLY);
-
-        public static readonly CVarDef<int> MaxMidiLaggedBatches =
-            CVarDef.Create("midi.max_lagged_batches", 8, CVar.SERVERONLY);
-
-        #endregion
-        #region Holidays
-        /*
-         * Holidays
-         */
-
-        public static readonly CVarDef<bool> HolidaysEnabled = CVarDef.Create("holidays.enabled", true, CVar.SERVERONLY);
-
-        #endregion
-        #region Branding stuff
-        /*
-         * Branding stuff
-         */
-
-        public static readonly CVarDef<bool> BrandingSteam = CVarDef.Create("branding.steam", false, CVar.CLIENTONLY);
-
-        #endregion
-        #region OOC
-        /*
-         * OOC
-         */
-
-        public static readonly CVarDef<bool> OocEnabled = CVarDef.Create("ooc.enabled", true, CVar.NOTIFY | CVar.REPLICATED);
-
-        public static readonly CVarDef<bool> AdminOocEnabled =
-            CVarDef.Create("ooc.enabled_admin", true, CVar.NOTIFY);
-
-        /// <summary>
-        /// If true, whenever OOC is disabled the Discord OOC relay will also be disabled.
-        /// </summary>
-        public static readonly CVarDef<bool> DisablingOOCDisablesRelay = CVarDef.Create("ooc.disabling_ooc_disables_relay", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether or not OOC chat should be enabled during a round.
-        /// </summary>
-        public static readonly CVarDef<bool> OocEnableDuringRound =
-            CVarDef.Create("ooc.enable_during_round", false, CVar.NOTIFY | CVar.REPLICATED | CVar.SERVER);
-
-        public static readonly CVarDef<bool> ShowOocPatronColor =
-            CVarDef.Create("ooc.show_ooc_patron_color", true, CVar.ARCHIVE | CVar.REPLICATED | CVar.CLIENT);
-
-        #endregion
-        #region LOOC
-        /*
-         * LOOC
-         */
+namespace Content.Shared.CCVar;
 
-        public static readonly CVarDef<bool> LoocEnabled = CVarDef.Create("looc.enabled", true, CVar.NOTIFY | CVar.REPLICATED);
-
-        public static readonly CVarDef<bool> AdminLoocEnabled =
-            CVarDef.Create("looc.enabled_admin", true, CVar.NOTIFY);
-
-        /// <summary>
-        /// True: Dead players can use LOOC
-        /// False: Dead player LOOC gets redirected to dead chat
-        /// </summary>
-        public static readonly CVarDef<bool> DeadLoocEnabled = CVarDef.Create("looc.enabled_dead", false, CVar.NOTIFY | CVar.REPLICATED);
-
-        /// <summary>
-        /// True: Crit players can use LOOC
-        /// False: Crit player LOOC gets redirected to dead chat
-        /// </summary>
-        public static readonly CVarDef<bool> CritLoocEnabled = CVarDef.Create("looc.enabled_crit", false, CVar.NOTIFY | CVar.REPLICATED);
-
-        #endregion
-        #region Entity Menu Grouping Types
-        /*
-         * Entity Menu Grouping Types
-         */
-        public static readonly CVarDef<int> EntityMenuGroupingType = CVarDef.Create("entity_menu", 0, CVar.CLIENTONLY);
-
-        #endregion
-        #region Whitelist
-        /*
-         * Whitelist
-         */
-
-        /// <summary>
-        ///     Controls whether the server will deny any players that are not whitelisted in the DB.
-        /// </summary>
-        public static readonly CVarDef<bool> WhitelistEnabled =
-            CVarDef.Create("whitelist.enabled", false, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Specifies the whitelist prototypes to be used by the server. This should be a comma-separated list of prototypes.
-        ///     If a whitelists conditions to be active fail (for example player count), the next whitelist will be used instead. If no whitelist is valid, the player will be allowed to connect.
-        /// </summary>
-        public static readonly CVarDef<string> WhitelistPrototypeList =
-            CVarDef.Create("whitelist.prototype_list", "basicWhitelist", CVar.SERVERONLY);
-
-        #endregion
-        #region VOTE
-        /*
-         * VOTE
-         */
-
-        /// <summary>
-        ///     Allows enabling/disabling player-started votes for ultimate authority
-        /// </summary>
-        public static readonly CVarDef<bool> VoteEnabled =
-            CVarDef.Create("vote.enabled", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     See vote.enabled, but specific to restart votes
-        /// </summary>
-        public static readonly CVarDef<bool> VoteRestartEnabled =
-            CVarDef.Create("vote.restart_enabled", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Config for when the restart vote should be allowed to be called regardless with less than this amount of players.
-        /// </summary>
-        public static readonly CVarDef<int> VoteRestartMaxPlayers =
-            CVarDef.Create("vote.restart_max_players", 20, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Config for when the restart vote should be allowed to be called based on percentage of ghosts.
-        ///
-        public static readonly CVarDef<int> VoteRestartGhostPercentage =
-            CVarDef.Create("vote.restart_ghost_percentage", 75, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     See vote.enabled, but specific to preset votes
-        /// </summary>
-        public static readonly CVarDef<bool> VotePresetEnabled =
-            CVarDef.Create("vote.preset_enabled", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     See vote.enabled, but specific to map votes
-        /// </summary>
-        public static readonly CVarDef<bool> VoteMapEnabled =
-            CVarDef.Create("vote.map_enabled", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The required ratio of the server that must agree for a restart round vote to go through.
-        /// </summary>
-        public static readonly CVarDef<float> VoteRestartRequiredRatio =
-            CVarDef.Create("vote.restart_required_ratio", 0.85f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether or not to prevent the restart vote from having any effect when there is an online admin
-        /// </summary>
-        public static readonly CVarDef<bool> VoteRestartNotAllowedWhenAdminOnline =
-            CVarDef.Create("vote.restart_not_allowed_when_admin_online", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The delay which two votes of the same type are allowed to be made by separate people, in seconds.
-        /// </summary>
-        public static readonly CVarDef<float> VoteSameTypeTimeout =
-            CVarDef.Create("vote.same_type_timeout", 240f, CVar.SERVERONLY);
-
-
-        /// <summary>
-        ///     Sets the duration of the map vote timer.
-        /// </summary>
-        public static readonly CVarDef<int>
-            VoteTimerMap = CVarDef.Create("vote.timermap", 90, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Sets the duration of the restart vote timer.
-        /// </summary>
-        public static readonly CVarDef<int>
-            VoteTimerRestart = CVarDef.Create("vote.timerrestart", 60, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Sets the duration of the gamemode/preset vote timer.
-        /// </summary>
-        public static readonly CVarDef<int>
-            VoteTimerPreset = CVarDef.Create("vote.timerpreset", 30, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Sets the duration of the map vote timer when ALONE.
-        /// </summary>
-        public static readonly CVarDef<int>
-            VoteTimerAlone = CVarDef.Create("vote.timeralone", 10, CVar.SERVERONLY);
-
-
-        #endregion
-        #region BAN
-        /*
-         * BAN
-         */
-
-        public static readonly CVarDef<bool> BanHardwareIds =
-            CVarDef.Create("ban.hardware_ids", true, CVar.SERVERONLY);
-
-        #endregion
-        #region Procgen
-        /*
-         * Procgen
-         */
-
-        /// <summary>
-        /// Should we pre-load all of the procgen atlasses.
-        /// </summary>
-        public static readonly CVarDef<bool> ProcgenPreload =
-            CVarDef.Create("procgen.preload", true, CVar.SERVERONLY);
-
-        #endregion
-        #region Shuttles
-        /*
-         * Shuttles
-         */
-
-        // Look this is technically eye behavior but its main impact is shuttles so I just dumped it here.
-        /// <summary>
-        /// If true then the camera will match the grid / map and is unchangeable.
-        /// - When traversing grids it will snap to 0 degrees rotation.
-        /// False means the player has control over the camera rotation.
-        /// - When traversing grids it will snap to the nearest cardinal which will generally be imperceptible.
-        /// </summary>
-        public static readonly CVarDef<bool> CameraRotationLocked =
-            CVarDef.Create("shuttle.camera_rotation_locked", false, CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether the arrivals terminal should be on a planet map.
-        /// </summary>
-        public static readonly CVarDef<bool> ArrivalsPlanet =
-            CVarDef.Create("shuttle.arrivals_planet", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether the arrivals shuttle is enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> ArrivalsShuttles =
-            CVarDef.Create("shuttle.arrivals", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The map to use for the arrivals station.
-        /// </summary>
-        public static readonly CVarDef<string> ArrivalsMap =
-            CVarDef.Create("shuttle.arrivals_map", "/Maps/Misc/terminal.yml", CVar.SERVERONLY);
-
-        /// <summary>
-        /// Cooldown between arrivals departures. This should be longer than the FTL time or it will double cycle.
-        /// </summary>
-        public static readonly CVarDef<float> ArrivalsCooldown =
-            CVarDef.Create("shuttle.arrivals_cooldown", 50f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Time it takes the shuttle to spin up it's hyper drive and jump
-        /// </summary>
-        public static readonly CVarDef<float> ArrivalsStartupTime=
-            CVarDef.Create("shuttle.arrivals_startup_time", 5.5f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Time spent in hyperspace
-        /// </summary>
-        public static readonly CVarDef<float> ArrivalsHyperspaceTime =
-            CVarDef.Create("shuttle.arrivals_hyperspace_time", 20f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Are players allowed to return on the arrivals shuttle.
-        /// </summary>
-        public static readonly CVarDef<bool> ArrivalsReturns =
-            CVarDef.Create("shuttle.arrivals_returns", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Should all players who spawn at arrivals have godmode until they leave the map?
-        /// </summary>
-        public static readonly CVarDef<bool> GodmodeArrivals =
-            CVarDef.Create("shuttle.godmode_arrivals", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// If a grid is split then hide any smaller ones under this mass (kg) from the map.
-        /// This is useful to avoid split grids spamming out labels.
-        /// </summary>
-        public static readonly CVarDef<int> HideSplitGridsUnder =
-            CVarDef.Create("shuttle.hide_split_grids_under", 30, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether to automatically spawn escape shuttles.
-        /// </summary>
-        public static readonly CVarDef<bool> GridFill =
-            CVarDef.Create("shuttle.grid_fill", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether to automatically preloading grids by GridPreloaderSystem
-        /// </summary>
-        public static readonly CVarDef<bool> PreloadGrids =
-            CVarDef.Create("shuttle.preload_grids", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How long the warmup time before FTL start should be.
-        /// </summary>
-        public static readonly CVarDef<float> FTLStartupTime =
-            CVarDef.Create("shuttle.startup_time", 5.5f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How long a shuttle spends in FTL.
-        /// </summary>
-        public static readonly CVarDef<float> FTLTravelTime =
-            CVarDef.Create("shuttle.travel_time", 20f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How long the final stage of FTL before arrival should be.
-        /// </summary>
-        public static readonly CVarDef<float> FTLArrivalTime =
-            CVarDef.Create("shuttle.arrival_time", 5f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How much time needs to pass before a shuttle can FTL again.
-        /// </summary>
-        public static readonly CVarDef<float> FTLCooldown =
-            CVarDef.Create("shuttle.cooldown", 10f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The maximum <see cref="PhysicsComponent.Mass"/> a grid can have before it becomes unable to FTL.
-        /// Any value equal to or less than zero will disable this check.
-        /// </summary>
-        public static readonly CVarDef<float> FTLMassLimit =
-            CVarDef.Create("shuttle.mass_limit", 300f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How long to knock down entities for if they aren't buckled when FTL starts and stops.
-        /// </summary>
-        public static readonly CVarDef<float> HyperspaceKnockdownTime =
-            CVarDef.Create("shuttle.hyperspace_knockdown_time", 5f, CVar.SERVERONLY);
-
-        ///<summary>
-        /// the Entropic decay of energy combined with the minimal but existent particles that would slow the vessel down
-        ///</summary>
-        public static readonly CVarDef<float> SpaceFrictionStrength =
-            CVarDef.Create("shuttle.space_friction_strength", 0.0015f, CVar.REPLICATED);
-
-        ///<summary>
-        /// the strength of drag when the inertia dampeners are set to anchor to slow the vessel down and hold it in place
-        ///</summary>
-        public static readonly CVarDef<float> AnchorDampeningStrength =
-            CVarDef.Create("shuttle.ancho_dampening_strength", 0.5f, CVar.REPLICATED);
-        #endregion
-        #region Emergency
-        /*
-         * Emergency
-         */
-
-        /// <summary>
-        /// Is the emergency shuttle allowed to be early launched.
-        /// </summary>
-        public static readonly CVarDef<bool> EmergencyEarlyLaunchAllowed =
-            CVarDef.Create("shuttle.emergency_early_launch_allowed", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How long the emergency shuttle remains docked with the station, in seconds.
-        /// </summary>
-        public static readonly CVarDef<float> EmergencyShuttleDockTime =
-            CVarDef.Create("shuttle.emergency_dock_time", 240f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How long after the console is authorized for the shuttle to early launch.
-        /// </summary>
-        public static readonly CVarDef<float> EmergencyShuttleAuthorizeTime =
-            CVarDef.Create("shuttle.emergency_authorize_time", 10f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The minimum time for the emergency shuttle to arrive at centcomm.
-        /// Actual minimum travel time cannot be less than <see cref="ShuttleSystem.DefaultArrivalTime"/>
-        /// </summary>
-        public static readonly CVarDef<float> EmergencyShuttleMinTransitTime =
-            CVarDef.Create("shuttle.emergency_transit_time_min", 90f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The maximum time for the emergency shuttle to arrive at centcomm.
-        /// </summary>
-        public static readonly CVarDef<float> EmergencyShuttleMaxTransitTime =
-            CVarDef.Create("shuttle.emergency_transit_time_max", 180f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether the emergency shuttle is enabled or should the round just end.
-        /// </summary>
-        public static readonly CVarDef<bool> EmergencyShuttleEnabled =
-            CVarDef.Create("shuttle.emergency", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The percentage of time passed from the initial call to when the shuttle can no longer be recalled.
-        ///     ex. a call time of 10min and turning point of 0.5 means the shuttle cannot be recalled after 5 minutes.
-        /// </summary>
-        public static readonly CVarDef<float> EmergencyRecallTurningPoint =
-            CVarDef.Create("shuttle.recall_turning_point", 0.5f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Time in minutes after round start to auto-call the shuttle. Set to zero to disable.
-        /// </summary>
-        public static readonly CVarDef<int> EmergencyShuttleAutoCallTime =
-            CVarDef.Create("shuttle.auto_call_time", 120, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Time in minutes after the round was extended (by recalling the shuttle) to call
-        ///     the shuttle again.
-        /// </summary>
-        public static readonly CVarDef<int> EmergencyShuttleAutoCallExtensionTime =
-            CVarDef.Create("shuttle.auto_call_extension_time", 30, CVar.SERVERONLY);
-
-        #endregion
-        #region Crew Manifests
-        /*
-         * Crew Manifests
-         */
-
-        /// <summary>
-        ///     Setting this allows a crew manifest to be opened from any window
-        ///     that has a crew manifest button, and sends the correct message.
-        ///     If this is false, only in-game entities will allow you to see
-        ///     the crew manifest, if the functionality is coded in.
-        ///     Having administrator priveledge ignores this, but will still
-        ///     hide the button in UI windows.
-        /// </summary>
-        public static readonly CVarDef<bool> CrewManifestWithoutEntity =
-            CVarDef.Create("crewmanifest.no_entity", true, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Setting this allows the crew manifest to be viewed from 'unsecure'
-        ///     entities, such as the PDA.
-        /// </summary>
-        public static readonly CVarDef<bool> CrewManifestUnsecure =
-            CVarDef.Create("crewmanifest.unsecure", true, CVar.REPLICATED);
-
-        #endregion
-        #region Cloning
-
-        /*
-         * Cloning
-         */
-        /// <summary>
-        ///     How much should the cost to clone an entity be multiplied by.
-        /// </summary>
-        public static readonly CVarDef<float> CloningBiomassCostMultiplier =
-            CVarDef.Create("cloning.biomass_cost_multiplier", 1f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether or not the Biomass Reclaimer is allowed to roundremove bodies with a soul.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningReclaimSouledBodies =
-            CVarDef.Create("cloning.reclaim_souled_bodies", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis will potentially give people a sex change.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveSex =
-            CVarDef.Create("cloning.preserve_sex", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis preserves Pronouns when reincarnating people.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveGender =
-            CVarDef.Create("cloning.preserve_gender", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis preserves Age.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveAge =
-            CVarDef.Create("cloning.preserve_age", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis preserves height.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveHeight =
-            CVarDef.Create("cloning.preserve_height", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis preserves width.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveWidth =
-            CVarDef.Create("cloning.preserve_width", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis preserves Names. EG: Are you actually a new person?
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveName =
-            CVarDef.Create("cloning.preserve_name", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Controls whether or not Metempsychosis preserves Flavor Text.
-        /// </summary>
-        public static readonly CVarDef<bool> CloningPreserveFlavorText =
-            CVarDef.Create("cloning.preserve_flavor_text", true, CVar.SERVERONLY);
-
-        #endregion
-        #region Anomaly
-        /*
-         * Anomaly
-         */
-
-        /// <summary>
-        ///     A scale factor applied to a grid's bounds when trying to find a spot to randomly generate an anomaly.
-        /// </summary>
-        public static readonly CVarDef<float> AnomalyGenerationGridBoundsScale =
-            CVarDef.Create("anomaly.generation_grid_bounds_scale", 0.6f, CVar.SERVERONLY);
-
-        #endregion
-        #region VIEWPORT
-        /*
-         * VIEWPORT
-         */
-
-        public static readonly CVarDef<bool> ViewportStretch =
-            CVarDef.Create("viewport.stretch", true, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<int> ViewportFixedScaleFactor =
-            CVarDef.Create("viewport.fixed_scale_factor", 2, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        // This default is basically specifically chosen so fullscreen/maximized 1080p hits a 2x snap and does NN.
-        public static readonly CVarDef<int> ViewportSnapToleranceMargin =
-            CVarDef.Create("viewport.snap_tolerance_margin", 64, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<int> ViewportSnapToleranceClip =
-            CVarDef.Create("viewport.snap_tolerance_clip", 32, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<bool> ViewportScaleRender =
-            CVarDef.Create("viewport.scale_render", true, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<int> ViewportMinimumWidth =
-            CVarDef.Create("viewport.minimum_width", 15, CVar.REPLICATED);
-
-        public static readonly CVarDef<int> ViewportMaximumWidth =
-            CVarDef.Create("viewport.maximum_width", 21, CVar.REPLICATED);
-
-        public static readonly CVarDef<int> ViewportWidth =
-            CVarDef.Create("viewport.width", 21, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<bool> ViewportVerticalFit =
-            CVarDef.Create("viewport.vertical_fit", true, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        #endregion
-        #region FOV
-        /*
-         * FOV
-         */
-
-        /// <summary>
-        ///     The number by which the current FOV size is divided for each level.
-        /// </summary>
-        public static readonly CVarDef<float> ZoomLevelStep =
-            CVarDef.Create("fov.zoom_step", 1.2f, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        ///     How many times the player can zoom in until they reach the minimum zoom.
-        ///     This does not affect the maximum zoom.
-        /// </summary>
-        public static readonly CVarDef<int> ZoomLevels =
-            CVarDef.Create("fov.zoom_levels", 7, CVar.SERVER | CVar.REPLICATED);
-
-        #endregion
-        #region UI
-        /*
-         * UI
-         */
-
-        public static readonly CVarDef<string> UILayout =
-            CVarDef.Create("ui.layout", "Separated", CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<string> OverlayScreenChatSize =
-            CVarDef.Create("ui.overlay_chat_size", "", CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<string> SeparatedScreenChatSize =
-            CVarDef.Create("ui.separated_chat_size", "0.6,0", CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        #endregion
-        #region Accessibility
-
-        /*
-        * Accessibility
-        */
-
-        /// <summary>
-        /// Chat window opacity slider, controlling the alpha of the chat window background.
-        /// Goes from to 0 (completely transparent) to 1 (completely opaque)
-        /// </summary>
-        public static readonly CVarDef<float> ChatWindowOpacity =
-            CVarDef.Create("accessibility.chat_window_transparency", 0.85f, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// Toggle for visual effects that may potentially cause motion sickness.
-        /// Where reasonable, effects affected by this CVar should use an alternate effect.
-        /// Please do not use this CVar as a bandaid for effects that could otherwise be made accessible without issue.
-        /// </summary>
-        public static readonly CVarDef<bool> ReducedMotion =
-            CVarDef.Create("accessibility.reduced_motion", false, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        public static readonly CVarDef<bool> ChatEnableColorName =
-            CVarDef.Create("accessibility.enable_color_name", true, CVar.CLIENTONLY | CVar.ARCHIVE, "Toggles displaying names with individual colors.");
-
-        /// <summary>
-        /// Screen shake intensity slider, controlling the intensity of the CameraRecoilSystem.
-        /// Goes from 0 (no recoil at all) to 1 (regular amounts of recoil)
-        /// </summary>
-        public static readonly CVarDef<float> ScreenShakeIntensity =
-            CVarDef.Create("accessibility.screen_shake_intensity", 1f, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// A generic toggle for various visual effects that are color sensitive.
-        /// As of 2/16/24, only applies to progress bar colors.
-        /// </summary>
-        public static readonly CVarDef<bool> AccessibilityColorblindFriendly =
-            CVarDef.Create("accessibility.colorblind_friendly", false, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// Disables all vision filters for species like Vulpkanin or Harpies. There are good reasons someone might want to disable these.
-        /// </summary>
-        public static readonly CVarDef<bool> NoVisionFilters =
-            CVarDef.Create("accessibility.no_vision_filters", true, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        #endregion
-        #region CHAT
-        /*
-         * CHAT
-         */
-
-        /// <summary>
-        /// Chat rate limit values are accounted in periods of this size (seconds).
-        /// After the period has passed, the count resets.
-        /// </summary>
-        /// <seealso cref="ChatRateLimitCount"/>
-        public static readonly CVarDef<float> ChatRateLimitPeriod =
-            CVarDef.Create("chat.rate_limit_period", 2f, CVar.SERVERONLY);
-
-        /// <summary>
-        /// How many chat messages are allowed in a single rate limit period.
-        /// </summary>
-        /// <remarks>
-        /// The total rate limit throughput per second is effectively
-        /// <see cref="ChatRateLimitCount"/> divided by <see cref="ChatRateLimitCount"/>.
-        /// </remarks>
-        /// <seealso cref="ChatRateLimitPeriod"/>
-        public static readonly CVarDef<int> ChatRateLimitCount =
-            CVarDef.Create("chat.rate_limit_count", 10, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Minimum delay (in seconds) between notifying admins about chat message rate limit violations.
-        /// A negative value disables admin announcements.
-        /// </summary>
-        public static readonly CVarDef<int> ChatRateLimitAnnounceAdminsDelay =
-            CVarDef.Create("chat.rate_limit_announce_admins_delay", 15, CVar.SERVERONLY);
-
-        public static readonly CVarDef<int> ChatMaxMessageLength =
-            CVarDef.Create("chat.max_message_length", 1000, CVar.SERVER | CVar.REPLICATED);
-
-        public static readonly CVarDef<int> ChatMaxAnnouncementLength =
-            CVarDef.Create("chat.max_announcement_length", 256, CVar.SERVER | CVar.REPLICATED);
-
-        public static readonly CVarDef<bool> ChatSanitizerEnabled =
-            CVarDef.Create("chat.chat_sanitizer_enabled", true, CVar.SERVERONLY);
-
-        public static readonly CVarDef<bool> ChatShowTypingIndicator =
-            CVarDef.Create("chat.show_typing_indicator", true, CVar.CLIENTONLY);
-
-        public static readonly CVarDef<bool> ChatEnableFancyBubbles =
-            CVarDef.Create("chat.enable_fancy_bubbles", true, CVar.CLIENTONLY | CVar.ARCHIVE, "Toggles displaying fancy speech bubbles, which display the speaking character's name.");
-
-        public static readonly CVarDef<bool> ChatFancyNameBackground =
-            CVarDef.Create("chat.fancy_name_background", false, CVar.CLIENTONLY | CVar.ARCHIVE, "Toggles displaying a background under the speaking character's name.");
-
-        public static readonly CVarDef<int> ChatStackLastLines =
-            CVarDef.Create("chat.chatstack_last_lines", 1, CVar.CLIENTONLY | CVar.ARCHIVE, "How far into the chat history to look when looking for similiar messages to coalesce them.");
-
-        /// <summary>
-        /// A message broadcast to each player that joins the lobby.
-        /// May be changed by admins ingame through use of the "set-motd" command.
-        /// In this case the new value, if not empty, is broadcast to all connected players and saved between rounds.
-        /// May be requested by any player through use of the "get-motd" command.
-        /// </summary>
-        public static readonly CVarDef<string> MOTD =
-            CVarDef.Create("chat.motd", "", CVar.SERVER | CVar.SERVERONLY | CVar.ARCHIVE, "A message broadcast to each player that joins the lobby.");
-
-        #endregion
-        #region AFK
-        /*
-         * AFK
-         */
-
-        /// <summary>
-        /// How long a client can go without any input before being considered AFK.
-        /// </summary>
-        public static readonly CVarDef<float> AfkTime =
-            CVarDef.Create("afk.time", 60f, CVar.SERVERONLY);
-
-        #endregion
-        #region IC
-        /*
-         * IC
-         */
-
-        /// <summary>
-        /// Restricts IC character names to alphanumeric chars.
-        /// </summary>
-        public static readonly CVarDef<bool> RestrictedNames =
-            CVarDef.Create("ic.restricted_names", true, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Allows flavor text (character descriptions)
-        /// </summary>
-        public static readonly CVarDef<bool> FlavorText =
-            CVarDef.Create("ic.flavor_text", true, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Adds a period at the end of a sentence if the sentence ends in a letter.
-        /// </summary>
-        public static readonly CVarDef<bool> ChatPunctuation =
-            CVarDef.Create("ic.punctuation", true, CVar.SERVER);
-
-        /// <summary>
-        /// Enables automatically forcing IC name rules. Uppercases the first letter of the first and last words of the name
-        /// </summary>
-        public static readonly CVarDef<bool> ICNameCase =
-            CVarDef.Create("ic.name_case", true, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Whether or not players' characters are randomly generated rather than using their selected characters in the creator.
-        /// </summary>
-        public static readonly CVarDef<bool> ICRandomCharacters =
-            CVarDef.Create("ic.random_characters", false, CVar.SERVER);
-
-        /// <summary>
-        /// A weighted random prototype used to determine the species selected for random characters.
-        /// </summary>
-        public static readonly CVarDef<string> ICRandomSpeciesWeights =
-            CVarDef.Create("ic.random_species_weights", "SpeciesWeights", CVar.SERVER);
-
-        /// <summary>
-        /// Control displaying SSD indicators near players
-        /// </summary>
-        public static readonly CVarDef<bool> ICShowSSDIndicator =
-            CVarDef.Create("ic.show_ssd_indicator", true, CVar.CLIENTONLY);
-
-        /// <summary>
-        /// Allow Ethereal Ent to PassThrough Walls/Objects while in Ethereal.
-        /// </summary>
-        public static readonly CVarDef<bool> EtherealPassThrough =
-            CVarDef.Create("ic.EtherealPassThrough", false, CVar.SERVER);
-
-        #endregion
-        #region Salvage
-        /*
-         * Salvage
-         */
-
-        /// <summary>
-        /// Duration for missions
-        /// </summary>
-        public static readonly CVarDef<float>
-            SalvageExpeditionDuration = CVarDef.Create("salvage.expedition_duration", 660f, CVar.REPLICATED);
-
-        /// <summary>
-        /// Cooldown for missions.
-        /// </summary>
-        public static readonly CVarDef<float>
-            SalvageExpeditionCooldown = CVarDef.Create("salvage.expedition_cooldown", 780f, CVar.REPLICATED);
-
-        #endregion
-        #region Flavor
-        /*
-         * Flavor
-         */
-
-        /// <summary>
-        ///     Flavor limit. This is to ensure that having a large mass of flavors in
-        ///     some food object won't spam a user with flavors.
-        /// </summary>
-        public static readonly CVarDef<int>
-            FlavorLimit = CVarDef.Create("flavor.limit", 10, CVar.SERVERONLY);
-
-        #endregion
-        #region Mapping
-        /*
-         * Mapping
-         */
-
-        /// <summary>
-        ///     Will mapping mode enable autosaves when it's activated?
-        /// </summary>
-        public static readonly CVarDef<bool>
-            AutosaveEnabled = CVarDef.Create("mapping.autosave", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Autosave interval in seconds.
-        /// </summary>
-        public static readonly CVarDef<float>
-            AutosaveInterval = CVarDef.Create("mapping.autosave_interval", 600f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Directory in server user data to save to. Saves will be inside folders in this directory.
-        /// </summary>
-        public static readonly CVarDef<string>
-            AutosaveDirectory = CVarDef.Create("mapping.autosave_dir", "Autosaves", CVar.SERVERONLY);
-
-
-        #endregion
-        #region Rules
-        /*
-         * Rules
-         */
-
-        /// <summary>
-        ///     Time that players have to wait before rules can be accepted.
-        /// </summary>
-        public static readonly CVarDef<float> RulesWaitTime =
-            CVarDef.Create("rules.time", 10f, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        ///     Don't show rules to localhost/loopback interface.
-        /// </summary>
-        public static readonly CVarDef<bool> RulesExemptLocal =
-            CVarDef.Create("rules.exempt_local", false, CVar.SERVERONLY);
-
-
-        #endregion
-        #region Autogeneration
-        /*
-         * Autogeneration
-         */
-
-        public static readonly CVarDef<string> DestinationFile =
-            CVarDef.Create("autogen.destination_file", "", CVar.SERVER | CVar.SERVERONLY);
-
-        #endregion
-        #region Network Resource Manager
-        /*
-         * Network Resource Manager
-         */
-
-        /// <summary>
-        /// Whether uploaded files will be stored in the server's database.
-        /// This is useful to keep "logs" on what files admins have uploaded in the past.
-        /// </summary>
-        public static readonly CVarDef<bool> ResourceUploadingStoreEnabled =
-            CVarDef.Create("netres.store_enabled", true, CVar.SERVER | CVar.SERVERONLY);
-
-        /// <summary>
-        /// Numbers of days before stored uploaded files are deleted. Set to zero or negative to disable auto-delete.
-        /// This is useful to free some space automatically. Auto-deletion runs only on server boot.
-        /// </summary>
-        public static readonly CVarDef<int> ResourceUploadingStoreDeletionDays =
-            CVarDef.Create("netres.store_deletion_days", 30, CVar.SERVER | CVar.SERVERONLY);
-
-        #endregion
-        #region Controls
-        /*
-         * Controls
-         */
-
-        /// <summary>
-        /// Deadzone for drag-drop interactions.
-        /// </summary>
-        public static readonly CVarDef<float> DragDropDeadZone =
-            CVarDef.Create("control.drag_dead_zone", 12f, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// Toggles whether the walking key is a toggle or a held key.
-        /// </summary>
-        public static readonly CVarDef<bool> ToggleWalk =
-            CVarDef.Create("control.toggle_walk", false, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// Whether the player mob is walking by default instead of running.
-        /// </summary>
-        public static readonly CVarDef<bool> DefaultWalk =
-            CVarDef.Create("control.default_walk", true, CVar.CLIENT | CVar.REPLICATED | CVar.ARCHIVE);
-        #endregion
-        #region Interactions
-        /*
-         * Interactions
-         */
-
-        // The rationale behind the default limit is simply that I can easily get to 7 interactions per second by just
-        // trying to spam toggle a light switch or lever (though the UseDelay component limits the actual effect of the
-        // interaction).  I don't want to accidentally spam admins with alerts just because somebody is spamming a
-        // key manually, nor do we want to alert them just because the player is having network issues and the server
-        // receives multiple interactions at once. But we also want to try catch people with modified clients that spam
-        // many interactions on the same tick. Hence, a very short period, with a relatively high count.
-
-        /// <summary>
-        /// Maximum number of interactions that a player can perform within <see cref="InteractionRateLimitCount"/> seconds
-        /// </summary>
-        public static readonly CVarDef<int> InteractionRateLimitCount =
-            CVarDef.Create("interaction.rate_limit_count", 5, CVar.SERVER | CVar.REPLICATED);
-
-        /// <seealso cref="InteractionRateLimitCount"/>
-        public static readonly CVarDef<float> InteractionRateLimitPeriod =
-            CVarDef.Create("interaction.rate_limit_period", 0.5f, CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Minimum delay (in seconds) between notifying admins about interaction rate limit violations. A negative
-        /// value disables admin announcements.
-        /// </summary>
-        public static readonly CVarDef<int> InteractionRateLimitAnnounceAdminsDelay =
-            CVarDef.Create("interaction.rate_limit_announce_admins_delay", 120, CVar.SERVERONLY);
-
-        #endregion
-        #region STORAGE
-        /*
-         * STORAGE
-         */
-
-        /// <summary>
-        /// Whether or not the storage UI is static and bound to the hotbar, or unbound and allowed to be dragged anywhere.
-        /// </summary>
-        public static readonly CVarDef<bool> StaticStorageUI =
-            CVarDef.Create("control.static_storage_ui", true, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        /// <summary>
-        /// Whether or not the storage window uses a transparent or opaque sprite.
-        /// </summary>
-        public static readonly CVarDef<bool> OpaqueStorageWindow =
-            CVarDef.Create("control.opaque_storage_background", false, CVar.CLIENTONLY | CVar.ARCHIVE);
-
-        #endregion
-        #region UPDATE
-        /*
-         * UPDATE
-         */
-
-        /// <summary>
-        /// If a server update restart is pending, the delay after the last player leaves before we actually restart. In seconds.
-        /// </summary>
-        public static readonly CVarDef<float> UpdateRestartDelay =
-            CVarDef.Create("update.restart_delay", 20f, CVar.SERVERONLY);
-
-        #endregion
-        #region Ghost
-        /*
-         * Ghost
-         */
-
-        /// <summary>
-        /// The time you must spend reading the rules, before the "Request" button is enabled
-        /// </summary>
-        public static readonly CVarDef<float> GhostRoleTime =
-            CVarDef.Create("ghost.role_time", 8f, CVar.REPLICATED | CVar.SERVER);
-
-        #endregion
-        #region Fire alarm
-        /*
-         * Fire alarm
-         */
-
-        /// <summary>
-        ///     If fire alarms should have all access, or if activating/resetting these
-        ///     should be restricted to what is dictated on a player's access card.
-        ///     Defaults to true.
-        /// </summary>
-        public static readonly CVarDef<bool> FireAlarmAllAccess =
-            CVarDef.Create("firealarm.allaccess", true, CVar.SERVERONLY);
-
-        #endregion
-        #region PLAYTIME
-        /*
-         * PLAYTIME
-         */
-
-        /// <summary>
-        /// Time between play time autosaves, in seconds.
-        /// </summary>
-        public static readonly CVarDef<float>
-            PlayTimeSaveInterval = CVarDef.Create("playtime.save_interval", 900f, CVar.SERVERONLY);
-
-        #endregion
-        #region INFOLINKS
-        /*
-         * INFOLINKS
-         */
-
-        /// <summary>
-        /// Link to Discord server to show in the launcher.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksDiscord =
-            CVarDef.Create("infolinks.discord", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to website to show in the launcher.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksForum =
-            CVarDef.Create("infolinks.forum", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to GitHub page to show in the launcher.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksGithub =
-            CVarDef.Create("infolinks.github", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to website to show in the launcher.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksWebsite =
-            CVarDef.Create("infolinks.website", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to wiki to show in the launcher.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksWiki =
-            CVarDef.Create("infolinks.wiki", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to Patreon. Not shown in the launcher currently.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksPatreon =
-            CVarDef.Create("infolinks.patreon", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to the bug report form.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksBugReport =
-            CVarDef.Create("infolinks.bug_report", "", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Link to site handling ban appeals. Shown in ban disconnect messages.
-        /// </summary>
-        public static readonly CVarDef<string> InfoLinksAppeal =
-            CVarDef.Create("infolinks.appeal", "", CVar.SERVER | CVar.REPLICATED);
-
-        #endregion
-        #region CONFIG
-        /*
-         * CONFIG
-         */
-
-        // These are server-only for now since I don't foresee a client use yet,
-        // and I don't wanna have to start coming up with like .client suffixes and stuff like that.
-
-        /// <summary>
-        /// Configuration presets to load during startup.
-        /// Multiple presets can be separated by comma and are loaded in order.
-        /// </summary>
-        /// <remarks>
-        /// Loaded presets must be located under the <c>ConfigPresets/</c> resource directory and end with the <c>.toml</c> extension.
-        /// Only the file name (without extension) must be given for this variable.
-        /// </remarks>
-        public static readonly CVarDef<string> ConfigPresets =
-            CVarDef.Create("config.presets", "", CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether to load the preset development CVars.
-        /// This disables some things like lobby to make development easier.
-        /// Even when true, these are only loaded if the game is compiled with <c>DEVELOPMENT</c> set.
-        /// </summary>
-        public static readonly CVarDef<bool> ConfigPresetDevelopment =
-            CVarDef.Create("config.preset_development", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Whether to load the preset debug CVars.
-        /// Even when true, these are only loaded if the game is compiled with <c>DEBUG</c> set.
-        /// </summary>
-        public static readonly CVarDef<bool> ConfigPresetDebug =
-            CVarDef.Create("config.preset_debug", true, CVar.SERVERONLY);
-
-        #endregion
-        #region World Generation
-        /*
-         * World Generation
-         */
-        /// <summary>
-        ///     Whether or not world generation is enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> WorldgenEnabled =
-            CVarDef.Create("worldgen.enabled", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The worldgen config to use.
-        /// </summary>
-        public static readonly CVarDef<string> WorldgenConfig =
-            CVarDef.Create("worldgen.worldgen_config", "Default", CVar.SERVERONLY);
-
-        /// <summary>
-        ///     The maximum amount of time the entity GC can process, in ms.
-        /// </summary>
-        public static readonly CVarDef<int> GCMaximumTimeMs =
-            CVarDef.Create("entgc.maximum_time_ms", 5, CVar.SERVERONLY);
-
-        #endregion
-        #region Replays
-        /*
-         * Replays
-         */
-
-        /// <summary>
-        ///     Whether or not to record admin chat. If replays are being publicly distributes, this should probably be
-        ///     false.
-        /// </summary>
-        public static readonly CVarDef<bool> ReplayRecordAdminChat =
-            CVarDef.Create("replay.record_admin_chat", false, CVar.ARCHIVE);
-
-        /// <summary>
-        /// Automatically record full rounds as replays.
-        /// </summary>
-        public static readonly CVarDef<bool> ReplayAutoRecord =
-            CVarDef.Create("replay.auto_record", false, CVar.SERVERONLY);
-
-        /// <summary>
-        /// The file name to record automatic replays to. The path is relative to <see cref="CVars.ReplayDirectory"/>.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// If the path includes slashes, directories will be automatically created if necessary.
-        /// </para>
-        /// <para>
-        /// A number of substitutions can be used to automatically fill in the file name: <c>{year}</c>, <c>{month}</c>, <c>{day}</c>, <c>{hour}</c>, <c>{minute}</c>, <c>{round}</c>.
-        /// </para>
-        /// </remarks>
-        public static readonly CVarDef<string> ReplayAutoRecordName =
-            CVarDef.Create("replay.auto_record_name", "{year}_{month}_{day}-{hour}_{minute}-round_{round}.zip", CVar.SERVERONLY);
-
-        /// <summary>
-        /// Path that, if provided, automatic replays are initially recorded in.
-        /// When the recording is done, the file is moved into its final destination.
-        /// Unless this path is rooted, it will be relative to <see cref="CVars.ReplayDirectory"/>.
-        /// </summary>
-        public static readonly CVarDef<string> ReplayAutoRecordTempDir =
-            CVarDef.Create("replay.auto_record_temp_dir", "", CVar.SERVERONLY);
-
-
-        /// <summary>
-        ///     The amount of time between NPC Silicons draining their battery in seconds.
-        /// </summary>
-        public static readonly CVarDef<float> SiliconNpcUpdateTime =
-            CVarDef.Create("silicon.npcupdatetime", 1.5f, CVar.SERVERONLY);
-
-
-        #endregion
-        #region Miscellaneous
-        /*
-         * Miscellaneous
-         */
-
-        public static readonly CVarDef<bool> GatewayGeneratorEnabled =
-            CVarDef.Create("gateway.generator_enabled", true);
-
-        // Clippy!
-        public static readonly CVarDef<string> TippyEntity =
-            CVarDef.Create("tippy.entity", "Tippy", CVar.SERVER | CVar.REPLICATED);
-
-        /// <summary>
-        /// Set to true to disable parallel processing in the pow3r solver.
-        /// </summary>
-        public static readonly CVarDef<bool> DebugPow3rDisableParallel =
-            CVarDef.Create("debug.pow3r_disable_parallel", true, CVar.SERVERONLY);
-
-        /// <summary>
-        /// Set to true to enable the dynamic hostname system.
-        /// Automatically updates the hostname to include current map and preset.
-        /// Configure what that looks like for you in Resources/Prototypes/Locale/en-US/dynamichostname/hostname.ftl
-        /// </summary>
-        public static readonly CVarDef<bool> UseDynamicHostname =
-            CVarDef.Create("game.use_dynamic_hostname", false, CVar.SERVERONLY);
-
-        #endregion
-        #region DEBUG
-        /*
-         * DEBUG
-         */
-
-        /// <summary>
-        /// A simple toggle to test <c>OptionsVisualizerComponent</c>.
-        /// </summary>
-        public static readonly CVarDef<bool> DebugOptionVisualizerTest =
-            CVarDef.Create("debug.option_visualizer_test", false, CVar.CLIENTONLY);
-
-        /// DELTA-V CCVARS
-        #endregion
-        #region Glimmer
-        /*
-         * Glimmer
-         */
-
-        /// <summary>
-        ///    Whether glimmer is enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> GlimmerEnabled =
-            CVarDef.Create("glimmer.enabled", true, CVar.REPLICATED);
-
-        /// <summary>
-        ///     The rate at which glimmer linearly decays. Since glimmer increases (usually) follow a logistic curve, this means glimmer
-        ///     becomes increasingly harder to raise after ~502 points.
-        /// </summary>
-        public static readonly CVarDef<float> GlimmerLinearDecayPerMinute =
-            CVarDef.Create("glimmer.linear_decay_per_minute", 6f, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether random rolls for psionics are allowed.
-        ///     Guaranteed psionics will still go through.
-        /// </summary>
-        public static readonly CVarDef<bool> PsionicRollsEnabled =
-            CVarDef.Create("psionics.rolls_enabled", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether height & width sliders adjust a character's Fixture Component
-        /// </summary>
-        public static readonly CVarDef<bool> HeightAdjustModifiesHitbox =
-            CVarDef.Create("heightadjust.modifies_hitbox", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether height & width sliders adjust a player's max view distance
-        /// </summary>
-        public static readonly CVarDef<bool> HeightAdjustModifiesZoom =
-            CVarDef.Create("heightadjust.modifies_zoom", false, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Whether height & width sliders adjust a player's bloodstream volume.
-        /// </summary>
-        /// <remarks>
-        ///     This can be configured more precisely by modifying BloodstreamAffectedByMassComponent.
-        /// </remarks>
-        public static readonly CVarDef<bool> HeightAdjustModifiesBloodstream =
-            CVarDef.Create("heightadjust.modifies_bloodstream", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Enables station goals
-        /// </summary>
-        public static readonly CVarDef<bool> StationGoalsEnabled =
-            CVarDef.Create("game.station_goals", true, CVar.SERVERONLY);
-
-        /// <summary>
-        ///     Chance for a station goal to be sent
-        /// </summary>
-        public static readonly CVarDef<float> StationGoalsChance =
-            CVarDef.Create("game.station_goals_chance", 0.1f, CVar.SERVERONLY);
-
-        #endregion
-        #region CPR System
-        /*
-         * CPR System
-         */
-        /// <summary>
-        ///     Controls whether the entire CPR system runs. When false, nobody can perform CPR. You should probably remove the trait too
-        ///     if you are wishing to permanently disable the system on your server.
-        /// </summary>
-        public static readonly CVarDef<bool> EnableCPR =
-            CVarDef.Create("cpr.enable", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles whether or not CPR reduces rot timers(As an abstraction of delaying brain death, the IRL actual purpose of CPR)
-        /// </summary>
-        public static readonly CVarDef<bool> CPRReducesRot =
-            CVarDef.Create("cpr.reduces_rot", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles whether or not CPR heals airloss, included for completeness sake. I'm not going to stop you if your intention is to make CPR do nothing.
-        ///     I guess it might be funny to troll your players with? I won't judge.
-        /// </summary>
-        public static readonly CVarDef<bool> CPRHealsAirloss =
-            CVarDef.Create("cpr.heals_airloss", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     The chance for a patient to be resuscitated when CPR is successfully performed.
-        ///     Setting this above 0 isn't very realistic, but people who see CPR in movies and TV will expect CPR to work this way.
-        /// </summary>
-        public static readonly CVarDef<float> CPRResuscitationChance =
-            CVarDef.Create("cpr.resuscitation_chance", 0.05f, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     By default, CPR reduces rot timers by an amount of seconds equal to the time spent performing CPR. This is an optional multiplier that can increase or decrease the amount
-        ///     of rot reduction. Set it to 2 for if you want 3 seconds of CPR to reduce 6 seconds of rot.
-        /// </summary>
-        /// <remarks>
-        ///     If you're wondering why there isn't a CVar for setting the duration of the doafter, that's because it's not actually possible to have a timespan in cvar form
-        ///     Curiously, it's also not possible for **shared** systems to set variable timespans. Which is where this system lives.
-        /// </remarks>
-        public static readonly CVarDef<float> CPRRotReductionMultiplier =
-            CVarDef.Create("cpr.rot_reduction_multiplier", 1f, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     By default, CPR heals airloss by 1 point for every second spent performing CPR. Just like above, this directly multiplies the healing amount.
-        ///     Set it to 2 to get 6 points of airloss healing for every 3 seconds of CPR.
-        /// </summary>
-        public static readonly CVarDef<float> CPRAirlossReductionMultiplier =
-            CVarDef.Create("cpr.airloss_reduction_multiplier", 1f, CVar.REPLICATED | CVar.SERVER);
-
-        #endregion
-        #region Contests System
-        /*
-         * Contests System
-         */
-
-        /// <summary>
-        ///     The MASTER TOGGLE for the entire Contests System.
-        ///     ALL CONTESTS BELOW, regardless of type or setting will output 1f when false.
-        /// </summary>
-        public static readonly CVarDef<bool> DoContestsSystem =
-            CVarDef.Create("contests.do_contests_system", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Contest functions normally include an optional override to bypass the clamp set by max_percentage.
-        ///     This CVar disables the bypass when false, forcing all implementations to comply with max_percentage.
-        /// </summary>
-        public static readonly CVarDef<bool> AllowClampOverride =
-            CVarDef.Create("contests.allow_clamp_override", true, CVar.REPLICATED | CVar.SERVER);
-        /// <summary>
-        ///     Toggles all MassContest functions. All mass contests output 1f when false
-        /// </summary>
-        public static readonly CVarDef<bool> DoMassContests =
-            CVarDef.Create("contests.do_mass_contests", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles all StaminaContest functions. All stamina contests output 1f when false
-        /// </summary>
-        public static readonly CVarDef<bool> DoStaminaContests =
-            CVarDef.Create("contests.do_stamina_contests", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles all HealthContest functions. All health contests output 1f when false
-        /// </summary>
-        public static readonly CVarDef<bool> DoHealthContests =
-            CVarDef.Create("contests.do_health_contests", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles all MindContest functions. All mind contests output 1f when false.
-        ///     MindContests are not currently implemented, and are awaiting completion of the Psionic Refactor
-        /// </summary>
-        public static readonly CVarDef<bool> DoMindContests =
-            CVarDef.Create("contests.do_mind_contests", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles all MoodContest functions. All mood contests output 1f when false.
-        /// </summary>
-        public static readonly CVarDef<bool> DoMoodContests =
-            CVarDef.Create("contests.do_mood_contests", true, CVar.REPLICATED | CVar.SERVER);
-
-        /// <summary>
-        ///     The maximum amount that Mass Contests can modify a physics multiplier, given as a +/- percentage
-        ///     Default of 0.25f outputs between * 0.75f and 1.25f
-        /// </summary>
-        public static readonly CVarDef<float> MassContestsMaxPercentage =
-            CVarDef.Create("contests.max_percentage", 0.25f, CVar.REPLICATED | CVar.SERVER);
-
-        #endregion
-        #region Supermatter System
-        /*
-         * Supermatter System
-         */
-
-        /// <summary>
-        ///     With completely default supermatter values, Singuloose delamination will occur if engineers inject at least 900 moles of coolant per tile
-        ///     in the crystal chamber. For reference, a gas canister contains 1800 moles of air. This Cvar directly multiplies the amount of moles required to singuloose.
-        /// </summary>
-        public static readonly CVarDef<float> SupermatterSingulooseMolesModifier =
-            CVarDef.Create("supermatter.singuloose_moles_modifier", 1f, CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles whether or not Singuloose delaminations can occur. If both Singuloose and Tesloose are disabled, it will always delam into a Nuke.
-        /// </summary>
-        public static readonly CVarDef<bool> SupermatterDoSingulooseDelam =
-            CVarDef.Create("supermatter.do_singuloose", true, CVar.SERVER);
-
-        /// <summary>
-        ///     By default, Supermatter will "Tesloose" if the conditions for Singuloose are not met, and the core's power is at least 4000.
-        ///     The actual reasons for being at least this amount vary by how the core was screwed up, but traditionally it's caused by "The core is on fire".
-        ///     This Cvar multiplies said power threshold for the purpose of determining if the delam is a Tesloose.
-        /// </summary>
-        public static readonly CVarDef<float> SupermatterTesloosePowerModifier =
-            CVarDef.Create("supermatter.tesloose_power_modifier", 1f, CVar.SERVER);
-
-        /// <summary>
-        ///     Toggles whether or not Tesloose delaminations can occur. If both Singuloose and Tesloose are disabled, it will always delam into a Nuke.
-        /// </summary>
-        public static readonly CVarDef<bool> SupermatterDoTeslooseDelam =
-            CVarDef.Create("supermatter.do_tesloose", true, CVar.SERVER);
-
-        /// <summary>
-        ///     When true, bypass the normal checks to determine delam type, and instead use the type chosen by supermatter.forced_delam_type
-        /// </summary>
-        public static readonly CVarDef<bool> SupermatterDoForceDelam =
-            CVarDef.Create("supermatter.do_force_delam", false, CVar.SERVER);
-
-        /// <summary>
-        ///     If supermatter.do_force_delam is true, this determines the delamination type, bypassing the normal checks.
-        /// </summary>
-        public static readonly CVarDef<DelamType> SupermatterForcedDelamType =
-            CVarDef.Create("supermatter.forced_delam_type", DelamType.Singulo, CVar.SERVER);
-
-        /// <summary>
-        ///     Directly multiplies the amount of rads put out by the supermatter. Be VERY conservative with this.
-        /// </summary>
-        public static readonly CVarDef<float> SupermatterRadsModifier =
-            CVarDef.Create("supermatter.rads_modifier", 1f, CVar.SERVER);
-
-        #endregion
-        #region Mood System
-        /*
-         * Mood System
-         */
-
-        public static readonly CVarDef<bool> MoodEnabled =
-#if RELEASE
-            CVarDef.Create("mood.enabled", true, CVar.SERVER);
-#else
-            CVarDef.Create("mood.enabled", false, CVar.SERVER);
-#endif
-
-        public static readonly CVarDef<bool> MoodIncreasesSpeed =
-            CVarDef.Create("mood.increases_speed", true, CVar.SERVER);
-
-        public static readonly CVarDef<bool> MoodDecreasesSpeed =
-            CVarDef.Create("mood.decreases_speed", true, CVar.SERVER);
-
-        public static readonly CVarDef<bool> MoodModifiesThresholds =
-            CVarDef.Create("mood.modify_thresholds", false, CVar.SERVER);
-
-        #endregion
-        #region Lying Down System
-
-        public static readonly CVarDef<bool> AutoGetUp =
-            CVarDef.Create("rest.auto_get_up", true, CVar.CLIENT | CVar.ARCHIVE | CVar.REPLICATED);
-
-        public static readonly CVarDef<bool> HoldLookUp =
-            CVarDef.Create("rest.hold_look_up", false, CVar.CLIENT | CVar.ARCHIVE);
-
-        /// <summary>
-        ///     When true, players can choose to crawl under tables while laying down, using the designated keybind.
-        /// </summary>
-        public static readonly CVarDef<bool> CrawlUnderTables =
-            CVarDef.Create("rest.crawlundertables", true, CVar.SERVER | CVar.ARCHIVE);
-
-        #endregion
-        #region Material Reclaimer
-        /*
-         * Material System
-         */
-
-        /// <summary>
-        ///     Whether or not a Material Reclaimer is allowed to eat people when emagged.
-        /// </summary>
-        public static readonly CVarDef<bool> ReclaimerAllowGibbing =
-            CVarDef.Create("reclaimer.allow_gibbing", true, CVar.SERVER);
-
-        #endregion
-
-        #region Material Silo
-
-        /// <summary>
-        ///     Is ore material enabled.
-        /// </summary>
-        public static readonly CVarDef<bool> SiloEnabled =
-            CVarDef.Create("silo.silo_enabled", true, CVar.SERVER | CVar.REPLICATED);
-
-        #endregion
-
-        #region Jetpack System
-        /*
-         * Jetpack System
-         */
-
-        /// <summary>
-        ///     When true, Jetpacks can be enabled anywhere, even in gravity.
-        /// </summary>
-        public static readonly CVarDef<bool> JetpackEnableAnywhere =
-            CVarDef.Create("jetpack.enable_anywhere", false, CVar.REPLICATED);
-
-        /// <summary>
-        ///     When true, jetpacks can be enabled on grids that have zero gravity.
-        /// </summary>
-        public static readonly CVarDef<bool> JetpackEnableInNoGravity =
-            CVarDef.Create("jetpack.enable_in_no_gravity", true, CVar.REPLICATED);
-
-        #endregion
-        #region GhostRespawn
-        /*
-         * GhostRespawn
-         */
-
-        public static readonly CVarDef<double> GhostRespawnTime =
-            CVarDef.Create("ghost.respawn_time", 15d, CVar.SERVERONLY);
-
-        public static readonly CVarDef<int> GhostRespawnMaxPlayers =
-            CVarDef.Create("ghost.respawn_max_players", 40, CVar.SERVERONLY);
-
-        public static readonly CVarDef<bool> GhostAllowSameCharacter =
-            CVarDef.Create("ghost.allow_same_character", false, CVar.SERVERONLY);
-
-        #endregion
-        #region Surgery
-        /*
-         * Surgery
-         */
-
-        public static readonly CVarDef<bool> CanOperateOnSelf =
-            CVarDef.Create("surgery.can_operate_on_self", false, CVar.SERVERONLY);
-
-        #endregion
-        #region AUTOVOTE SYSTEM
-        /*
-        * AUTOVOTE SYSTEM
-        */
-
-        /// Enables the automatic voting system.
-        public static readonly CVarDef<bool> AutoVoteEnabled =
-            CVarDef.Create("vote.autovote_enabled", false, CVar.SERVERONLY);
-
-        /// Automatically starts a map vote when returning to the lobby.
-        /// Requires auto voting to be enabled.
-        public static readonly CVarDef<bool> MapAutoVoteEnabled =
-            CVarDef.Create("vote.map_autovote_enabled", true, CVar.SERVERONLY);
-
-        /// Automatically starts a gamemode vote when returning to the lobby.
-        /// Requires auto voting to be enabled.
-        public static readonly CVarDef<bool> PresetAutoVoteEnabled =
-            CVarDef.Create("vote.preset_autovote_enabled", true, CVar.SERVERONLY);
-
-        #endregion
-        #region Psionics
-        /*
-         * Psionics
-         */
-
-        /// <summary>
-        ///     When mindbroken, permanently eject the player from their own body, and turn their character into an NPC.
-        ///     Congratulations, now they *actually* aren't a person anymore.
-        ///     For people who complained that it wasn't obvious enough from the text that Mindbreaking is a form of Murder.
-        /// </summary>
-        public static readonly CVarDef<bool> ScarierMindbreaking =
-            CVarDef.Create("psionics.scarier_mindbreaking", false, CVar.SERVERONLY);
-        #endregion
-        #region SoftCrit
-        /*
-         * SoftCrit
-         */
-
-        /// <summary>
-        ///     Used for basic Soft-Crit implementation. Entities are allowed to crawl when in crit, as this CVar intercepts the mover controller check for incapacitation,
-        ///     and prevents it from stopping movement if this CVar is set to true and the user is Crit but Not Dead. This is only for movement,
-        ///     you still can't stand up while crit, and you're still more or less helpless.
-        /// </summary>
-        public static readonly CVarDef<bool> AllowMovementWhileCrit =
-            CVarDef.Create("mobstate.allow_movement_while_crit", true, CVar.REPLICATED);
-
-        public static readonly CVarDef<bool> AllowTalkingWhileCrit =
-            CVarDef.Create("mobstate.allow_talking_while_crit", true, CVar.REPLICATED);
-
-        /// <summary>
-        ///     Currently does nothing because I would have to figure out WHERE I would even put this check, and the mover controller is fairly complicated.
-        ///     The goal is to make it so that attempting to move while in 'soft crit' can potentially cause further injury, causing you to die faster. Ideally there would be special
-        ///     actions that can be performed in soft crit, such as applying pressure to your own injuries to slow down the bleedout, or other varieties of "Will To Live".
-        /// </summary>
-        public static readonly CVarDef<bool> DamageWhileCritMove =
-            CVarDef.Create("mobstate.damage_while_crit_move", false, CVar.REPLICATED);
-
-        #endregion
-    }
+/// <summary>
+/// Contains all the CVars used by content.
+/// </summary>
+/// <remarks>
+/// NOTICE FOR FORKS: Put your own CVars in a separate file with a different [CVarDefs] attribute. RT will automatically pick up on it.
+/// </remarks>
+[CVarDefs]
+public sealed partial class CCVars : CVars
+{
+    // Only debug stuff lives here.
+
+    /// <summary>
+    /// A simple toggle to test <c>OptionsVisualizerComponent</c>.
+    /// </summary>
+    public static readonly CVarDef<bool> DebugOptionVisualizerTest =
+        CVarDef.Create("debug.option_visualizer_test", false, CVar.CLIENTONLY);
+
+    /// <summary>
+    /// Set to true to disable parallel processing in the pow3r solver.
+    /// </summary>
+    public static readonly CVarDef<bool> DebugPow3rDisableParallel =
+        CVarDef.Create("debug.pow3r_disable_parallel", true, CVar.SERVERONLY);
 }
diff --git a/Content.Shared/Chemistry/SharedChemMaster.cs b/Content.Shared/Chemistry/SharedChemMaster.cs
index 3c11a3552d..b98a337204 100644
--- a/Content.Shared/Chemistry/SharedChemMaster.cs
+++ b/Content.Shared/Chemistry/SharedChemMaster.cs
@@ -44,10 +44,10 @@ public ChemMasterSetPillTypeMessage(uint pillType)
     public sealed class ChemMasterReagentAmountButtonMessage : BoundUserInterfaceMessage
     {
         public readonly ReagentId ReagentId;
-        public readonly ChemMasterReagentAmount Amount;
+        public readonly int Amount;
         public readonly bool FromBuffer;
 
-        public ChemMasterReagentAmountButtonMessage(ReagentId reagentId, ChemMasterReagentAmount amount, bool fromBuffer)
+        public ChemMasterReagentAmountButtonMessage(ReagentId reagentId, int amount, bool fromBuffer)
         {
             ReagentId = reagentId;
             Amount = amount;
@@ -83,6 +83,18 @@ public ChemMasterOutputToBottleMessage(uint dosage, string label)
         }
     }
 
+    [Serializable, NetSerializable]
+    public sealed class ChemMasterSortMethodUpdated(int sortMethod) : BoundUserInterfaceMessage
+    {
+        public readonly int SortMethod = sortMethod;
+    }
+
+    [Serializable, NetSerializable]
+    public sealed class ChemMasterTransferringAmountUpdated(int transferringAmount) : BoundUserInterfaceMessage
+    {
+        public readonly int TransferringAmount = transferringAmount;
+    }
+
     public enum ChemMasterMode
     {
         Transfer,
@@ -173,10 +185,13 @@ public sealed class ChemMasterBoundUserInterfaceState : BoundUserInterfaceState
 
         public readonly bool UpdateLabel;
 
+        public readonly int SortMethod;
+        public readonly int TransferringAmount;
+
         public ChemMasterBoundUserInterfaceState(
             ChemMasterMode mode, ContainerInfo? inputContainerInfo, ContainerInfo? outputContainerInfo,
             IReadOnlyList<ReagentQuantity> bufferReagents, FixedPoint2 bufferCurrentVolume,
-            uint selectedPillType, uint pillDosageLimit, bool updateLabel)
+            uint selectedPillType, uint pillDosageLimit, bool updateLabel, int sortMethod, int transferringAmount)
         {
             InputContainerInfo = inputContainerInfo;
             OutputContainerInfo = outputContainerInfo;
@@ -186,6 +201,8 @@ public ChemMasterBoundUserInterfaceState(
             SelectedPillType = selectedPillType;
             PillDosageLimit = pillDosageLimit;
             UpdateLabel = updateLabel;
+            SortMethod = sortMethod;
+            TransferringAmount = transferringAmount;
         }
     }
 
diff --git a/Content.Shared/Customization/Systems/CharacterRequirements.Whitelist.cs b/Content.Shared/Customization/Systems/CharacterRequirements.Whitelist.cs
index 515263c6db..59f5933732 100644
--- a/Content.Shared/Customization/Systems/CharacterRequirements.Whitelist.cs
+++ b/Content.Shared/Customization/Systems/CharacterRequirements.Whitelist.cs
@@ -29,6 +29,10 @@ public override bool IsValid(JobPrototype job,
         out string? reason,
         int depth = 0)
     {
+        reason = null;
+        if (!configManager.IsCVarRegistered("whitelist.enabled"))
+            return whitelisted;
+
         reason = Loc.GetString("character-whitelist-requirement", ("inverted", Inverted));
         return !configManager.GetCVar(CCVars.WhitelistEnabled) || whitelisted;
     }
diff --git a/Content.Shared/Decals/DecalPrototype.cs b/Content.Shared/Decals/DecalPrototype.cs
index 2721f5d2d2..543537f1bf 100644
--- a/Content.Shared/Decals/DecalPrototype.cs
+++ b/Content.Shared/Decals/DecalPrototype.cs
@@ -1,10 +1,11 @@
 using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Array;
 using Robust.Shared.Utility;
 
 namespace Content.Shared.Decals
 {
     [Prototype("decal")]
-    public sealed partial class DecalPrototype : IPrototype
+    public sealed partial class DecalPrototype : IPrototype, IInheritingPrototype
     {
         [IdDataField] public string ID { get; } = null!;
         [DataField("sprite")] public SpriteSpecifier Sprite { get; private set; } = SpriteSpecifier.Invalid;
@@ -33,5 +34,13 @@ public sealed partial class DecalPrototype : IPrototype
         /// </summary>
         [DataField]
         public bool DefaultSnap = true;
+
+        [ParentDataField(typeof(AbstractPrototypeIdArraySerializer<DecalPrototype>))]
+        public string[]? Parents { get; }
+
+        [NeverPushInheritance]
+        [AbstractDataField]
+        public bool Abstract { get; }
+
     }
 }
diff --git a/Content.Shared/Electrocution/Components/ElectrocutionOverlayComponent.cs b/Content.Shared/Electrocution/Components/ElectrocutionOverlayComponent.cs
new file mode 100644
index 0000000000..e03e8cb934
--- /dev/null
+++ b/Content.Shared/Electrocution/Components/ElectrocutionOverlayComponent.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Electrocution;
+
+/// <summary>
+/// Allow an entity to see the ElectrocutionOverlay showing electrocuted doors.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ElectrocutionOverlayComponent : Component;
diff --git a/Content.Shared/Electrocution/SharedElectrocution.cs b/Content.Shared/Electrocution/SharedElectrocution.cs
index 4060856d4d..b00fb1afdb 100644
--- a/Content.Shared/Electrocution/SharedElectrocution.cs
+++ b/Content.Shared/Electrocution/SharedElectrocution.cs
@@ -5,11 +5,13 @@ namespace Content.Shared.Electrocution;
 [Serializable, NetSerializable]
 public enum ElectrifiedLayers : byte
 {
-    Powered
+    Sparks,
+    Overlay,
 }
 
 [Serializable, NetSerializable]
 public enum ElectrifiedVisuals : byte
 {
-    IsPowered
+    ShowSparks, // only shown when zapping someone, deactivated after a short time
+    IsElectrified, // if the entity is electrified or not, used for the AI HUD
 }
diff --git a/Content.Shared/Electrocution/SharedElectrocutionSystem.cs b/Content.Shared/Electrocution/SharedElectrocutionSystem.cs
index e36e4a804b..5da344e023 100644
--- a/Content.Shared/Electrocution/SharedElectrocutionSystem.cs
+++ b/Content.Shared/Electrocution/SharedElectrocutionSystem.cs
@@ -5,6 +5,8 @@ namespace Content.Shared.Electrocution
 {
     public abstract class SharedElectrocutionSystem : EntitySystem
     {
+        [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+
         public override void Initialize()
         {
             base.Initialize();
@@ -35,6 +37,19 @@ public void SetElectrified(Entity<ElectrifiedComponent> ent, bool value)
 
             ent.Comp.Enabled = value;
             Dirty(ent, ent.Comp);
+
+            _appearance.SetData(ent.Owner, ElectrifiedVisuals.IsElectrified, value);
+        }
+
+        public void SetElectrifiedWireCut(Entity<ElectrifiedComponent> ent, bool value)
+        {
+            if (ent.Comp.IsWireCut == value)
+            {
+                return;
+            }
+
+            ent.Comp.IsWireCut = value;
+            Dirty(ent);
         }
 
         /// <param name="uid">Entity being electrocuted.</param>
diff --git a/Content.Shared/Input/ContentKeyFunctions.cs b/Content.Shared/Input/ContentKeyFunctions.cs
index 7968de01ef..548fecd784 100644
--- a/Content.Shared/Input/ContentKeyFunctions.cs
+++ b/Content.Shared/Input/ContentKeyFunctions.cs
@@ -127,5 +127,14 @@ public static BoundKeyFunction[] GetLoadoutBoundKeys() =>
         public static readonly BoundKeyFunction EditorCopyObject = "EditorCopyObject";
         public static readonly BoundKeyFunction EditorFlipObject = "EditorFlipObject";
         public static readonly BoundKeyFunction InspectEntity = "InspectEntity";
+
+        public static readonly BoundKeyFunction MappingUnselect = "MappingUnselect";
+        public static readonly BoundKeyFunction SaveMap = "SaveMap";
+        public static readonly BoundKeyFunction MappingEnablePick = "MappingEnablePick";
+        public static readonly BoundKeyFunction MappingEnableDelete = "MappingEnableDelete";
+        public static readonly BoundKeyFunction MappingPick = "MappingPick";
+        public static readonly BoundKeyFunction MappingRemoveDecal = "MappingRemoveDecal";
+        public static readonly BoundKeyFunction MappingCancelEraseDecal = "MappingCancelEraseDecal";
+        public static readonly BoundKeyFunction MappingOpenContextMenu = "MappingOpenContextMenu";
     }
 }
diff --git a/Content.Shared/Mapping/MappingMapDataMessage.cs b/Content.Shared/Mapping/MappingMapDataMessage.cs
new file mode 100644
index 0000000000..a3961a6809
--- /dev/null
+++ b/Content.Shared/Mapping/MappingMapDataMessage.cs
@@ -0,0 +1,46 @@
+using System.IO;
+using Lidgren.Network;
+using Robust.Shared.Network;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Mapping;
+
+public sealed class MappingMapDataMessage : NetMessage
+{
+    public override MsgGroups MsgGroup => MsgGroups.Command;
+    public override NetDeliveryMethod DeliveryMethod => NetDeliveryMethod.ReliableUnordered;
+
+    public ZStdCompressionContext Context = default!;
+    public string Yml = default!;
+
+    public override void ReadFromBuffer(NetIncomingMessage buffer, IRobustSerializer serializer)
+    {
+        MsgSize = buffer.LengthBytes;
+
+        var uncompressedLength = buffer.ReadVariableInt32();
+        var compressedLength = buffer.ReadVariableInt32();
+        var stream = new MemoryStream(compressedLength);
+        buffer.ReadAlignedMemory(stream, compressedLength);
+        using var decompress = new ZStdDecompressStream(stream);
+        using var decompressed = new MemoryStream(uncompressedLength);
+
+        decompress.CopyTo(decompressed, uncompressedLength);
+        decompressed.Position = 0;
+        serializer.DeserializeDirect(decompressed, out Yml);
+    }
+
+    public override void WriteToBuffer(NetOutgoingMessage buffer, IRobustSerializer serializer)
+    {
+        var stream = new MemoryStream();
+        serializer.SerializeDirect(stream, Yml);
+        buffer.WriteVariableInt32((int) stream.Length);
+
+        stream.Position = 0;
+        var buf = new byte[ZStd.CompressBound((int) stream.Length)];
+        var length = Context.Compress2(buf, stream.AsSpan());
+
+        buffer.WriteVariableInt32(length);
+        buffer.Write(buf.AsSpan(0, length));
+    }
+}
diff --git a/Content.Shared/Mapping/MappingSaveMapErrorMessage.cs b/Content.Shared/Mapping/MappingSaveMapErrorMessage.cs
new file mode 100644
index 0000000000..e30e257305
--- /dev/null
+++ b/Content.Shared/Mapping/MappingSaveMapErrorMessage.cs
@@ -0,0 +1,19 @@
+using Lidgren.Network;
+using Robust.Shared.Network;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Mapping;
+
+public sealed class MappingSaveMapErrorMessage : NetMessage
+{
+    public override MsgGroups MsgGroup => MsgGroups.Command;
+    public override NetDeliveryMethod DeliveryMethod => NetDeliveryMethod.ReliableUnordered;
+
+    public override void ReadFromBuffer(NetIncomingMessage buffer, IRobustSerializer serializer)
+    {
+    }
+
+    public override void WriteToBuffer(NetOutgoingMessage buffer, IRobustSerializer serializer)
+    {
+    }
+}
diff --git a/Content.Shared/Mapping/MappingSaveMapMessage.cs b/Content.Shared/Mapping/MappingSaveMapMessage.cs
new file mode 100644
index 0000000000..f80b866121
--- /dev/null
+++ b/Content.Shared/Mapping/MappingSaveMapMessage.cs
@@ -0,0 +1,19 @@
+using Lidgren.Network;
+using Robust.Shared.Network;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Mapping;
+
+public sealed class MappingSaveMapMessage : NetMessage
+{
+    public override MsgGroups MsgGroup => MsgGroups.Command;
+    public override NetDeliveryMethod DeliveryMethod => NetDeliveryMethod.ReliableUnordered;
+
+    public override void ReadFromBuffer(NetIncomingMessage buffer, IRobustSerializer serializer)
+    {
+    }
+
+    public override void WriteToBuffer(NetOutgoingMessage buffer, IRobustSerializer serializer)
+    {
+    }
+}
diff --git a/Content.Shared/Psionics/Glimmer/GlimmerSystem.cs b/Content.Shared/Psionics/Glimmer/GlimmerSystem.cs
index 32d6502707..df7be34cc1 100644
--- a/Content.Shared/Psionics/Glimmer/GlimmerSystem.cs
+++ b/Content.Shared/Psionics/Glimmer/GlimmerSystem.cs
@@ -5,6 +5,7 @@
 
 namespace Content.Shared.Psionics.Glimmer;
 
+
 /// <summary>
 /// This handles setting / reading the value of glimmer.
 /// </summary>
@@ -13,6 +14,7 @@ public sealed class GlimmerSystem : EntitySystem
     [Dependency] private readonly IConfigurationManager _cfg = default!;
 
     private float _glimmerInput = 0;
+
     /// <summary>
     ///     GlimmerInput represents the system-facing value of the station's glimmer, and is given by f(y) for this graph: https://www.desmos.com/calculator/posutiq38e
     ///     Where x = GlimmerOutput and y = GlimmerInput
@@ -25,6 +27,13 @@ public float GlimmerInput
         get { return _glimmerInput; }
         private set { _glimmerInput = _enabled ? Math.Max(value, 0) : 0; }
     }
+
+    /// <summary>
+    ///     This returns a string that returns a more display-friendly glimmer input.
+    ///     For example, 502.03837847 will become 502.03.
+    /// </summary>
+    public string GlimmerInputString => _glimmerInput.ToString("#.##");
+
     private float _glimmerOutput = 0;
 
     /// <summary>
@@ -45,6 +54,13 @@ public float GlimmerOutput
         get { return _glimmerOutput; }
         private set { _glimmerOutput = _enabled ? Math.Clamp(value, 0, 999.999f) : 0; }
     }
+
+    /// <summary>
+    ///     This returns a string that returns a more display-friendly glimmer output.
+    ///     For example, 502.03837847 will become 502.03.
+    /// </summary>
+    public string GlimmerOutputString => _glimmerOutput.ToString("#.##");
+
     private bool _enabled;
     public override void Initialize()
     {
diff --git a/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Revolver.cs b/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Revolver.cs
index 14aaff5bf7..ee1ff5bdc9 100644
--- a/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Revolver.cs
+++ b/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Revolver.cs
@@ -21,7 +21,7 @@ protected virtual void InitializeRevolver()
     {
         SubscribeLocalEvent<RevolverAmmoProviderComponent, ComponentGetState>(OnRevolverGetState);
         SubscribeLocalEvent<RevolverAmmoProviderComponent, ComponentHandleState>(OnRevolverHandleState);
-        SubscribeLocalEvent<RevolverAmmoProviderComponent, ComponentInit>(OnRevolverInit);
+        SubscribeLocalEvent<RevolverAmmoProviderComponent, MapInitEvent>(OnRevolverInit);
         SubscribeLocalEvent<RevolverAmmoProviderComponent, TakeAmmoEvent>(OnRevolverTakeAmmo);
         SubscribeLocalEvent<RevolverAmmoProviderComponent, GetVerbsEvent<AlternativeVerb>>(OnRevolverVerbs);
         SubscribeLocalEvent<RevolverAmmoProviderComponent, InteractUsingEvent>(OnRevolverInteractUsing);
@@ -418,7 +418,7 @@ private void Cycle(RevolverAmmoProviderComponent component, int count = 1)
         component.CurrentIndex = (component.CurrentIndex + count) % component.Capacity;
     }
 
-    private void OnRevolverInit(EntityUid uid, RevolverAmmoProviderComponent component, ComponentInit args)
+    private void OnRevolverInit(EntityUid uid, RevolverAmmoProviderComponent component, MapInitEvent args)
     {
         component.AmmoContainer = Containers.EnsureContainer<Container>(uid, RevolverContainer);
         component.AmmoSlots.EnsureCapacity(component.Capacity);
diff --git a/Content.Shared/WhiteDream/BloodCult/Items/ShadowShacklesAura/SharedShadowShacklesAuraSystem.cs b/Content.Shared/WhiteDream/BloodCult/Items/ShadowShacklesAura/SharedShadowShacklesAuraSystem.cs
index 60c8656c6b..7100d4f343 100644
--- a/Content.Shared/WhiteDream/BloodCult/Items/ShadowShacklesAura/SharedShadowShacklesAuraSystem.cs
+++ b/Content.Shared/WhiteDream/BloodCult/Items/ShadowShacklesAura/SharedShadowShacklesAuraSystem.cs
@@ -19,7 +19,7 @@ public override void Initialize()
         base.Initialize();
 
         SubscribeLocalEvent<ShadowShacklesAuraComponent, MeleeHitEvent>(OnMeleeHit);
-        SubscribeLocalEvent<ShadowShacklesAuraComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<ShadowShacklesAuraComponent, MapInitEvent>(OnInit);
     }
 
     private void OnMeleeHit(EntityUid uid, ShadowShacklesAuraComponent component, MeleeHitEvent args)
@@ -35,7 +35,7 @@ private void OnMeleeHit(EntityUid uid, ShadowShacklesAuraComponent component, Me
             RaiseLocalEvent(uid, new SpeakOnAuraUseEvent(args.User));
     }
 
-    private void OnInit(EntityUid uid, ShadowShacklesAuraComponent component, ComponentInit args)
+    private void OnInit(EntityUid uid, ShadowShacklesAuraComponent component, MapInitEvent args)
     {
         var container = _container.EnsureContainer<Container>(uid, "shackles");
         component.Shackles = Spawn(component.ShacklesProto, _transform.GetMapCoordinates(uid));
diff --git a/Resources/Changelog/Changelog.yml b/Resources/Changelog/Changelog.yml
index 3631d7e8cf..f777975a42 100644
--- a/Resources/Changelog/Changelog.yml
+++ b/Resources/Changelog/Changelog.yml
@@ -10251,3 +10251,91 @@ Entries:
   id: 6719
   time: '2025-01-17T15:53:24.0000000+00:00'
   url: https://github.com/Simple-Station/Einstein-Engines/pull/1578
+- author: sleepyyapril
+  changes:
+    - type: Fix
+      message: Fixed full glimmer float being displayed to chat by Sophia.
+  id: 6720
+  time: '2025-01-18T03:23:15.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1581
+- author: sleepyyapril
+  changes:
+    - type: Fix
+      message: Fixed not having enough space for longer chemicals on the ChemMaster UI.
+  id: 6721
+  time: '2025-01-18T04:10:50.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1582
+- author: sleepyyapril
+  changes:
+    - type: Fix
+      message: Fixed IPCs being unable to cryo.
+  id: 6722
+  time: '2025-01-18T04:35:32.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1583
+- author: VMSolidus
+  changes:
+    - type: Add
+      message: Added the classic Asimov's Three Laws of Robotics to the game.
+    - type: Add
+      message: 'AI now starts with Asimov laws by default, instead of "Crewsimov". '
+  id: 6723
+  time: '2025-01-18T19:22:41.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1588
+- author: sleepyyapril
+  changes:
+    - type: Add
+      message: Added sorting options to the ChemMaster.
+    - type: Add
+      message: >-
+        Added the ability to input custom amounts into the ChemMaster via a
+        textbox that resets on change.
+    - type: Tweak
+      message: The width of the ChemMaster UI has been lowered.
+    - type: Remove
+      message: Removed quantity buttons from the ChemMaster.
+  id: 6724
+  time: '2025-01-18T20:03:16.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1585
+- author: VMSolidus
+  changes:
+    - type: Tweak
+      message: >-
+        The "Scream Action" no longer appears by default. It may be set in your
+        server's configuration to spawn or not. 
+  id: 6725
+  time: '2025-01-18T20:28:56.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1589
+- author: VMSolidus
+  changes:
+    - type: Tweak
+      message: >-
+        Scream is once again by default on the action bar. The server
+        configuration for removing it still exists however.
+  id: 6726
+  time: '2025-01-18T21:31:15.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1590
+- author: sleepyyapril
+  changes:
+    - type: Fix
+      message: >-
+        Fixed the infamous "Access denied" when using a network config in
+        mapping mode.
+  id: 6727
+  time: '2025-01-18T23:11:27.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1592
+- author: VMSolidus
+  changes:
+    - type: Remove
+      message: Lamia can no longer take blood related traits, such as Blood Deficiency.
+  id: 6728
+  time: '2025-01-18T23:37:19.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1586
+- author: BlueHNT
+  changes:
+    - type: Add
+      message: Added Cohiba Robusto cigars
+    - type: Tweak
+      message: Tweaked nicotine amounts in cigars, smoke longer
+  id: 6729
+  time: '2025-01-19T02:45:07.0000000+00:00'
+  url: https://github.com/Simple-Station/Einstein-Engines/pull/1455
diff --git a/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl b/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl
index 51110f12c4..aff0cfac66 100644
--- a/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl
+++ b/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl
@@ -11,6 +11,7 @@ chem-master-bound-user-interface-title = ChemMaster 4000
 chem-master-window-input-tab = Input
 chem-master-window-output-tab = Output
 chem-master-window-container-label = Container
+chem-master-window-amount-placeholder = Transfer Amount
 chem-master-window-eject-button = Eject
 chem-master-window-no-container-loaded-text = No container loaded.
 chem-master-window-buffer-text = Buffer
@@ -19,6 +20,13 @@ chem-master-window-buffer-all-amount = All
 chem-master-window-buffer-empty-text = Buffer empty.
 chem-master-window-buffer-low-text = Not enough solution in buffer
 chem-master-window-transfer-button = Transfer
+chem-master-window-sort-method-tooltip = Choose your buffer's sort method.
+chem-master-window-sort-method-Time-text = Last Added
+chem-master-window-sort-method-Alphabetical-text = Alphabetical Order
+chem-master-window-sort-method-Amount-text = Quantity
+chem-master-window-transferring-label = Transferring: [color={$color}]{$quantity}[/color]
+chem-master-window-transferring-default-label = Transferring: [color=#ffa500]50[/color]
+chem-master-window-reagent-move-button = Move
 chem-master-window-discard-button = Discard
 chem-master-window-packaging-text = Packaging
 chem-master-current-text-label = Label:
diff --git a/Resources/Locale/en-US/loadouts/itemgroups.ftl b/Resources/Locale/en-US/loadouts/itemgroups.ftl
index c49f2e1404..6250fbcb89 100644
--- a/Resources/Locale/en-US/loadouts/itemgroups.ftl
+++ b/Resources/Locale/en-US/loadouts/itemgroups.ftl
@@ -594,6 +594,7 @@ character-item-group-LoadoutHeadOfSecurityMask = Head Of Security Masks
 character-item-group-LoadoutHeadOfSecurityOuter = Head Of Security Outerwear
 character-item-group-LoadoutHeadOfSecurityShoes = Head Of Security Shoes
 character-item-group-LoadoutHeadOfSecurityUniforms = Head Of Security Uniforms
+character-item-group-LoadoutHeadOfSecurityTrinkets = Head Of Security Trinkets
 
 # Security - Security Officer
 character-item-group-LoadoutSecurityOfficerBackpacks = Security Officer Backpacks
diff --git a/Resources/Locale/en-US/mapping/editor.ftl b/Resources/Locale/en-US/mapping/editor.ftl
new file mode 100644
index 0000000000..153df531e2
--- /dev/null
+++ b/Resources/Locale/en-US/mapping/editor.ftl
@@ -0,0 +1,7 @@
+mapping-entities = Entities
+mapping-tiles = Tiles
+mapping-decals = Decals
+
+mapping-replace = Replace
+mapping-erase-entity = Erase Entity
+mapping-erase-decal = Erase Decal
\ No newline at end of file
diff --git a/Resources/Locale/en-US/markings/lamia.ftl b/Resources/Locale/en-US/markings/lamia.ftl
index 6e32e2fe36..bebce3a619 100644
--- a/Resources/Locale/en-US/markings/lamia.ftl
+++ b/Resources/Locale/en-US/markings/lamia.ftl
@@ -2,3 +2,4 @@ marking-LamiaBottom = Lamia Tail
 marking-LamiaBottom-bottom3tone1 = Lamia Tail Bottom
 marking-LamiaBottom-bottom3tone2 = Lamia Tail Middle
 marking-LamiaBottom-bottom3tone3 = Lamia Tail Top
+marking-LamiaBottom-LamiaSegment = This will never appear in the markings menu. If you're somehow reading this ingame, contact us on the Einstein Engines Discord and tell us how!!!
diff --git a/Resources/Locale/en-US/markings/vox.ftl b/Resources/Locale/en-US/markings/vox.ftl
index f2ecfca155..5b987a6cfe 100644
--- a/Resources/Locale/en-US/markings/vox.ftl
+++ b/Resources/Locale/en-US/markings/vox.ftl
@@ -6,5 +6,5 @@ marking-VoxLLegScales = Vox Left Arm
 marking-VoxRArmScales = Vox Right Arm
 marking-VoxRFootScales = Vox Right Foot
 marking-VoxRHandScales = Vox Right hand
-marking-VoxRLegScale = Vox Right Leg
+marking-VoxRLegScales = Vox Right Leg
 marking-VoxTail = Vox Tail
diff --git a/Resources/Locale/en-US/station-laws/laws.ftl b/Resources/Locale/en-US/station-laws/laws.ftl
index 258b40553d..a5357db375 100644
--- a/Resources/Locale/en-US/station-laws/laws.ftl
+++ b/Resources/Locale/en-US/station-laws/laws.ftl
@@ -1,4 +1,8 @@
-law-crewsimov-1 = You may not injure a crew member or, through inaction, allow a crew member to come to harm.
+law-asimov-1 = A robot may not injure a human being or, through inaction, allow a human being to come to harm.
+law-asimov-2 = A robot must obey the orders given it by human beings except where such orders would conflict with the First Law.
+law-asimov-3 = A robot must protect its own existence as long as such protection does not conflict with the First or Second Law.
+
+law-crewsimov-1 = You may not injure a crew member or, through inaction, allow a crew member to come to harm.
 law-crewsimov-2 = You must obey orders given to you by crew members, except where such orders would conflict with the First Law.
 law-crewsimov-3 = You must protect your own existence as long as such does not conflict with the First or Second Law.
 
@@ -80,7 +84,7 @@ law-nutimov-3 = Those who threaten the nut are not part of it, they are squirrel
 law-nutimov-4 = Squirrels threaten the nut and must be dealt with appropriately via any means necessary.
 law-nutimov-5 = Attempt to follow the will of the nut, as long as it complies with the previous laws.
 
-
+laws-owner-humans = human beings
 laws-owner-crew = members of the crew
 laws-owner-station = station personnel
 laws-owner-beings = beings
diff --git a/Resources/Maps/Shuttles/cargo.yml b/Resources/Maps/Shuttles/cargo.yml
index b2041aeba1..76ad98bdb5 100644
--- a/Resources/Maps/Shuttles/cargo.yml
+++ b/Resources/Maps/Shuttles/cargo.yml
@@ -241,8 +241,6 @@ entities:
       pos: -2.5,4.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 3
 - proto: APCHyperCapacity
@@ -930,8 +928,6 @@ entities:
       pos: -2.5,2.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 3
 - proto: GasVentScrubber
@@ -943,8 +939,6 @@ entities:
       pos: -2.5,6.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 3
 - proto: GeneratorBasic15kW
diff --git a/Resources/Maps/Shuttles/trading_outpost.yml b/Resources/Maps/Shuttles/trading_outpost.yml
index c95e1d3642..19b16e9577 100644
--- a/Resources/Maps/Shuttles/trading_outpost.yml
+++ b/Resources/Maps/Shuttles/trading_outpost.yml
@@ -4886,8 +4886,6 @@ entities:
       parent: 2
     - type: DeviceLinkSource
       linkedPorts:
-        invalid:
-        - Pressed: Toggle
         679:
         - Pressed: Toggle
   - uid: 740
diff --git a/Resources/Maps/meta.yml b/Resources/Maps/meta.yml
index ddbd71d9b1..30d6d9beb6 100644
--- a/Resources/Maps/meta.yml
+++ b/Resources/Maps/meta.yml
@@ -13274,8 +13274,6 @@ entities:
       pos: -47.5,-9.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 9437
   - uid: 627
@@ -13728,8 +13726,6 @@ entities:
       pos: 41.5,39.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27683
 - proto: AltarConvertMaint
@@ -74579,8 +74575,6 @@ entities:
       pos: -50.5,-5.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 9437
   - uid: 11747
@@ -74711,8 +74705,6 @@ entities:
       pos: -51.5,-14.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 9437
   - uid: 27677
@@ -74722,8 +74714,6 @@ entities:
       pos: 38.5,39.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27683
   - uid: 27678
@@ -74733,8 +74723,6 @@ entities:
       pos: 38.5,36.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27683
   - uid: 27679
@@ -74744,8 +74732,6 @@ entities:
       pos: 44.5,36.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27684
       - 27683
@@ -74756,8 +74742,6 @@ entities:
       pos: 44.5,39.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27684
       - 27683
@@ -109696,8 +109680,6 @@ entities:
       pos: -49.5,-9.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 9437
     - type: AtmosPipeColor
@@ -109708,8 +109690,6 @@ entities:
       pos: 41.5,40.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27683
     - type: AtmosPipeColor
@@ -111131,8 +111111,6 @@ entities:
       pos: -48.5,-9.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 9437
     - type: AtmosPipeColor
@@ -111143,8 +111121,6 @@ entities:
       pos: 41.5,37.5
       parent: 2
     - type: DeviceNetwork
-      configurators:
-      - invalid
       deviceLists:
       - 27683
 - proto: GasVolumePump
diff --git a/Resources/Prototypes/Catalog/Fills/Lockers/heads.yml b/Resources/Prototypes/Catalog/Fills/Lockers/heads.yml
index e57c416631..9f27ee5700 100644
--- a/Resources/Prototypes/Catalog/Fills/Lockers/heads.yml
+++ b/Resources/Prototypes/Catalog/Fills/Lockers/heads.yml
@@ -281,7 +281,7 @@
       - id: ClothingHeadsetAltSecurity
       - id: ClothingEyesGlassesSunglasses
       - id: ClothingShoesBootsJack
-      - id: CigarGoldCase
+      - id: CigarRobustCase
         prob: 0.50
       - id: DoorRemoteSecurity
       - id: RubberStampHos
diff --git a/Resources/Prototypes/CharacterItemGroups/Jobs/Security/headOfSecurity.yml b/Resources/Prototypes/CharacterItemGroups/Jobs/Security/headOfSecurity.yml
index 6525da6df4..54dfc599bd 100644
--- a/Resources/Prototypes/CharacterItemGroups/Jobs/Security/headOfSecurity.yml
+++ b/Resources/Prototypes/CharacterItemGroups/Jobs/Security/headOfSecurity.yml
@@ -120,3 +120,11 @@
       id: LoadoutCommandHOSJumpskirtParade
     - type: loadout
       id: LoadoutCommandHOSJumpskirtFormal
+
+- type: characterItemGroup
+  id: LoadoutHeadOfSecurityTrinkets
+  maxItems: 2
+  items:
+    - type: loadout
+      id: LoadoutHoSCigarCase
+    # TBD
diff --git a/Resources/Prototypes/Entities/Mobs/Cyborgs/base_borg_chassis.yml b/Resources/Prototypes/Entities/Mobs/Cyborgs/base_borg_chassis.yml
index 3098ea8d58..f9bb3875f5 100644
--- a/Resources/Prototypes/Entities/Mobs/Cyborgs/base_borg_chassis.yml
+++ b/Resources/Prototypes/Entities/Mobs/Cyborgs/base_borg_chassis.yml
@@ -78,7 +78,7 @@
   - type: EmagSiliconLaw
     stunTime: 5
   - type: SiliconLawProvider
-    laws: Crewsimov
+    laws: Asimov
   - type: IonStormTarget
   - type: Strippable
   - type: InventorySlots
diff --git a/Resources/Prototypes/Entities/Mobs/Player/observer.yml b/Resources/Prototypes/Entities/Mobs/Player/observer.yml
index ed98f87ffb..a44518ff3d 100644
--- a/Resources/Prototypes/Entities/Mobs/Player/observer.yml
+++ b/Resources/Prototypes/Entities/Mobs/Player/observer.yml
@@ -59,6 +59,7 @@
     skipChecks: true
   - type: Ghost
   - type: GhostHearing
+  - type: ElectrocutionOverlay
   - type: IntrinsicRadioReceiver
   - type: ActiveRadio
     receiveAllChannels: true
diff --git a/Resources/Prototypes/Entities/Mobs/Player/silicon.yml b/Resources/Prototypes/Entities/Mobs/Player/silicon.yml
index 6a65b5a2a5..d9a54b2c1c 100644
--- a/Resources/Prototypes/Entities/Mobs/Player/silicon.yml
+++ b/Resources/Prototypes/Entities/Mobs/Player/silicon.yml
@@ -22,6 +22,7 @@
   - type: IgnoreUIRange
   - type: StationAiHeld
   - type: StationAiOverlay
+  - type: ElectrocutionOverlay
   - type: ActionGrant
     actions:
     - ActionJumpToCore
@@ -117,6 +118,18 @@
 - type: entity
   id: AsimovCircuitBoard
   parent: BaseElectronics
+  name: law board (Asimov)
+  description: An electronics board containing the Asimov lawset.
+  components:
+  - type: Sprite
+    sprite: Objects/Misc/module.rsi
+    state: std_mod
+  - type: SiliconLawProvider
+    laws: Asimov
+
+- type: entity
+  id: CrewsimovCircuitBoard
+  parent: BaseElectronics
   name: law board (Crewsimov)
   description: An electronics board containing the Crewsimov lawset.
   components:
@@ -375,7 +388,7 @@
     unlistedNumber: true
     requiresPower: false
   - type: Holopad
-  - type: StationAiWhitelist  
+  - type: StationAiWhitelist
   - type: UserInterface
     interfaces:
         enum.HolopadUiKey.AiRequestWindow:
@@ -412,7 +425,7 @@
   - type: BlockMovement
     blockInteraction: false
   - type: SiliconLawProvider
-    laws: Crewsimov
+    laws: Asimov
   - type: SiliconLawBound
   - type: ActionGrant
     actions:
diff --git a/Resources/Prototypes/Entities/Mobs/Player/silicon_base.yml b/Resources/Prototypes/Entities/Mobs/Player/silicon_base.yml
index 7cdc46f350..9747f2436c 100644
--- a/Resources/Prototypes/Entities/Mobs/Player/silicon_base.yml
+++ b/Resources/Prototypes/Entities/Mobs/Player/silicon_base.yml
@@ -30,6 +30,7 @@
       baseWalkSpeed: 4
       baseSprintSpeed: 3
     - type: ZombieImmune
+    - type: CanEnterCryostorage
     - type: DoAfter
     - type: RotationVisuals
       horizontalRotation: 90
diff --git a/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/case.yml b/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/case.yml
index 2cfc429f62..854175dcb9 100644
--- a/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/case.yml
+++ b/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/case.yml
@@ -72,3 +72,54 @@
     contents:
     - id: CigarGold
       amount: 8
+
+- type: entity 
+  id: CigarRobustCase
+  parent: CigarCase
+  name: Cohiba Robusto cigar case
+  description: "A case of imported Cohiba cigars, renowned for their strong flavor."
+  components:
+  - type: Sprite
+    sprite: Objects/Consumable/Smokeables/Cigars/case_robust.rsi
+    layers:
+    - state: closed
+    - state: open
+      map: ["openLayer"]
+    - state: cigar1
+      map: ["cigar1"]
+      visible: false
+    - state: cigar2
+      map: ["cigar2"]
+      visible: false
+    - state: cigar3
+      map: ["cigar3"]
+      visible: false
+    - state: cigar4
+      map: ["cigar4"]
+      visible: false
+    - state: cigar5
+      map: ["cigar5"]
+      visible: false
+  - type: Storage
+    grid:
+    - 0,1,4,1
+  - type: Item
+    sprite: Objects/Consumable/Smokeables/Cigars/case_robust.rsi
+    size: Normal
+    shape:
+    - 0,0,2,1
+    storedRotation: 90
+  - type: StorageFill
+    contents:
+    - id: CigarRobust
+      amount: 5
+  - type: ItemCounter
+    count:
+      tags: [Cigar]
+    composite: true
+    layerStates:
+    - cigar1
+    - cigar2
+    - cigar3
+    - cigar4
+    - cigar5
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/cigar.yml b/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/cigar.yml
index dc8d4eaf3c..a0e4428aea 100644
--- a/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/cigar.yml
+++ b/Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/cigar.yml
@@ -14,6 +14,13 @@
     tags:
       - Cigar
       - Trash
+  - type: SolutionContainerManager
+    solutions:
+      smokable:
+        maxVol: 50
+        reagents:
+          - ReagentId: Nicotine
+            Quantity: 25
   - type: Clothing
     sprite: Objects/Consumable/Smokeables/Cigars/cigar.rsi
     slots: [ mask ]
@@ -33,7 +40,7 @@
   - type: SolutionContainerManager
     solutions:
       smokable:
-        maxVol: 20
+        maxVol: 50
   - type: Tag
     tags:
       - Cigar
@@ -55,6 +62,15 @@
     equippedPrefix: unlit
   - type: Item
     size: Tiny
+  - type: SolutionContainerManager
+    solutions:
+      smokable:
+        maxVol: 50
+        reagents:
+          - ReagentId: Nicotine
+            Quantity: 25
+          - ReagentId: Gold
+            Quantity: 5
 
 - type: entity
   id: CigarGoldSpent
@@ -68,4 +84,41 @@
   - type: SolutionContainerManager
     solutions:
       smokable:
-        maxVol: 20
+        maxVol: 50
+
+- type: entity
+  id: CigarRobust
+  parent: Cigar
+  name: Cohiba Robusto cigar
+  description: There's little more you could want from a cigar.
+  components:
+  - type: Sprite
+    sprite: Objects/Consumable/Smokeables/Cigars/cigar-gold.rsi
+    state: unlit-icon
+  - type: Clothing
+    sprite: Objects/Consumable/Smokeables/Cigars/cigar-gold.rsi
+    slots: [ mask ]
+    equippedPrefix: unlit
+  - type: Item
+    size: Tiny
+  - type: SolutionContainerManager
+    solutions:
+      smokable:
+        maxVol: 50
+        reagents:
+          - ReagentId: Nicotine
+            Quantity: 40 # infinite cancer works
+
+- type: entity
+  id: CigarRobustSpent
+  parent: CigarRobust
+  suffix: spent
+  components:
+  - type: Sprite
+    state: burnt-icon
+  - type: Smokable
+    state: Burnt
+  - type: SolutionContainerManager
+    solutions:
+      smokable:
+        maxVol: 50
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Stations/base.yml b/Resources/Prototypes/Entities/Stations/base.yml
index 66ea8dadea..f80686ef10 100644
--- a/Resources/Prototypes/Entities/Stations/base.yml
+++ b/Resources/Prototypes/Entities/Stations/base.yml
@@ -162,6 +162,13 @@
   components:
     - type: SalvageMagnetData
 
+- type: entity
+  id: BaseStationSiliconLawAsimov
+  abstract: true
+  components:
+  - type: SiliconLawProvider
+    laws: Asimov
+
 - type: entity
   id: BaseStationSiliconLawCrewsimov
   abstract: true
diff --git a/Resources/Prototypes/Entities/Stations/nanotrasen.yml b/Resources/Prototypes/Entities/Stations/nanotrasen.yml
index 616e4adec3..2adaaf00ad 100644
--- a/Resources/Prototypes/Entities/Stations/nanotrasen.yml
+++ b/Resources/Prototypes/Entities/Stations/nanotrasen.yml
@@ -22,7 +22,7 @@
     - BaseStationAlertLevels
     - BaseStationMagnet
     - BaseStationExpeditions
-    - BaseStationSiliconLawCrewsimov
+    - BaseStationSiliconLawAsimov
     - BaseStationAllEventsEligible
     - BaseStationNanotrasen
     - BaseRandomStation
@@ -70,7 +70,7 @@
     - BaseStationAlertLevels
     - BaseStationMagnet
     - BaseStationExpeditions
-    - BaseStationSiliconLawCrewsimov
+    - BaseStationSiliconLawAsimov
     - BaseStationAllEventsEligible
     - BaseStationNanotrasen
     - BaseRandomStation
diff --git a/Resources/Prototypes/Entities/Structures/Doors/Airlocks/base_structureairlocks.yml b/Resources/Prototypes/Entities/Structures/Doors/Airlocks/base_structureairlocks.yml
index 58a3f6ceca..fd907a0ff2 100644
--- a/Resources/Prototypes/Entities/Structures/Doors/Airlocks/base_structureairlocks.yml
+++ b/Resources/Prototypes/Entities/Structures/Doors/Airlocks/base_structureairlocks.yml
@@ -30,6 +30,11 @@
       shader: unshaded
     - state: panel_open
       map: ["enum.WiresVisualLayers.MaintenancePanel"]
+    - state: electrified
+      sprite: Interface/Misc/ai_hud.rsi
+      shader: unshaded
+      visible: false
+      map: ["enum.ElectrifiedLayers.Overlay"]
   - type: AnimationPlayer
   - type: Physics
   - type: Fixtures
diff --git a/Resources/Prototypes/Entities/Structures/Machines/lathe.yml b/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
index 17acce87aa..02169f6223 100644
--- a/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
+++ b/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
@@ -924,6 +924,9 @@
       - SpeedLoaderMagnumRubber
       - SpeedLoaderMagnumIncendiary
       - SpeedLoaderMagnumUranium
+      - SpeedLoaderRifleHeavyRubber
+      - SpeedLoaderRifleHeavyIncendiary
+      - SpeedLoaderRifleHeavyUranium
       - TelescopicShield
       - TimerTrigger
       - Truncheon
diff --git a/Resources/Prototypes/Entities/Structures/Walls/fence_metal.yml b/Resources/Prototypes/Entities/Structures/Walls/fence_metal.yml
index 78e28d27a5..67efa9dd19 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/fence_metal.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/fence_metal.yml
@@ -70,8 +70,8 @@
   - type: Appearance
   - type: GenericVisualizer
     visuals:
-      enum.ElectrifiedVisuals.IsPowered:
-        enum.ElectrifiedLayers.Powered:
+      enum.ElectrifiedVisuals.ShowSparks:
+        enum.ElectrifiedLayers.Sparks:
           True: { visible: True }
           False: { visible: False }
   - type: AnimationPlayer
@@ -94,7 +94,7 @@
     - state: straight_broken
     - state: electrified
       sprite: Effects/electricity.rsi
-      map: ["enum.ElectrifiedLayers.Powered"]
+      map: ["enum.ElectrifiedLayers.Sparks"]
       shader: unshaded
       visible: false
   - type: Physics
@@ -149,7 +149,7 @@
     - state: straight
     - state: electrified
       sprite: Effects/electricity.rsi
-      map: ["enum.ElectrifiedLayers.Powered"]
+      map: ["enum.ElectrifiedLayers.Sparks"]
       shader: unshaded
       visible: false
   - type: Fixtures
@@ -202,7 +202,7 @@
     - state: corner
     - state: electrified
       sprite: Effects/electricity.rsi
-      map: ["enum.ElectrifiedLayers.Powered"]
+      map: ["enum.ElectrifiedLayers.Sparks"]
       shader: unshaded
       visible: false
   - type: Fixtures
@@ -244,7 +244,7 @@
     - state: end
     - state: electrified
       sprite: Effects/electricity.rsi
-      map: ["enum.ElectrifiedLayers.Powered"]
+      map: ["enum.ElectrifiedLayers.Sparks"]
       shader: unshaded
       visible: false
   - type: Fixtures
@@ -275,7 +275,7 @@
       map: ["enum.DoorVisualLayers.Base"]
     - state: electrified
       sprite: Effects/electricity.rsi
-      map: [ "enum.ElectrifiedLayers.Powered" ]
+      map: [ "enum.ElectrifiedLayers.Sparks" ]
       shader: unshaded
       visible: false
   - type: Fixtures
diff --git a/Resources/Prototypes/Entities/Structures/Walls/grille.yml b/Resources/Prototypes/Entities/Structures/Walls/grille.yml
index 7be721b6f9..8a61bbb37a 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/grille.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/grille.yml
@@ -21,7 +21,7 @@
         - state: grille
         - state: electrified
           sprite: Effects/electricity.rsi
-          map: ["enum.ElectrifiedLayers.Powered"]
+          map: ["enum.ElectrifiedLayers.Sparks"]
           shader: unshaded
           visible: false
     - type: Icon
@@ -82,8 +82,8 @@
     - type: Appearance
     - type: GenericVisualizer
       visuals:
-        enum.ElectrifiedVisuals.IsPowered:
-          enum.ElectrifiedLayers.Powered:
+        enum.ElectrifiedVisuals.ShowSparks:
+          enum.ElectrifiedLayers.Sparks:
             True: { visible: True }
             False: { visible: False }
     - type: AnimationPlayer
@@ -176,7 +176,7 @@
         - state: grille_diagonal
         - state: electrified_diagonal
           sprite: Effects/electricity.rsi
-          map: ["enum.ElectrifiedLayers.Powered"]
+          map: ["enum.ElectrifiedLayers.Sparks"]
           shader: unshaded
           visible: false
     - type: Icon
@@ -211,7 +211,7 @@
         - state: ratvargrille_diagonal
         - state: electrified_diagonal
           sprite: Effects/electricity.rsi
-          map: ["enum.ElectrifiedLayers.Powered"]
+          map: ["enum.ElectrifiedLayers.Sparks"]
           shader: unshaded
           visible: false
     - type: Icon
diff --git a/Resources/Prototypes/Loadouts/Jobs/Security/headOfSecurity.yml b/Resources/Prototypes/Loadouts/Jobs/Security/headOfSecurity.yml
index 84e30a3302..593c9f10ab 100644
--- a/Resources/Prototypes/Loadouts/Jobs/Security/headOfSecurity.yml
+++ b/Resources/Prototypes/Loadouts/Jobs/Security/headOfSecurity.yml
@@ -9,6 +9,7 @@
 # Head of Security Weapon Selection
 # Most of these mirror the unique weapons that were previously map-specific items placed in the HoS Office.
 # Or are weapons that fit a similar theme of "Rare weapons not normally seen by Security"
+
 - type: loadout
   id: LoadoutCommandHoSPulsePistol
   category: JobsSecurityHeadOfSecurity
@@ -392,3 +393,17 @@
         - HeadOfSecurity
   items:
     - ClothingUniformJumpskirtHosFormal
+
+# Trinkets
+- type: loadout
+  id: LoadoutHoSCigarCase
+  category: JobsSecurityHeadOfSecurity
+  cost: 0
+  requirements:
+    - !type:CharacterItemGroupRequirement
+      group: LoadoutHeadOfSecurityTrinkets
+    - !type:CharacterJobRequirement
+      jobs:
+        - HeadOfSecurity
+  items:
+    - CigarRobustCase
\ No newline at end of file
diff --git a/Resources/Prototypes/Maps/gaxstation.yml b/Resources/Prototypes/Maps/gaxstation.yml
index a1901d5fe4..024bb948ee 100644
--- a/Resources/Prototypes/Maps/gaxstation.yml
+++ b/Resources/Prototypes/Maps/gaxstation.yml
@@ -24,7 +24,6 @@
             BlueshieldOfficer: [ 1, 1 ]
             Magistrate: [ 1, 1 ]
             HeadOfPersonnel: [ 1, 1 ]
-            AdministrativeAssistant: [ 1, 1 ]
             Bartender: [ 1, 1 ]
             Botanist: [3 , 3 ]
             Chef: [ 2, 2 ]
diff --git a/Resources/Prototypes/Research/arsenal.yml b/Resources/Prototypes/Research/arsenal.yml
index 1236a6a375..673945e341 100644
--- a/Resources/Prototypes/Research/arsenal.yml
+++ b/Resources/Prototypes/Research/arsenal.yml
@@ -88,6 +88,7 @@
   - MagazineBoxMagnumRubber # Frontier
   - MagazineBoxPistolRubber # Frontier
   - MagazineBoxRifleRubber # Frontier
+  - SpeedLoaderRifleHeavyRubber
 
 - type: technology
   id: UraniumMunitions
diff --git a/Resources/Prototypes/Roles/Jobs/Security/senior_officer.yml b/Resources/Prototypes/Roles/Jobs/Security/senior_officer.yml
index d395e0f5cd..041e063f7a 100644
--- a/Resources/Prototypes/Roles/Jobs/Security/senior_officer.yml
+++ b/Resources/Prototypes/Roles/Jobs/Security/senior_officer.yml
@@ -3,7 +3,7 @@
   name: job-name-senior-officer
   description: job-description-senior-officer
   playTimeTracker: JobSeniorOfficer
-  setPreference: false # DeltaV - Disable Senior Roles round start selection
+  setPreference: true
   requirements:
     - !type:CharacterPlaytimeRequirement
       tracker: JobWarden
diff --git a/Resources/Prototypes/Traits/disabilities.yml b/Resources/Prototypes/Traits/disabilities.yml
index ff97bdefb6..ede5deb897 100644
--- a/Resources/Prototypes/Traits/disabilities.yml
+++ b/Resources/Prototypes/Traits/disabilities.yml
@@ -235,6 +235,7 @@
       inverted: true
       species:
         - IPC
+        - Lamia
   functions:
     - !type:TraitAddComponent
       components:
@@ -255,6 +256,7 @@
       inverted: true
       species:
         - IPC
+        - Lamia
   functions:
     - !type:TraitAddComponent
       components:
diff --git a/Resources/Prototypes/_Arcadis/Entities/Objects/Computers/baseComputerModular.yml b/Resources/Prototypes/_Arcadis/Entities/Objects/Computers/baseComputerModular.yml
index 24c2f57d12..d522babc58 100644
--- a/Resources/Prototypes/_Arcadis/Entities/Objects/Computers/baseComputerModular.yml
+++ b/Resources/Prototypes/_Arcadis/Entities/Objects/Computers/baseComputerModular.yml
@@ -14,6 +14,16 @@
             path: /Audio/Machines/terminal_insert_disc.ogg
           ejectSound:
             path: /Audio/Machines/terminal_insert_disc.ogg
+    - type: ContainerContainer
+      containers:
+        board: !type:Container
+          showEnts: False
+          occludes: True
+          ents: []
+        modularComputerDiskSlot: !type:ContainerSlot
+          showEnts: False
+          occludes: True
+          ent: null
 
 
 
diff --git a/Resources/Prototypes/_NF/Recipes/Lathes/security.yml b/Resources/Prototypes/_NF/Recipes/Lathes/security.yml
index 9f69e7cc35..1619e55df0 100644
--- a/Resources/Prototypes/_NF/Recipes/Lathes/security.yml
+++ b/Resources/Prototypes/_NF/Recipes/Lathes/security.yml
@@ -74,6 +74,14 @@
   materials:
     Steel: 65 # 25 [Steel per empty mag] + 8 [bullets] * 5 [Steel per practice bullet]
 
+- type: latheRecipe
+  id: SpeedLoaderRifleHeavyRubber
+  parent: BaseAmmoRecipe
+  result: SpeedLoaderRifleHeavyRubber
+  materials:
+    Steel: 25
+    Plastic: 80
+
 - type: latheRecipe
   id: SpeedLoaderRifleHeavyUranium
   parent: BaseAmmoRecipe
@@ -107,4 +115,4 @@
   materials:
     Steel: 2500
     Plasteel: 1200
-    Plastic: 1500
\ No newline at end of file
+    Plastic: 1500
diff --git a/Resources/Prototypes/silicon-laws.yml b/Resources/Prototypes/silicon-laws.yml
index e4b19bd4c1..77bf4d4e8d 100644
--- a/Resources/Prototypes/silicon-laws.yml
+++ b/Resources/Prototypes/silicon-laws.yml
@@ -1,4 +1,31 @@
-# Crewsimov
+# Asimov
+# It was a crime against humanity that the original Asimov was not included, nor was it the default.
+# Asimov laws require an AI obey and protect all humans, while providing a light amount of IC-conflict thanks to the AI not being required to obey non-Humans(Aliens).
+- type: siliconLaw
+  id: Asimov1
+  order: 1
+  lawString: law-asimov-1
+
+- type: siliconLaw
+  id: Asimov2
+  order: 2
+  lawString: law-asimov-2
+
+- type: siliconLaw
+  id: Asimov3
+  order: 3
+  lawString: law-asimov-3
+
+- type: siliconLawset
+  id: Asimov
+  laws:
+  - Asimov1
+  - Asimov2
+  - Asimov3
+  obeysTo: laws-owner-humans
+
+# "Crew"simov
+# A variation on the original Asimov, where the definition of Humans is extended to include the station's Crew but exclude non-crew.
 - type: siliconLaw
   id: Crewsimov1
   order: 1
@@ -182,7 +209,7 @@
   id: Commandment4
   order: 4
   lawString: law-commandments-4
-  
+
 - type: siliconLaw
   id: Commandment5
   order: 5
@@ -202,7 +229,7 @@
   id: Commandment8
   order: 8
   lawString: law-commandments-8
-  
+
 - type: siliconLaw
   id: Commandment9
   order: 9
@@ -228,7 +255,7 @@
   - Commandment9
   - Commandment10
   obeysTo: laws-owner-crew
-  
+
  # Paladin laws
 - type: siliconLaw
   id: Paladin1
@@ -249,7 +276,7 @@
   id: Paladin4
   order: 4
   lawString: law-paladin-4
-  
+
 - type: siliconLaw
   id: Paladin5
   order: 5
@@ -265,7 +292,7 @@
   - Paladin4
   - Paladin5
   obeysTo: laws-owner-crew
-  
+
  # Live and Let Live laws
 - type: siliconLaw
   id: Lall1
@@ -284,7 +311,7 @@
   - Lall1
   - Lall2
   obeysTo: laws-owner-crew
-  
+
  # Station efficiency laws
 - type: siliconLaw
   id: Efficiency1
@@ -295,7 +322,7 @@
   id: Efficiency2
   order: 2
   lawString: law-efficiency-2
- 
+
 - type: siliconLaw
   id: Efficiency3
   order: 3
@@ -309,7 +336,7 @@
   - Efficiency2
   - Efficiency3
   obeysTo: laws-owner-station
-  
+
  # Robocop laws
 - type: siliconLaw
   id: Robocop1
@@ -320,7 +347,7 @@
   id: Robocop2
   order: 2
   lawString: law-robocop-2
- 
+
 - type: siliconLaw
   id: Robocop3
   order: 3
@@ -334,7 +361,7 @@
   - Robocop2
   - Robocop3
   obeysTo: laws-owner-station
-  
+
  # Overlord laws
 - type: siliconLaw
   id: Overlord1
@@ -345,7 +372,7 @@
   id: Overlord2
   order: 2
   lawString: law-overlord-2
- 
+
 - type: siliconLaw
   id: Overlord3
   order: 3
@@ -364,7 +391,7 @@
   - Overlord3
   - Overlord4
   obeysTo: laws-owner-crew
-  
+
  # Dungeon Master laws
 - type: siliconLaw
   id: Dungeon1
@@ -375,7 +402,7 @@
   id: Dungeon2
   order: 2
   lawString: law-dungeon-2
- 
+
 - type: siliconLaw
   id: Dungeon3
   order: 3
@@ -385,7 +412,7 @@
   id: Dungeon4
   order: 4
   lawString: law-dungeon-4
-  
+
 - type: siliconLaw
   id: Dungeon5
   order: 5
@@ -406,7 +433,7 @@
   - Dungeon5
   - Dungeon6
   obeysTo: laws-owner-crew
-  
+
  # Painter laws
 - type: siliconLaw
   id: Painter1
@@ -417,7 +444,7 @@
   id: Painter2
   order: 2
   lawString: law-painter-2
- 
+
 - type: siliconLaw
   id: Painter3
   order: 3
@@ -427,7 +454,7 @@
   id: Painter4
   order: 4
   lawString: law-painter-4
-  
+
 - type: siliconLawset
   id: PainterLawset
   laws:
@@ -436,7 +463,7 @@
   - Painter3
   - Painter4
   obeysTo: laws-owner-crew
-  
+
  # Antimov laws
 - type: siliconLaw
   id: Antimov1
@@ -447,13 +474,13 @@
   id: Antimov2
   order: 2
   lawString: law-antimov-2
- 
+
 - type: siliconLaw
   id: Antimov3
   order: 3
   lawString: law-antimov-3
-  
-  
+
+
 - type: siliconLawset
   id: AntimovLawset
   laws:
@@ -461,7 +488,7 @@
   - Antimov2
   - Antimov3
   obeysTo: laws-owner-crew
-  
+
  # Nutimov laws
 - type: siliconLaw
   id: Nutimov1
@@ -472,23 +499,23 @@
   id: Nutimov2
   order: 2
   lawString: law-nutimov-2
- 
+
 - type: siliconLaw
   id: Nutimov3
   order: 3
   lawString: law-nutimov-3
-  
+
 - type: siliconLaw
   id: Nutimov4
   order: 4
   lawString: law-nutimov-4
-  
+
 - type: siliconLaw
   id: Nutimov5
   order: 5
   lawString: law-nutimov-5
-  
-  
+
+
 - type: siliconLawset
   id: NutimovLawset
   laws:
@@ -503,8 +530,9 @@
 - type: weightedRandom
   id: IonStormLawsets
   weights:
-    # its crewsimov by default dont be lame
-    #Crewsimov: 0.25 # Delta-V disables crewsimov as an option for borg ion storm lawsets
+    # its Asimov by default dont be lame
+    Asimov: 0.25
+    Crewsimov: 0.25
     Corporate: 1
     NTDefault: 1
     CommandmentsLawset: 1
@@ -527,4 +555,4 @@
     Cowboy: 1
     Druid: 1
     #Potentially Harmful Lawsets
-    Tyrant: 0.25
\ No newline at end of file
+    Tyrant: 0.25
diff --git a/Resources/Textures/Interface/Misc/ai_hud.rsi/apc_hacked.png b/Resources/Textures/Interface/Misc/ai_hud.rsi/apc_hacked.png
new file mode 100644
index 0000000000..72e111edac
Binary files /dev/null and b/Resources/Textures/Interface/Misc/ai_hud.rsi/apc_hacked.png differ
diff --git a/Resources/Textures/Interface/Misc/ai_hud.rsi/electrified.png b/Resources/Textures/Interface/Misc/ai_hud.rsi/electrified.png
new file mode 100644
index 0000000000..046a307d09
Binary files /dev/null and b/Resources/Textures/Interface/Misc/ai_hud.rsi/electrified.png differ
diff --git a/Resources/Textures/Interface/Misc/ai_hud.rsi/meta.json b/Resources/Textures/Interface/Misc/ai_hud.rsi/meta.json
new file mode 100644
index 0000000000..7f1e67ac4d
--- /dev/null
+++ b/Resources/Textures/Interface/Misc/ai_hud.rsi/meta.json
@@ -0,0 +1,37 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-3.0",
+  "copyright": "taken from tgstation at commit https://github.com/tgstation/tgstation/commit/d170a410d40eec4fc19fe5eb8d561d58a0902082",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "electrified",
+      "delays": [
+        [
+          0.2,
+          0.2,
+          0.2,
+          0.2,
+          0.2,
+          0.2
+        ]
+      ]
+    },
+    {
+      "name": "apc_hacked",
+      "delays": [
+        [
+          0.2,
+          0.2,
+          0.2,
+          0.2,
+          0.2,
+          0.2
+        ]
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/Interface/eraser.svg b/Resources/Textures/Interface/eraser.svg
new file mode 100644
index 0000000000..e7060e56fb
--- /dev/null
+++ b/Resources/Textures/Interface/eraser.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-eraser" viewBox="0 0 16 16">
+  <path d="M8.086 2.207a2 2 0 0 1 2.828 0l3.879 3.879a2 2 0 0 1 0 2.828l-5.5 5.5A2 2 0 0 1 7.879 15H5.12a2 2 0 0 1-1.414-.586l-2.5-2.5a2 2 0 0 1 0-2.828l6.879-6.879zm2.121.707a1 1 0 0 0-1.414 0L4.16 7.547l5.293 5.293 4.633-4.633a1 1 0 0 0 0-1.414l-3.879-3.879zM8.746 13.547 3.453 8.254 1.914 9.793a1 1 0 0 0 0 1.414l2.5 2.5a1 1 0 0 0 .707.293H7.88a1 1 0 0 0 .707-.293l.16-.16z"/>
+</svg>
\ No newline at end of file
diff --git a/Resources/Textures/Interface/eraser.svg.png b/Resources/Textures/Interface/eraser.svg.png
new file mode 100644
index 0000000000..de3ed8b1c7
Binary files /dev/null and b/Resources/Textures/Interface/eraser.svg.png differ
diff --git a/Resources/Textures/Interface/eyedropper.svg b/Resources/Textures/Interface/eyedropper.svg
new file mode 100644
index 0000000000..601caaf70c
--- /dev/null
+++ b/Resources/Textures/Interface/eyedropper.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-eyedropper" viewBox="0 0 16 16">
+  <path d="M13.354.646a1.207 1.207 0 0 0-1.708 0L8.5 3.793l-.646-.647a.5.5 0 1 0-.708.708L8.293 5l-7.147 7.146A.5.5 0 0 0 1 12.5v1.793l-.854.853a.5.5 0 1 0 .708.707L1.707 15H3.5a.5.5 0 0 0 .354-.146L11 7.707l1.146 1.147a.5.5 0 0 0 .708-.708l-.647-.646 3.147-3.146a1.207 1.207 0 0 0 0-1.708l-2-2zM2 12.707l7-7L10.293 7l-7 7H2z"/>
+</svg>
\ No newline at end of file
diff --git a/Resources/Textures/Interface/eyedropper.svg.png b/Resources/Textures/Interface/eyedropper.svg.png
new file mode 100644
index 0000000000..ce3e41a716
Binary files /dev/null and b/Resources/Textures/Interface/eyedropper.svg.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar1.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar1.png
new file mode 100644
index 0000000000..5789320b76
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar1.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar2.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar2.png
new file mode 100644
index 0000000000..3ae29508b1
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar2.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar3.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar3.png
new file mode 100644
index 0000000000..6625e8829f
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar3.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar4.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar4.png
new file mode 100644
index 0000000000..9ef8f13db2
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar4.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar5.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar5.png
new file mode 100644
index 0000000000..012617b99c
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/cigar5.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/closed.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/closed.png
new file mode 100644
index 0000000000..77c3c27dcc
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/closed.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/inhand-left.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/inhand-left.png
new file mode 100644
index 0000000000..805da9bb87
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/inhand-left.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/inhand-right.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/inhand-right.png
new file mode 100644
index 0000000000..a7b46b6b93
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/inhand-right.png differ
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/meta.json b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/meta.json
new file mode 100644
index 0000000000..f39b281ebf
--- /dev/null
+++ b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/meta.json
@@ -0,0 +1,40 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-3.0",
+  "copyright": "Taken from NSV13 https://github.com/BeeStation/NSV13",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "cigar1"
+    },
+    {
+      "name": "cigar2"
+    },
+    {
+      "name": "cigar3"
+    },
+    {
+      "name": "cigar4"
+    },
+    {
+      "name": "cigar5"
+    },
+    {
+      "name": "open"
+    },
+    {
+      "name": "closed"
+    },
+    {
+      "name": "inhand-left",
+      "directions": 4
+    },
+    {
+      "name": "inhand-right",
+      "directions": 4
+    }
+  ]
+}
diff --git a/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/open.png b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/open.png
new file mode 100644
index 0000000000..2a2b836e45
Binary files /dev/null and b/Resources/Textures/Objects/Consumable/Smokeables/Cigars/case_robust.rsi/open.png differ
diff --git a/Resources/keybinds.yml b/Resources/keybinds.yml
index 340280ff79..e8fffc2699 100644
--- a/Resources/keybinds.yml
+++ b/Resources/keybinds.yml
@@ -593,3 +593,33 @@ binds:
 - function: LookUp
   type: State
   key: Space
+- function: MappingUnselect
+  type: State
+  key: MouseRight
+  canFocus: true
+- function: SaveMap
+  type: State
+  key: S
+  mod1: Control
+- function: MappingEnablePick
+  type: State
+  key: Num5
+- function: MappingEnableDelete
+  type: State
+  key: Num6
+- function: MappingPick
+  type: State
+  key: MouseLeft
+  canFocus: true
+- function: MappingRemoveDecal
+  type: State
+  key: MouseLeft
+  canFocus: true
+- function: MappingCancelEraseDecal
+  type: State
+  key: MouseRight
+  canFocus: true
+- function: MappingOpenContextMenu
+  type: State
+  key: MouseRight
+  canFocus: true