diff --git a/Content.Client/_Goobstation/Heretic/EntitySystems/GhoulSystem.cs b/Content.Client/_Goobstation/Heretic/EntitySystems/GhoulSystem.cs
new file mode 100644
index 0000000000000..8395d66a0f57e
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/EntitySystems/GhoulSystem.cs
@@ -0,0 +1,46 @@
+using Content.Shared.Examine;
+using Content.Shared.Ghost.Roles.Components;
+using Content.Shared.Heretic;
+using Content.Shared.Humanoid;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Nutrition.AnimalHusbandry;
+using Content.Shared.Nutrition.Components;
+using Content.Shared.Zombies;
+using Robust.Client.GameObjects;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Client.Heretic.EntitySystems
+{
+    public sealed partial class GhoulSystem : Shared.Heretic.EntitySystems.SharedGhoulSystem
+    {
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<GhoulComponent, ComponentStartup>(OnStartup);
+
+        }
+
+
+        public void OnStartup(EntityUid uid, GhoulComponent component, ComponentStartup args) {
+            var ghoulcolor = Color.FromHex("#505050");
+
+            if (!HasComp<HumanoidAppearanceComponent>(uid))
+            {
+                if (!TryComp<SpriteComponent>(uid, out var sprite))
+                    return;
+
+                for (var i = 0; i < sprite.AllLayers.Count(); i++)
+                {
+                    sprite.LayerSetColor(i, ghoulcolor);
+                }
+            }
+        }
+    }
+}
diff --git a/Content.Client/_Goobstation/Heretic/HereticCombatMarkSystem.cs b/Content.Client/_Goobstation/Heretic/HereticCombatMarkSystem.cs
new file mode 100644
index 0000000000000..5848b9a2b4988
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/HereticCombatMarkSystem.cs
@@ -0,0 +1,61 @@
+using Content.Shared.Heretic;
+using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Heretic;
+
+public sealed partial class HereticCombatMarkSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticCombatMarkComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<HereticCombatMarkComponent, ComponentShutdown>(OnShutdown);
+    }
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        // i can't think of a better way to do this. everything else has failed
+        // god i hate client server i hate client server i hate client server i hate
+        foreach (var mark in EntityQuery<HereticCombatMarkComponent>())
+        {
+            if (!TryComp<SpriteComponent>(mark.Owner, out var sprite))
+                continue;
+
+            if (!sprite.LayerMapTryGet(0, out var layer))
+                continue;
+
+            sprite.LayerSetState(layer, mark.Path.ToLower());
+        }
+    }
+
+    private void OnStartup(Entity<HereticCombatMarkComponent> ent, ref ComponentStartup args)
+    {
+        if (!TryComp<SpriteComponent>(ent, out var sprite))
+            return;
+
+        if (sprite.LayerMapTryGet(0, out var l))
+        {
+            sprite.LayerSetState(l, ent.Comp.Path.ToLower());
+            return;
+        }
+
+        var rsi = new SpriteSpecifier.Rsi(new ResPath("_Goobstation/Heretic/combat_marks.rsi"), ent.Comp.Path.ToLower());
+        var layer = sprite.AddLayer(rsi);
+
+        sprite.LayerMapSet(0, layer);
+        sprite.LayerSetShader(layer, "unshaded");
+    }
+    private void OnShutdown(Entity<HereticCombatMarkComponent> ent, ref ComponentShutdown args)
+    {
+        if (!TryComp<SpriteComponent>(ent, out var sprite))
+            return;
+
+        if (!sprite.LayerMapTryGet(0, out var layer))
+            return;
+
+        sprite.RemoveLayer(layer);
+    }
+}
diff --git a/Content.Client/_Goobstation/Heretic/HereticRitualRuneBoundUserInterface.cs b/Content.Client/_Goobstation/Heretic/HereticRitualRuneBoundUserInterface.cs
new file mode 100644
index 0000000000000..b1a44e1790ba3
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/HereticRitualRuneBoundUserInterface.cs
@@ -0,0 +1,39 @@
+using Content.Client._Goobstation.Heretic.UI;
+using Content.Shared._Goobstation.Heretic.Components;
+using Content.Shared.Heretic.Prototypes;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.UserInterface;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._Goobstation.Heretic;
+
+public sealed class HereticRitualRuneBoundUserInterface : BoundUserInterface
+{
+    [Dependency] private readonly IClyde _displayManager = default!;
+    [Dependency] private readonly IInputManager _inputManager = default!;
+
+    private HereticRitualRuneRadialMenu? _hereticRitualMenu;
+
+    public HereticRitualRuneBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+        IoCManager.InjectDependencies(this);
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _hereticRitualMenu = this.CreateWindow<HereticRitualRuneRadialMenu>();
+        _hereticRitualMenu.SetEntity(Owner);
+        _hereticRitualMenu.SendHereticRitualRuneMessageAction += SendHereticRitualMessage;
+
+        var vpSize = _displayManager.ScreenSize;
+        _hereticRitualMenu.OpenCenteredAt(_inputManager.MouseScreenPosition.Position / vpSize);
+    }
+
+    private void SendHereticRitualMessage(ProtoId<HereticRitualPrototype> protoId)
+    {
+        SendMessage(new HereticRitualMessage(protoId));
+    }
+}
diff --git a/Content.Client/_Goobstation/Heretic/Ritual.CustomBehaviors.cs b/Content.Client/_Goobstation/Heretic/Ritual.CustomBehaviors.cs
new file mode 100644
index 0000000000000..9730a08affacf
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/Ritual.CustomBehaviors.cs
@@ -0,0 +1,67 @@
+using Content.Shared.Heretic.Prototypes;
+
+namespace Content.Client.Heretic;
+
+// these do nothing and are there just for yaml limter to shut the fuck up.
+// make sure they stay up in sync with the server counterpart.
+// regards.
+// - john
+
+public sealed partial class RitualAshAscendBehavior : RitualSacrificeBehavior { }
+public sealed partial class RitualMuteGhoulifyBehavior : RitualSacrificeBehavior { }
+
+[Virtual] public partial class RitualSacrificeBehavior : RitualCustomBehavior
+{
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        outstr = null;
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        // do nothing
+    }
+}
+
+public sealed partial class RitualTemperatureBehavior : RitualCustomBehavior
+{
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        outstr = null;
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        // do nothing
+    }
+}
+
+public sealed partial class RitualReagentPuddleBehavior : RitualCustomBehavior
+{
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        outstr = null;
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        // do nothing
+    }
+}
+
+public sealed partial class RitualKnowledgeBehavior : RitualCustomBehavior
+{
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        outstr = null;
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        // do nothing
+    }
+}
diff --git a/Content.Client/_Goobstation/Heretic/UI/HellMemoryEui.cs b/Content.Client/_Goobstation/Heretic/UI/HellMemoryEui.cs
new file mode 100644
index 0000000000000..bb9de08ac5123
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/UI/HellMemoryEui.cs
@@ -0,0 +1,25 @@
+using Content.Client.Eui;
+
+namespace Content.Client._Goobstation.Heretic.UI;
+
+public sealed class HellMemoryEui : BaseEui
+{
+    private readonly HellMemoryMenu _menu;
+
+    public HellMemoryEui()
+    {
+        _menu = new HellMemoryMenu();
+    }
+
+    public override void Opened()
+    {
+        _menu.OpenCentered();
+    }
+
+    public override void Closed()
+    {
+        base.Closed();
+
+        _menu.Close();
+    }
+}
diff --git a/Content.Client/_Goobstation/Heretic/UI/HellMemoryMenu.xaml b/Content.Client/_Goobstation/Heretic/UI/HellMemoryMenu.xaml
new file mode 100644
index 0000000000000..48742c08692a1
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/UI/HellMemoryMenu.xaml
@@ -0,0 +1,10 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      Title="{Loc 'hell-memory-title'}">
+    <BoxContainer Orientation="Vertical" Margin="5">
+        <Label Text="{Loc 'hell-memory-text'}"/>
+        <BoxContainer Orientation="Horizontal" Align="Center">
+            <Button Name="ConfirmButton" Text="{Loc 'hell-memory-confirm'}"/>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_Goobstation/Heretic/UI/HellMemoryMenu.xaml.cs b/Content.Client/_Goobstation/Heretic/UI/HellMemoryMenu.xaml.cs
new file mode 100644
index 0000000000000..50db667362ffa
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/UI/HellMemoryMenu.xaml.cs
@@ -0,0 +1,17 @@
+using Content.Client.UserInterface.Controls;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._Goobstation.Heretic.UI;
+
+
+[GenerateTypedNameReferences]
+public sealed partial class HellMemoryMenu : FancyWindow
+{
+    public HellMemoryMenu()
+    {
+        RobustXamlLoader.Load(this);
+
+        ConfirmButton.OnPressed += _ => Close();
+    }
+}
diff --git a/Content.Client/_Goobstation/Heretic/UI/HereticRitualRuneRadialMenu.xaml b/Content.Client/_Goobstation/Heretic/UI/HereticRitualRuneRadialMenu.xaml
new file mode 100644
index 0000000000000..cfa0b93234e7c
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/UI/HereticRitualRuneRadialMenu.xaml
@@ -0,0 +1,13 @@
+<ui:RadialMenu xmlns="https://spacestation14.io"
+                xmlns:ui="clr-namespace:Content.Client.UserInterface.Controls"
+                BackButtonStyleClass="RadialMenuBackButton"
+                CloseButtonStyleClass="RadialMenuCloseButton"
+                VerticalExpand="True"
+                HorizontalExpand="True"
+                MinSize="450 450">
+
+    <!-- Main -->
+    <ui:RadialContainer Name="Main" VerticalExpand="True" HorizontalExpand="True" InitialRadius="100" ReserveSpaceForHiddenChildren="False">
+    </ui:RadialContainer>
+
+</ui:RadialMenu>
diff --git a/Content.Client/_Goobstation/Heretic/UI/HereticRitualRuneRadialMenu.xaml.cs b/Content.Client/_Goobstation/Heretic/UI/HereticRitualRuneRadialMenu.xaml.cs
new file mode 100644
index 0000000000000..622f76cd88914
--- /dev/null
+++ b/Content.Client/_Goobstation/Heretic/UI/HereticRitualRuneRadialMenu.xaml.cs
@@ -0,0 +1,100 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Heretic;
+using Content.Shared.Heretic.Prototypes;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using System.Numerics;
+
+namespace Content.Client._Goobstation.Heretic.UI;
+
+public sealed partial class HereticRitualRuneRadialMenu : RadialMenu
+{
+    [Dependency] private readonly EntityManager _entityManager = default!;
+    [Dependency] private readonly IEntitySystemManager _entitySystem = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly ISharedPlayerManager _playerManager = default!;
+    private readonly SpriteSystem _spriteSystem;
+
+    public event Action<ProtoId<HereticRitualPrototype>>? SendHereticRitualRuneMessageAction;
+
+    public EntityUid Entity { get; set; }
+
+    public HereticRitualRuneRadialMenu()
+    {
+        IoCManager.InjectDependencies(this);
+        RobustXamlLoader.Load(this);
+        _spriteSystem = _entitySystem.GetEntitySystem<SpriteSystem>();
+    }
+
+    public void SetEntity(EntityUid uid)
+    {
+        Entity = uid;
+        RefreshUI();
+    }
+
+    private void RefreshUI()
+    {
+        var main = FindControl<RadialContainer>("Main");
+        if (main == null)
+            return;
+
+        var player = _playerManager.LocalEntity;
+
+        if (!_entityManager.TryGetComponent<HereticComponent>(player, out var heretic))
+            return;
+
+        foreach (var ritual in heretic.KnownRituals)
+        {
+            if (!_prototypeManager.TryIndex(ritual, out var ritualPrototype))
+                continue;
+
+            var button = new HereticRitualMenuButton
+            {
+                SetSize = new Vector2(64, 64),
+                ToolTip = Loc.GetString(ritualPrototype.LocName),
+                ProtoId = ritualPrototype.ID
+            };
+
+            var texture = new TextureRect
+            {
+                VerticalAlignment = VAlignment.Center,
+                HorizontalAlignment = HAlignment.Center,
+                Texture = _spriteSystem.Frame0(ritualPrototype.Icon),
+                TextureScale = new Vector2(2f, 2f)
+            };
+
+            button.AddChild(texture);
+            main.AddChild(button);
+        }
+
+        AddHereticRitualMenuButtonOnClickAction(main);
+    }
+
+    private void AddHereticRitualMenuButtonOnClickAction(RadialContainer mainControl)
+    {
+        if (mainControl == null)
+            return;
+
+        foreach(var child in mainControl.Children)
+        {
+            var castChild = child as HereticRitualMenuButton;
+
+            if (castChild == null)
+                continue;
+
+            castChild.OnButtonUp += _ =>
+            {
+                SendHereticRitualRuneMessageAction?.Invoke(castChild.ProtoId);
+                Close();
+            };
+        }
+    }
+
+    public sealed class HereticRitualMenuButton : RadialMenuTextureButtonWithSector
+    {
+        public ProtoId<HereticRitualPrototype> ProtoId { get; set; }
+    }
+}
diff --git a/Content.Server/Polymorph/Systems/PolymorphSystem.cs b/Content.Server/Polymorph/Systems/PolymorphSystem.cs
index ddbde38a08c99..6ebfb9876315a 100644
--- a/Content.Server/Polymorph/Systems/PolymorphSystem.cs
+++ b/Content.Server/Polymorph/Systems/PolymorphSystem.cs
@@ -5,7 +5,6 @@
 using Content.Server.Polymorph.Components;
 using Content.Shared.Actions;
 using Content.Shared.Buckle;
-using Content.Shared.Coordinates;
 using Content.Shared.Damage;
 using Content.Shared.Destructible;
 using Content.Shared.Hands.EntitySystems;
@@ -278,10 +277,6 @@ private void OnDestruction(Entity<PolymorphedEntityComponent> ent, ref Destructi
         var ev = new PolymorphedEvent(uid, child, false);
         RaiseLocalEvent(uid, ref ev);
 
-        // visual effect spawn
-        if (configuration.EffectProto != null)
-            SpawnAttachedTo(configuration.EffectProto, child.ToCoordinates());
-
         return child;
     }
 
@@ -358,10 +353,6 @@ private void OnDestruction(Entity<PolymorphedEntityComponent> ent, ref Destructi
         var ev = new PolymorphedEvent(uid, parent, true);
         RaiseLocalEvent(uid, ref ev);
 
-        // visual effect spawn
-        if (component.Configuration.EffectProto != null)
-            SpawnAttachedTo(component.Configuration.EffectProto, parent.ToCoordinates());
-
         if (component.Configuration.ExitPolymorphPopup != null)
             _popup.PopupEntity(Loc.GetString(component.Configuration.ExitPolymorphPopup,
                 ("parent", Identity.Entity(uid, EntityManager)),
@@ -369,6 +360,9 @@ private void OnDestruction(Entity<PolymorphedEntityComponent> ent, ref Destructi
                 parent);
         QueueDel(uid);
 
+        // goob edit
+        RaiseLocalEvent(parent, new PolymorphRevertEvent());
+
         return parent;
     }
 
@@ -415,3 +409,6 @@ public void RemovePolymorphAction(ProtoId<PolymorphPrototype> id, Entity<Polymor
             _actions.RemoveAction(target, val);
     }
 }
+
+// goob edit
+public sealed partial class PolymorphRevertEvent : EntityEventArgs { }
diff --git a/Content.Server/_DV/StationEvents/Components/DebrisSpawnerRuleComponent.cs b/Content.Server/_DV/StationEvents/Components/DebrisSpawnerRuleComponent.cs
new file mode 100644
index 0000000000000..0f89e161fc836
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Components/DebrisSpawnerRuleComponent.cs
@@ -0,0 +1,30 @@
+/*
+* Delta-V - This file is licensed under AGPLv3
+* Copyright (c) 2024 Delta-V Contributors
+* See AGPLv3.txt for details.
+*/
+
+using Content.Server.StationEvents.Events;
+
+namespace Content.Server.StationEvents.Components;
+
+/// <summary>
+/// Spawns random debris in space around a loaded grid.
+/// Requires <see cref="LoadFarGridRuleComponent"/>.
+/// </summary>
+[RegisterComponent, Access(typeof(DebrisSpawnerRule))]
+public sealed partial class DebrisSpawnerRuleComponent : Component
+{
+    /// <summary>
+    /// How many debris grids to spawn.
+    /// </summary>
+    [DataField(required: true)]
+    public int Count;
+
+    /// <summary>
+    /// Modifier for debris distance.
+    /// Should be between 3 and 10 generally.
+    /// </summary>
+    [DataField(required: true)]
+    public float DistanceModifier;
+}
diff --git a/Content.Server/_DV/StationEvents/Components/FugitiveRuleComponent.cs b/Content.Server/_DV/StationEvents/Components/FugitiveRuleComponent.cs
new file mode 100644
index 0000000000000..1150994982b42
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Components/FugitiveRuleComponent.cs
@@ -0,0 +1,87 @@
+using Content.Shared.Dataset;
+using Content.Server.StationEvents.Events;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using Robust.Shared.Utility;
+
+namespace Content.Server.StationEvents.Components;
+
+/// <summary>
+/// Makes a GALPOL announcement and creates a report some time after an antag spawns.
+/// Removed after this is done.
+/// </summary>
+[RegisterComponent, Access(typeof(FugitiveRule))]
+[AutoGenerateComponentPause]
+public sealed partial class FugitiveRuleComponent : Component
+{
+    [DataField]
+    public LocId Announcement = "station-event-fugitive-hunt-announcement";
+
+    [DataField]
+    public LocId Sender = "fugitive-announcement-GALPOL";
+
+    [DataField]
+    public Color Color = Color.Yellow;
+
+    /// <summary>
+    /// Report paper to spawn. Its content is generated from the fugitive.
+    /// </summary>
+    [DataField]
+    public EntProtoId ReportPaper = "PaperFugitiveReport";
+
+    /// <summary>
+    /// How long to wait after the antag spawns before announcing it.
+    /// </summary>
+    [DataField]
+    public TimeSpan AnnounceDelay = TimeSpan.FromMinutes(5);
+
+    /// <summary>
+    /// Station to give the report to.
+    /// </summary>
+    [DataField]
+    public EntityUid? Station;
+
+    /// <summary>
+    /// The report generated for the spawned fugitive.
+    /// </summary>
+    [DataField]
+    public string Report = string.Empty;
+
+    /// <summary>
+    /// When the announcement will be made, if an antag has spawned yet.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan? NextAnnounce;
+
+    /// <summary>
+    /// Dataset to pick crimes on the report from.
+    /// </summary>
+    [DataField]
+    public ProtoId<LocalizedDatasetPrototype> CrimesDataset = "FugitiveCrimes";
+
+    /// <summary>
+    /// Max number of unique crimes they can be charged with.
+    /// Does not affect the counts of each crime.
+    /// </summary>
+    [DataField]
+    public int MinCrimes = 2;
+
+    /// <summary>
+    /// Min number of unique crimes they can be charged with.
+    /// Does not affect the counts of each crime.
+    /// </summary>
+    [DataField]
+    public int MaxCrimes = 7;
+
+    /// <summary>
+    /// Min counts of each crime that can be rolled.
+    /// </summary>
+    [DataField]
+    public int MinCounts = 1;
+
+    /// <summary>
+    /// Max counts of each crime that can be rolled.
+    /// </summary>
+    [DataField]
+    public int MaxCounts = 4;
+}
diff --git a/Content.Server/_DV/StationEvents/Components/LoadFarGridRuleComponent.cs b/Content.Server/_DV/StationEvents/Components/LoadFarGridRuleComponent.cs
new file mode 100644
index 0000000000000..2c67e491f1987
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Components/LoadFarGridRuleComponent.cs
@@ -0,0 +1,31 @@
+using Content.Server.StationEvents.Events;
+using Robust.Shared.Utility;
+
+namespace Content.Server.StationEvents.Components;
+
+/// <summary>
+/// Loads a grid far away from a random station.
+/// Requires <see cref="RuleGridsComponent"/>.
+/// </summary>
+[RegisterComponent, Access(typeof(LoadFarGridRule))]
+public sealed partial class LoadFarGridRuleComponent : Component
+{
+    /// <summary>
+    /// Path to the grid to spawn.
+    /// </summary>
+    [DataField(required: true)]
+    public ResPath Path = new();
+
+    /// <summary>
+    /// Roughly how many AABBs away
+    /// </summary>
+    [DataField(required: true)]
+    public float DistanceModifier;
+
+    /// <summary>
+    /// "Stations of Unusual Size Constant", derived from the AABB.Width of Shoukou.
+    /// This Constant is used to check the size of a station relative to the reference point
+    /// </summary>
+    [DataField]
+    public float Sousk = 123.44f;
+}
diff --git a/Content.Server/_DV/StationEvents/Components/MidRoundAntagRuleComponent.cs b/Content.Server/_DV/StationEvents/Components/MidRoundAntagRuleComponent.cs
new file mode 100644
index 0000000000000..e2d5a65ceeaf3
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Components/MidRoundAntagRuleComponent.cs
@@ -0,0 +1,10 @@
+namespace Content.Server.StationEvents.Components;
+
+// Impstation this is MIT code licenced under Nyanotrasen namespace
+
+/// <summary>
+/// Spawns any antags at random midround antag spawnpoints, falls back to vent critter spawners.
+/// Requires <c>AntagSelection</c>.
+/// </summary>
+[RegisterComponent]
+public sealed partial class MidRoundAntagRuleComponent : Component;
diff --git a/Content.Server/_DV/StationEvents/Components/MidRoundAntagSpawnLocationComponent.cs b/Content.Server/_DV/StationEvents/Components/MidRoundAntagSpawnLocationComponent.cs
new file mode 100644
index 0000000000000..013b55a50ffde
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Components/MidRoundAntagSpawnLocationComponent.cs
@@ -0,0 +1,6 @@
+namespace Content.Server.StationEvents;
+
+// Impstation this is MIT code licenced under Nyanotrasen namespace
+
+[RegisterComponent]
+public sealed partial class MidRoundAntagSpawnLocationComponent : Component;
diff --git a/Content.Server/_DV/StationEvents/Events/DebrisSpawnerRule.cs b/Content.Server/_DV/StationEvents/Events/DebrisSpawnerRule.cs
new file mode 100644
index 0000000000000..88ca24ef88e69
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Events/DebrisSpawnerRule.cs
@@ -0,0 +1,64 @@
+/*
+* Delta-V - This file is licensed under AGPLv3
+* Copyright (c) 2024 Delta-V Contributors
+* See AGPLv3.txt for details.
+*/
+
+using Content.Server.GameTicking.Rules;
+using Content.Server.Station.Components;
+using Content.Server.StationEvents.Components;
+using Content.Shared.CCVar;
+using Content.Shared.Salvage;
+using Robust.Server.GameObjects;
+using Robust.Shared.Configuration;
+using Robust.Shared.EntitySerialization.Systems;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using System.Linq;
+
+namespace Content.Server.StationEvents.Events;
+
+public sealed class DebrisSpawnerRule : StationEventSystem<DebrisSpawnerRuleComponent>
+{
+    [Dependency] private readonly IConfigurationManager _config = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly MapLoaderSystem _mapLoader = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<DebrisSpawnerRuleComponent, RuleLoadedGridsEvent>(OnLoadedGrids);
+    }
+
+    private void OnLoadedGrids(Entity<DebrisSpawnerRuleComponent> ent, ref RuleLoadedGridsEvent args)
+    {
+        if (_config.GetCVar<bool>(CCVars.WorldgenEnabled))
+            return;
+
+        // get world AABBs of every grid that was loaded, probably just 1 anyway
+        var boxes = new List<Box2>(args.Grids.Count);
+        foreach (var gridId in args.Grids)
+        {
+            var grid = Comp<MapGridComponent>(gridId);
+            var aabb = Transform(gridId).WorldMatrix.TransformBox(grid.LocalAABB);
+            boxes.Add(aabb);
+        }
+
+        // fetch all the salvage maps that can be picked
+        var salvageMaps = _proto.EnumeratePrototypes<SalvageMapPrototype>().ToList();
+
+        // spawn them!
+        for (var i = 0; i < ent.Comp.Count; i++)
+        {
+            var aabb = RobustRandom.Pick(boxes);
+            var dist = MathF.Max(aabb.Height / 2f, aabb.Width / 2f) * ent.Comp.DistanceModifier;
+
+            var offset = RobustRandom.NextVector2(dist, dist * 2.5f);
+            var randomer = RobustRandom.NextVector2(dist, dist * 5f); //Second random vector to ensure the outpost isn't perfectly centered in the debris field
+            var salvage = RobustRandom.PickAndTake(salvageMaps);
+            _mapLoader.TryLoadGrid(args.Map, salvage.MapPath, out _, offset: aabb.Center + offset + randomer);
+        }
+    }
+}
diff --git a/Content.Server/_DV/StationEvents/Events/FugitiveRule.cs b/Content.Server/_DV/StationEvents/Events/FugitiveRule.cs
new file mode 100644
index 0000000000000..0e726ffd73cf6
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Events/FugitiveRule.cs
@@ -0,0 +1,177 @@
+using Content.Server.Antag;
+using Content.Server.Communications;
+using Content.Server.StationEvents.Components;
+using Content.Shared.Forensics.Components;
+using Content.Shared.GameTicking.Components;
+using Content.Shared.Ghost;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Prototypes;
+using Content.Shared.Inventory;
+using Content.Shared.Paper;
+using Content.Shared.Popups;
+using Content.Shared.Random.Helpers;
+using Content.Shared.Silicons.StationAi;
+using Content.Shared.Storage.EntitySystems;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Utility;
+
+namespace Content.Server.StationEvents.Events;
+
+public sealed class FugitiveRule : StationEventSystem<FugitiveRuleComponent>
+{
+    [Dependency] private readonly InventorySystem _inventory = default!;
+    [Dependency] private readonly PaperSystem _paper = default!;
+    [Dependency] private readonly SharedHandsSystem _hands = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly SharedStorageSystem _storage = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<FugitiveRuleComponent, AfterAntagEntitySelectedEvent>(OnEntitySelected);
+    }
+
+    protected override void ActiveTick(EntityUid uid, FugitiveRuleComponent comp, GameRuleComponent rule, float frameTime)
+    {
+        if (comp.NextAnnounce is not {} next || next > Timing.CurTime)
+            return;
+
+        var announcement = Loc.GetString(comp.Announcement);
+        var sender = Loc.GetString(comp.Sender);
+        ChatSystem.DispatchGlobalAnnouncement(announcement, sender: sender, colorOverride: comp.Color);
+
+        // send the report to every comms console on the station
+        var query = EntityQueryEnumerator<TransformComponent, CommunicationsConsoleComponent>();
+        var consoles = new List<TransformComponent>();
+        while (query.MoveNext(out var console, out var xform, out _))
+        {
+            if (StationSystem.GetOwningStation(console, xform) != comp.Station || HasComp<GhostComponent>(console) || HasComp<StationAiHeldComponent>(console))
+                continue;
+
+            consoles.Add(xform);
+        }
+
+        foreach (var xform in consoles)
+        {
+            SpawnReport(comp, xform);
+        }
+
+        // prevent any possible funnies
+        comp.NextAnnounce = null;
+
+        RemCompDeferred(uid, comp);
+    }
+
+    private void OnEntitySelected(Entity<FugitiveRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)
+    {
+        var (uid, comp) = ent;
+        if (comp.NextAnnounce != null)
+        {
+            Log.Error("Fugitive rule spawning multiple fugitives isn't supported, sorry.");
+            return;
+        }
+
+        var fugi = args.EntityUid;
+        comp.Report = GenerateReport(fugi, comp).ToMarkup();
+        comp.Station = StationSystem.GetOwningStation(fugi);
+        comp.NextAnnounce = Timing.CurTime + comp.AnnounceDelay;
+
+        _popup.PopupEntity(Loc.GetString("fugitive-spawn"), fugi, fugi);
+
+        // give the fugi a report so they know what their charges are
+        var report = SpawnReport(comp, Transform(fugi));
+
+        // try to insert it into their bag
+        if (_inventory.TryGetSlotEntity(fugi, "back", out var backpack))
+        {
+            _storage.Insert(backpack.Value, report, out _, playSound: false);
+        }
+        else
+        {
+            // no bag somehow, at least pick it up
+            _hands.TryPickup(fugi, report);
+        }
+    }
+
+    private Entity<PaperComponent> SpawnReport(FugitiveRuleComponent rule, TransformComponent xform)
+    {
+        var report = Spawn(rule.ReportPaper, xform.Coordinates);
+        var paper = Comp<PaperComponent>(report);
+        var ent = (report, paper);
+        _paper.SetContent(ent, rule.Report);
+        return ent;
+    }
+
+    private FormattedMessage GenerateReport(EntityUid uid, FugitiveRuleComponent rule)
+    {
+        var report = new FormattedMessage();
+        report.PushMarkup(Loc.GetString("fugitive-report-title"));
+        report.PushNewline();
+        report.PushMarkup(Loc.GetString("fugitive-report-first-line"));
+        report.PushNewline();
+
+        if (!TryComp<HumanoidAppearanceComponent>(uid, out var humanoid))
+        {
+            report.AddMarkup(Loc.GetString("fugitive-report-inhuman", ("name", uid)));
+            return report;
+        }
+
+        var species = PrototypeManager.Index(humanoid.Species);
+
+        report.PushMarkup(Loc.GetString("fugitive-report-morphotype", ("species", Loc.GetString(species.Name))));
+        report.PushMarkup(Loc.GetString("fugitive-report-age", ("age", humanoid.Age)));
+        report.PushMarkup(Loc.GetString("fugitive-report-sex", ("sex", humanoid.Sex.ToString())));
+
+        if (TryComp<PhysicsComponent>(uid, out var physics))
+            report.PushMarkup(Loc.GetString("fugitive-report-weight", ("weight", Math.Round(physics.FixturesMass))));
+
+        // add a random identifying quality that officers can use to track them down
+        report.PushMarkup(RobustRandom.Next(0, 2) switch
+        {
+            0 => Loc.GetString("fugitive-report-detail-dna", ("dna", GetDNA(uid))),
+            _ => Loc.GetString("fugitive-report-detail-prints", ("prints", GetPrints(uid)))
+        });
+
+        report.PushNewline();
+        report.PushMarkup(Loc.GetString("fugitive-report-crimes-header"));
+
+        // generate some random crimes to avoid this situation
+        // "officer what are my charges?"
+        // "uh i dunno a piece of paper said to arrest you thats it"
+        AddCharges(report, rule);
+
+        report.PushNewline();
+        report.AddMarkup(Loc.GetString("fugitive-report-last-line"));
+
+        return report;
+    }
+
+    private string GetDNA(EntityUid uid)
+    {
+        return CompOrNull<DnaComponent>(uid)?.DNA ?? "?";
+    }
+
+    private string GetPrints(EntityUid uid)
+    {
+        return CompOrNull<FingerprintComponent>(uid)?.Fingerprint ?? "?";
+    }
+
+    private void AddCharges(FormattedMessage report, FugitiveRuleComponent rule)
+    {
+        var crimeTypes = PrototypeManager.Index(rule.CrimesDataset);
+        var crimes = new HashSet<LocId>();
+        var total = RobustRandom.Next(rule.MinCrimes, rule.MaxCrimes + 1);
+        while (crimes.Count < total)
+        {
+            crimes.Add(RobustRandom.Pick(crimeTypes));
+        }
+
+        foreach (var crime in crimes)
+        {
+            var count = RobustRandom.Next(rule.MinCounts, rule.MaxCounts + 1);
+            report.PushMarkup(Loc.GetString("fugitive-report-crime", ("crime", Loc.GetString(crime)), ("count", count)));
+        }
+    }
+}
diff --git a/Content.Server/_DV/StationEvents/Events/LoadFarGridRule.cs b/Content.Server/_DV/StationEvents/Events/LoadFarGridRule.cs
new file mode 100644
index 0000000000000..7bab8adfa4d47
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Events/LoadFarGridRule.cs
@@ -0,0 +1,65 @@
+using Content.Server.GameTicking.Rules;
+using Content.Server.Station.Components;
+using Content.Server.StationEvents.Components;
+using Content.Shared.GameTicking.Components;
+using Robust.Server.GameObjects;
+using Robust.Shared.EntitySerialization.Systems;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server.StationEvents.Events;
+
+public sealed class LoadFarGridRule : StationEventSystem<LoadFarGridRuleComponent>
+{
+    [Dependency] private readonly MapLoaderSystem _mapLoader = default!;
+
+    protected override void Added(EntityUid uid, LoadFarGridRuleComponent comp, GameRuleComponent rule, GameRuleAddedEvent args)
+    {
+        base.Added(uid, comp, rule, args);
+
+        if (!TryGetRandomStation(out var station) || !TryComp<StationDataComponent>(station, out var data))
+        {
+            Log.Error($"{ToPrettyString(uid):rule} failed to find a station!");
+            ForceEndSelf(uid, rule);
+            return;
+        }
+
+        if (data.Grids.Count < 1)
+        {
+            Log.Error($"{ToPrettyString(uid):rule} picked station {station} which had no grids!");
+            ForceEndSelf(uid, rule);
+            return;
+        }
+
+        // get an AABB that contains all the station's grids
+        var aabb = new Box2();
+        var map = MapId.Nullspace;
+        foreach (var gridId in data.Grids)
+        {
+            // use the first grid's map id
+            if (map == MapId.Nullspace)
+                map = Transform(gridId).MapID;
+
+            var gridComp = Comp<MapGridComponent>(gridId);
+            var gridAabb = Transform(gridId).WorldMatrix.TransformBox(gridComp.LocalAABB);
+            aabb = aabb.Union(gridAabb);
+        }
+
+        var scale = comp.Sousk / aabb.Width;
+        var modifier = comp.DistanceModifier * scale;
+        var dist = MathF.Max(aabb.Height / 2f, aabb.Width / 2f) * modifier;
+        var offset = RobustRandom.NextVector2(dist, dist * 2.5f);
+
+        if (!_mapLoader.TryLoadGrid(map, comp.Path, out var grid, offset: aabb.Center + offset))
+        {
+            Log.Error($"{ToPrettyString(uid):rule} failed to load grid {comp.Path}!");
+            ForceEndSelf(uid, rule);
+            return;
+        }
+
+        // let other systems do stuff
+        var ev = new RuleLoadedGridsEvent(map, [grid.Value]);
+        RaiseLocalEvent(uid, ref ev);
+    }
+}
diff --git a/Content.Server/_DV/StationEvents/Events/MidRoundAntagRule.cs b/Content.Server/_DV/StationEvents/Events/MidRoundAntagRule.cs
new file mode 100644
index 0000000000000..f2c6b69eb0690
--- /dev/null
+++ b/Content.Server/_DV/StationEvents/Events/MidRoundAntagRule.cs
@@ -0,0 +1,63 @@
+using Content.Server.Antag;
+using Content.Server.StationEvents.Components;
+using Robust.Shared.Map;
+
+namespace Content.Server.StationEvents.Events;
+
+// Impstation heads up, this is MIT code, not AGPL. Licenced under Nyanotrasen namespace
+
+/// <summary>
+/// Makes antags spawn at a random midround antag or vent critter spawner.
+/// </summary>
+public sealed class MidRoundAntagRule : StationEventSystem<MidRoundAntagRuleComponent>
+{
+    [Dependency] private readonly SharedTransformSystem _xform = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<MidRoundAntagRuleComponent, AntagSelectLocationEvent>(OnSelectLocation);
+    }
+
+    private void OnSelectLocation(Entity<MidRoundAntagRuleComponent> ent, ref AntagSelectLocationEvent args)
+    {
+        if (!TryGetRandomStation(out var station))
+            return;
+
+        var spawns = FindSpawns(station.Value);
+        if (spawns.Count == 0)
+        {
+            Log.Warning($"Couldn't find any suitable midround antag spawners for {ToPrettyString(ent):rule}");
+            return;
+        }
+
+        args.Coordinates.AddRange(spawns);
+    }
+
+    private List<MapCoordinates> FindSpawns(EntityUid station)
+    {
+        var spawns = new List<MapCoordinates>();
+        var query = EntityQueryEnumerator<MidRoundAntagSpawnLocationComponent, TransformComponent>();
+        while (query.MoveNext(out var uid, out _, out var xform))
+        {
+            if (StationSystem.GetOwningStation(uid, xform) == station && xform.GridUid != null)
+                spawns.Add(_xform.GetMapCoordinates(xform));
+        }
+
+        // if there are any midround antag spawns mapped, use them
+        if (spawns.Count > 0)
+            return spawns;
+
+        // otherwise, fall back to vent critter spawns
+        Log.Info($"Station {ToPrettyString(station):station} has no midround antag spawnpoints mapped, falling back. Please map them!");
+        var fallbackQuery = EntityQueryEnumerator<VentCritterSpawnLocationComponent, TransformComponent>();
+        while (fallbackQuery.MoveNext(out var uid, out _, out var xform))
+        {
+            if (StationSystem.GetOwningStation(uid, xform) == station && xform.GridUid != null)
+                spawns.Add(_xform.GetMapCoordinates(xform));
+        }
+
+        return spawns;
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Ash.cs b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Ash.cs
new file mode 100644
index 0000000000000..1a0ace49a6055
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Ash.cs
@@ -0,0 +1,169 @@
+using Content.Server.Atmos.Components;
+using Content.Shared.Heretic;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs;
+using Content.Shared.Damage;
+using Content.Shared.Atmos;
+using Content.Server.Polymorph.Systems;
+using Robust.Server.Audio;
+using Robust.Shared.Audio;
+
+namespace Content.Server.Heretic.Abilities;
+
+public sealed partial class HereticAbilitySystem : EntitySystem
+{
+    [Dependency] private readonly AudioSystem _audio = default!;
+    [Dependency] private readonly BlazingDashSystem _blazingDash = default!;
+    public SoundSpecifier JauntExitSound = new SoundPathSpecifier("/Audio/Magic/fireball.ogg");
+    public const float RebirthRange = 3f;
+
+    private void SubscribeAsh()
+    {
+        SubscribeLocalEvent<HereticComponent, EventHereticAshenShift>(OnJaunt);
+        SubscribeLocalEvent<GhoulComponent, EventHereticAshenShift>(OnJauntGhoul);
+        SubscribeLocalEvent<HereticComponent, PolymorphRevertEvent>(OnJauntEnd);
+
+        SubscribeLocalEvent<HereticComponent, EventHereticVolcanoBlast>(OnVolcano);
+        SubscribeLocalEvent<HereticComponent, EventHereticBlazingDash>(OnBlazingDash);
+        SubscribeLocalEvent<HereticComponent, EventHereticNightwatcherRebirth>(OnNWRebirth);
+        SubscribeLocalEvent<HereticComponent, EventHereticFlames>(OnFlames);
+        SubscribeLocalEvent<HereticComponent, EventHereticCascade>(OnCascade);
+    }
+
+    //keeping this in for when i eventually make it possible to turn the shitpig into the Ashen Pig
+    private void OnJaunt(Entity<HereticComponent> ent, ref EventHereticAshenShift args)
+    {
+        if (TryUseAbility(ent, args) && TryDoJaunt(ent))
+            args.Handled = true;
+    }
+
+    //a few of the flesh ghouls use this so it stays too
+    private void OnJauntGhoul(Entity<GhoulComponent> ent, ref EventHereticAshenShift args)
+    {
+        if (TryUseAbility(ent, args) && TryDoJaunt(ent))
+            args.Handled = true;
+    }
+
+    private void OnBlazingDash(Entity<HereticComponent> ent, ref EventHereticBlazingDash args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        _blazingDash.TryDoDash(ent, ref args);
+    }
+
+    private bool TryDoJaunt(EntityUid ent)
+    {
+        Spawn("PolymorphAshJauntAnimation", Transform(ent).Coordinates);
+        var urist = _poly.PolymorphEntity(ent, "AshJaunt");
+        if (urist == null)
+            return false;
+        return true;
+    }
+    private void OnJauntEnd(Entity<HereticComponent> ent, ref PolymorphRevertEvent args)
+    {
+        Spawn("PolymorphAshJauntEndAnimation", Transform(ent).Coordinates);
+
+        // play a distinct sound, audible thru walls, so you can track where that slippery fuck went
+        _audio.PlayPvs(JauntExitSound, ent, AudioParams.Default
+            .WithVolume(-2f)
+            .WithMaxDistance(15f)
+            .WithRolloffFactor(0.8f)
+            );
+    }
+
+    private void OnVolcano(Entity<HereticComponent> ent, ref EventHereticVolcanoBlast args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        var ignoredTargets = new List<EntityUid>();
+
+        // all ghouls are immune to heretic shittery
+        foreach (var e in EntityQuery<GhoulComponent>())
+            ignoredTargets.Add(e.Owner);
+
+        // all heretics with the same path are also immune
+        foreach (var e in EntityQuery<HereticComponent>())
+            if (e.CurrentPath == ent.Comp.CurrentPath)
+                ignoredTargets.Add(e.Owner);
+
+        if (!_splitball.Spawn(ent, ignoredTargets))
+            return;
+
+        if (ent.Comp.Ascended) // will only work on ash path
+            _flammable.AdjustFireStacks(ent, 20f, ignite: true);
+
+        args.Handled = true;
+    }
+    private void OnNWRebirth(Entity<HereticComponent> ent, ref EventHereticNightwatcherRebirth args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        var lookup = _lookup.GetEntitiesInRange(ent, RebirthRange);
+
+        foreach (var look in lookup)
+        {
+            if ((TryComp<HereticComponent>(look, out var th) && th.CurrentPath == ent.Comp.CurrentPath)
+            || HasComp<GhoulComponent>(look))
+                continue;
+
+            if (TryComp<FlammableComponent>(look, out var flam))
+            {
+                if (flam.OnFire && TryComp<DamageableComponent>(ent, out var dmgc))
+                {
+                    // heals everything by 10 for each burning target
+                    _stam.TryTakeStamina(ent, -10);
+                    var dmgdict = dmgc.Damage.DamageDict;
+                    foreach (var key in dmgdict.Keys)
+                        dmgdict[key] = -10f;
+
+                    var dmgspec = new DamageSpecifier() { DamageDict = dmgdict };
+                    _dmg.TryChangeDamage(ent, dmgspec, true, false, dmgc);
+                }
+
+                if (!flam.OnFire)
+                    _flammable.AdjustFireStacks(look, 5, flam, true);
+
+                if (TryComp<MobStateComponent>(look, out var mobstat))
+                    if (mobstat.CurrentState == MobState.Critical)
+                        _mobstate.ChangeMobState(look, MobState.Dead, mobstat);
+            }
+        }
+
+        args.Handled = true;
+    }
+    private void OnFlames(Entity<HereticComponent> ent, ref EventHereticFlames args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        EnsureComp<HereticFlamesComponent>(ent);
+
+        if (ent.Comp.Ascended)
+            _flammable.AdjustFireStacks(ent, 20f, ignite: true);
+
+        args.Handled = true;
+    }
+    private void OnCascade(Entity<HereticComponent> ent, ref EventHereticCascade args)
+    {
+        if (!TryUseAbility(ent, args) || !Transform(ent).GridUid.HasValue)
+            return;
+
+        // yeah. it just generates a ton of plasma which just burns.
+        // lame, but we don't have anything fire related atm, so, it works.
+        var tilepos = _xform.GetGridOrMapTilePosition(ent, Transform(ent));
+        var enumerator = _atmos.GetAdjacentTileMixtures(Transform(ent).GridUid!.Value, tilepos, false, false);
+        while (enumerator.MoveNext(out var mix))
+        {
+            mix.AdjustMoles(Gas.Plasma, 50f);
+            mix.Temperature = Atmospherics.T0C + 125f;
+        }
+
+        if (ent.Comp.Ascended)
+            _flammable.AdjustFireStacks(ent, 20f, ignite: true);
+
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Flesh.cs b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Flesh.cs
new file mode 100644
index 0000000000000..5cd02c60ee91d
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Flesh.cs
@@ -0,0 +1,158 @@
+using Content.Server.Body.Components;
+using Content.Shared.Body.Components;
+using Content.Shared.Chemistry.Reagent; // imp
+using Content.Shared.Damage;
+using Content.Shared.DoAfter;
+using Content.Shared.Eye.Blinding.Components;
+using Content.Shared.Heretic;
+using Content.Shared.Humanoid; // imp
+using Content.Shared.Popups;
+using Content.Shared.Speech.Muting;
+using Content.Shared.Sprite; // imp
+using Robust.Shared.Audio;
+using Robust.Shared.Serialization.Manager; // imp
+
+namespace Content.Server.Heretic.Abilities;
+
+public sealed partial class HereticAbilitySystem : EntitySystem
+{
+    [Dependency] private readonly ISerializationManager _serManager = default!; // imp
+
+    private void SubscribeFlesh()
+    {
+        SubscribeLocalEvent<HereticComponent, EventHereticFleshSurgery>(OnFleshSurgery);
+        SubscribeLocalEvent<HereticComponent, EventHereticFleshSurgeryDoAfter>(OnFleshSurgeryDoAfter);
+        SubscribeLocalEvent<HereticComponent, EventHereticFleshAscend>(OnFleshAscendPolymorph);
+    }
+
+    private void OnFleshSurgery(Entity<HereticComponent> ent, ref EventHereticFleshSurgery args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        if (HasComp<GhoulComponent>(args.Target)
+        || (TryComp<HereticComponent>(args.Target, out var th) && th.CurrentPath == ent.Comp.CurrentPath))
+        {
+            var dargs = new DoAfterArgs(EntityManager, ent, 10f, new EventHereticFleshSurgeryDoAfter(args.Target), ent, args.Target)
+            {
+                BreakOnDamage = true,
+                BreakOnMove = true,
+                BreakOnHandChange = false,
+                BreakOnDropItem = false,
+            };
+            _doafter.TryStartDoAfter(dargs);
+            args.Handled = true;
+            return;
+        }
+
+        // temporarily disable a random organ
+        // the fucking goob coders were literally just deleting organ components. who thought that was okay
+        // TODO: change this to actually remove/disable organs once newmed comes out next week
+        if (TryComp<BodyComponent>(args.Target, out var body))
+        {
+            //i should really make these their own methods. but i dont want to
+            switch (_random.Next(0, 3))
+            {
+                // case 0: barf
+                case 0:
+                    _popup.PopupEntity(Loc.GetString("heretic-fleshsurgery-barf"), args.Target, args.Target, PopupType.LargeCaution);
+                    _vomit.Vomit(args.Target, -1000, -1000); // i frew up
+                    break;
+
+                // case 1: blind (fixable!)
+                case 1:
+                    if (!TryComp<BlindableComponent>(args.Target, out var blindable) || blindable.IsBlind)
+                        return;
+
+                    _popup.PopupEntity(Loc.GetString("heretic-fleshsurgery-eyes"), args.Target, args.Target, PopupType.LargeCaution);
+                    _blindable.AdjustEyeDamage((args.Target, blindable), 7); //same as rawdogging a welder 7 times. fixable but definitely a pain
+                    break;
+
+                // case 2: mute for 2.5 minutes
+                case 2:
+                    _popup.PopupEntity(Loc.GetString("heretic-fleshsurgery-mute"), args.Target, args.Target, PopupType.LargeCaution);
+                    _statusEffect.TryAddStatusEffect<MutedComponent>(args.Target, "Muted", TimeSpan.FromSeconds(150), false);
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        args.Handled = true;
+    }
+    private void OnFleshSurgeryDoAfter(Entity<HereticComponent> ent, ref EventHereticFleshSurgeryDoAfter args)
+    {
+        if (args.Cancelled)
+            return;
+
+        if (args.Target == null) // shouldn't really happen. just in case
+            return;
+
+        if (!TryComp<DamageableComponent>(args.Target, out var dmg))
+            return;
+
+        // heal teammates, mostly ghouls
+        _dmg.SetAllDamage((EntityUid) args.Target, dmg, 0);
+        args.Handled = true;
+    }
+    private void OnFleshAscendPolymorph(Entity<HereticComponent> ent, ref EventHereticFleshAscend args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        var urist = _poly.PolymorphEntity(ent, "EldritchHorror");
+        if (urist == null)
+            return;
+
+        var colors = GrabHumanoidColors(ent); // begin imp
+
+        if (colors != null) // match the colors of the ascended entity to those of the ascendee
+        {
+            (var skinColor, var eyeColor, var bloodColor) = colors.Value;
+            if (TryComp<RandomSpriteComponent>(urist, out var randomSprite)) // we have to do this using RandomSpriteComponent, otherwise I'd be making a whole species prototype just for this.
+            {
+                foreach (var entry in randomSprite.Selected)
+                {
+                    var state = randomSprite.Selected[entry.Key];
+                    switch (entry.Key)
+                    {
+                        case "fleshMap":
+                            state.Color = skinColor;
+                            break;
+                        case "eyesMap":
+                            state.Color = eyeColor;
+                            break;
+                        case "bloodMap":
+                            state.Color = bloodColor;
+                            break;
+                    }
+                    randomSprite.Selected[entry.Key] = state;
+                }
+                Dirty(urist.Value, randomSprite);
+            }
+        } // end imp
+
+        _aud.PlayPvs(new SoundPathSpecifier("/Audio/Animals/space_dragon_roar.ogg"), (EntityUid) urist, AudioParams.Default.AddVolume(2f));
+
+        args.Handled = true;
+    }
+
+    private (Color, Color, Color)? GrabHumanoidColors(EntityUid entity) // imp
+    {
+        Color skinColor;
+        Color eyeColor;
+        Color bloodColor;
+        if (TryComp<HumanoidAppearanceComponent>(entity, out var humanoid) && TryComp<BloodstreamComponent>(entity, out var bloodstream) // get the humanoidappearance and bloodstream
+        && _prot.TryIndex(bloodstream.BloodReagent, out ReagentPrototype? reagentProto) && reagentProto != null) // get the blood reagent 
+        {
+            skinColor = humanoid.SkinColor;
+            eyeColor = humanoid.EyeColor;
+            bloodColor = reagentProto.SubstanceColor;
+
+            return (skinColor, eyeColor, bloodColor);
+        }
+
+        else return null; // if (for some reason - like perhaps admin intervention) a non-humanoid or someone with no bloodstream ascends, we don't want to try to modify the colors. 
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Void.cs b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Void.cs
new file mode 100644
index 0000000000000..cf821504aadbc
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.Void.cs
@@ -0,0 +1,115 @@
+using Content.Server.Atmos.Components;
+using Content.Server.Body.Components;
+using Content.Server.Heretic.Components;
+using Content.Server.Temperature.Components;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.Heretic;
+using Content.Shared.Temperature.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Physics.Components;
+using System.Linq;
+
+namespace Content.Server.Heretic.Abilities;
+
+public sealed partial class HereticAbilitySystem : EntitySystem
+{
+    private void SubscribeVoid()
+    {
+        SubscribeLocalEvent<HereticComponent, HereticAristocratWayEvent>(OnAristocratWay);
+        SubscribeLocalEvent<HereticComponent, HereticAscensionVoidEvent>(OnAscensionVoid);
+
+        SubscribeLocalEvent<HereticComponent, HereticVoidBlastEvent>(OnVoidBlast);
+        SubscribeLocalEvent<HereticComponent, HereticVoidBlinkEvent>(OnVoidBlink);
+        SubscribeLocalEvent<HereticComponent, HereticVoidPullEvent>(OnVoidPull);
+    }
+
+    private void OnAristocratWay(Entity<HereticComponent> ent, ref HereticAristocratWayEvent args)
+    {
+        RemComp<TemperatureComponent>(ent);
+        RemComp<TemperatureSpeedComponent>(ent);
+        RemComp<RespiratorComponent>(ent);
+    }
+    private void OnAscensionVoid(Entity<HereticComponent> ent, ref HereticAscensionVoidEvent args)
+    {
+        RemComp<BarotraumaComponent>(ent);
+        EnsureComp<AristocratComponent>(ent);
+    }
+
+    private void OnVoidBlast(Entity<HereticComponent> ent, ref HereticVoidBlastEvent args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        var rod = Spawn("ImmovableVoidRod", Transform(ent).Coordinates);
+
+        if (TryComp(rod, out PhysicsComponent? phys))
+        {
+            _phys.SetLinearDamping(rod, phys, 0f);
+            _phys.SetFriction(rod, phys, 0f);
+            _phys.SetBodyStatus(rod, phys, BodyStatus.InAir);
+
+            var xform = Transform(rod);
+            var vel = Transform(ent).WorldRotation.ToWorldVec() * 15f;
+
+            _phys.SetLinearVelocity(rod, vel, body: phys);
+            xform.LocalRotation = Transform(ent).LocalRotation;
+        }
+
+        args.Handled = true;
+    }
+
+    private void OnVoidBlink(Entity<HereticComponent> ent, ref HereticVoidBlinkEvent args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        _aud.PlayPvs(new SoundPathSpecifier("/Audio/Effects/tesla_consume.ogg"), ent);
+
+        foreach (var pookie in GetNearbyPeople(ent, 2f))
+            _stun.TryKnockdown(pookie, TimeSpan.FromSeconds(2.5f), true);
+
+        _transform.SetCoordinates(ent, args.Target);
+
+        // repeating for both sides
+        _aud.PlayPvs(new SoundPathSpecifier("/Audio/Effects/tesla_consume.ogg"), ent);
+
+        foreach (var pookie in GetNearbyPeople(ent, 2f))
+            _stun.TryKnockdown(pookie, TimeSpan.FromSeconds(2.5f), true);
+
+        args.Handled = true;
+    }
+
+    private void OnVoidPull(Entity<HereticComponent> ent, ref HereticVoidPullEvent args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        var topPriority = GetNearbyPeople(ent, 1.5f);
+        var midPriority = GetNearbyPeople(ent, 2.5f);
+        var farPriority = GetNearbyPeople(ent, 5f);
+
+        // damage closest ones
+        foreach (var pookie in topPriority)
+        {
+            if (!TryComp<DamageableComponent>(pookie, out var dmgComp))
+                continue;
+
+            // total damage + 20 divided by all damage types.
+            var damage = (dmgComp.TotalDamage + 20f) / _prot.EnumeratePrototypes<DamageTypePrototype>().Count();
+
+            // apply gaming.
+            _dmg.SetAllDamage(pookie, dmgComp, damage);
+        }
+
+        // stun close-mid range
+        foreach (var pookie in midPriority)
+            _stun.TryKnockdown(pookie, TimeSpan.FromSeconds(2.5f), true);
+
+        // pull in farthest ones
+        foreach (var pookie in farPriority)
+            _throw.TryThrow(pookie, Transform(ent).Coordinates);
+
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.cs b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.cs
new file mode 100644
index 0000000000000..35129d97b1a31
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Abilities/HereticAbilitySystem.cs
@@ -0,0 +1,201 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Chat.Systems;
+using Content.Server.DoAfter;
+using Content.Server.Flash;
+using Content.Server.Hands.Systems;
+using Content.Server.Magic;
+using Content.Server.Polymorph.Systems;
+using Content.Server.Popups;
+using Content.Server.Radio.Components;
+using Content.Server.Store.Systems;
+using Content.Shared.Actions;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Systems;
+using Content.Shared.DoAfter;
+using Content.Shared.Heretic;
+using Content.Shared.Mind.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Store.Components;
+using Robust.Shared.Audio.Systems;
+using Content.Shared.Popups;
+using Robust.Shared.Random;
+using Content.Shared.Body.Systems;
+using Content.Server.Medical;
+using Robust.Server.GameObjects;
+using Content.Shared.Stunnable;
+using Robust.Shared.Map;
+using Content.Shared.StatusEffect;
+using Content.Shared.Throwing;
+using Content.Server.Station.Systems;
+using Robust.Shared.Prototypes;
+using Content.Shared.Eye.Blinding.Systems;
+using Content.Shared.Movement.Systems;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Heretic.Abilities;
+
+public sealed partial class HereticAbilitySystem : EntitySystem
+{
+    // keeping track of all systems in a single file
+    [Dependency] private readonly StoreSystem _store = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly HandsSystem _hands = default!;
+    [Dependency] private readonly ChatSystem _chat = default!;
+    [Dependency] private readonly PolymorphSystem _poly = default!;
+    [Dependency] private readonly ChainFireballSystem _splitball = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly MobStateSystem _mobstate = default!;
+    [Dependency] private readonly FlammableSystem _flammable = default!;
+    [Dependency] private readonly DamageableSystem _dmg = default!;
+    [Dependency] private readonly StaminaSystem _stam = default!;
+    [Dependency] private readonly AtmosphereSystem _atmos = default!;
+    [Dependency] private readonly SharedTransformSystem _xform = default!;
+    [Dependency] private readonly SharedAudioSystem _aud = default!;
+    [Dependency] private readonly DoAfterSystem _doafter = default!;
+    [Dependency] private readonly FlashSystem _flash = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly BlindableSystem _blindable = default!;
+    [Dependency] private readonly VomitSystem _vomit = default!;
+    [Dependency] private readonly StatusEffectsSystem _statusEffect = default!;
+    [Dependency] private readonly PhysicsSystem _phys = default!;
+    [Dependency] private readonly SharedStunSystem _stun = default!;
+    [Dependency] private readonly ThrowingSystem _throw = default!;
+    [Dependency] private readonly IPrototypeManager _prot = default!;
+
+    private List<EntityUid> GetNearbyPeople(Entity<HereticComponent> ent, float range)
+    {
+        var list = new List<EntityUid>();
+        var lookup = _lookup.GetEntitiesInRange(Transform(ent).Coordinates, range);
+
+        foreach (var look in lookup)
+        {
+            // ignore heretics with the same path*, affect everyone else
+            if ((TryComp<HereticComponent>(look, out var th) && th.CurrentPath == ent.Comp.CurrentPath)
+            || HasComp<GhoulComponent>(look))
+                continue;
+
+            if (!HasComp<StatusEffectsComponent>(look))
+                continue;
+
+            list.Add(look);
+        }
+        return list;
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticComponent, EventHereticOpenStore>(OnStore);
+        SubscribeLocalEvent<HereticComponent, EventHereticMansusGrasp>(OnMansusGrasp);
+
+        SubscribeLocalEvent<GhoulComponent, EventHereticMansusLink>(OnMansusLink);
+        SubscribeLocalEvent<GhoulComponent, HereticMansusLinkDoAfter>(OnMansusLinkDoafter);
+
+        SubscribeAsh();
+        SubscribeFlesh();
+        SubscribeVoid();
+    }
+
+    private bool TryUseAbility(EntityUid ent, BaseActionEvent args)
+    {
+        if (args.Handled)
+            return false;
+
+        if (!TryComp<HereticActionComponent>(args.Action, out var actionComp))
+            return false;
+
+        // check if any magic items are worn
+        if (TryComp<HereticComponent>(ent, out var hereticComp) && actionComp.RequireMagicItem && !hereticComp.Ascended)
+        {
+            var ev = new CheckMagicItemEvent();
+            RaiseLocalEvent(ent, ev);
+
+            if (!ev.Handled)
+            {
+                _popup.PopupEntity(Loc.GetString("heretic-ability-fail-magicitem"), ent, ent);
+                return false;
+            }
+        }
+
+        // shout the spell out
+        if (!string.IsNullOrWhiteSpace(actionComp.MessageLoc))
+            _chat.TrySendInGameICMessage(ent, Loc.GetString(actionComp.MessageLoc!), InGameICChatType.Speak, false);
+
+        return true;
+    }
+    private void OnStore(Entity<HereticComponent> ent, ref EventHereticOpenStore args)
+    {
+        if (!TryComp<StoreComponent>(ent, out var store))
+            return;
+
+        _store.ToggleUi(ent, ent, store);
+    }
+    private void OnMansusGrasp(Entity<HereticComponent> ent, ref EventHereticMansusGrasp args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        if (ent.Comp.MansusGraspActive)
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-ability-fail"), ent, ent);
+            return;
+        }
+
+        var st = Spawn("TouchSpellMansus", Transform(ent).Coordinates);
+
+        if (!_hands.TryForcePickupAnyHand(ent, st))
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-ability-fail"), ent, ent);
+            QueueDel(st);
+            return;
+        }
+
+        ent.Comp.MansusGraspActive = true;
+        args.Handled = true;
+    }
+
+    private void OnMansusLink(Entity<GhoulComponent> ent, ref EventHereticMansusLink args)
+    {
+        if (!TryUseAbility(ent, args))
+            return;
+
+        if (!HasComp<MindContainerComponent>(args.Target))
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-manselink-fail-nomind"), ent, ent);
+            return;
+        }
+
+        if (TryComp<ActiveRadioComponent>(args.Target, out var radio)
+        && radio.Channels.Contains("Mansus"))
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-manselink-fail-exists"), ent, ent);
+            return;
+        }
+
+        var dargs = new DoAfterArgs(EntityManager, ent, 5f, new HereticMansusLinkDoAfter(args.Target), ent, args.Target)
+        {
+            BreakOnDamage = true,
+            BreakOnMove = true,
+            BreakOnWeightlessMove = true
+        };
+        _popup.PopupEntity(Loc.GetString("heretic-manselink-start"), ent, ent);
+        _popup.PopupEntity(Loc.GetString("heretic-manselink-start-target"), args.Target, args.Target, PopupType.MediumCaution);
+        _doafter.TryStartDoAfter(dargs);
+    }
+    private void OnMansusLinkDoafter(Entity<GhoulComponent> ent, ref HereticMansusLinkDoAfter args)
+    {
+        if (args.Cancelled)
+            return;
+
+        var reciever = EnsureComp<IntrinsicRadioReceiverComponent>(args.Target);
+        var transmitter = EnsureComp<IntrinsicRadioTransmitterComponent>(args.Target);
+        var radio = EnsureComp<ActiveRadioComponent>(args.Target);
+        radio.Channels = new() { "Mansus" };
+        transmitter.Channels = new() { "Mansus" };
+
+        // this "* 1000f" (divided by 1000 in FlashSystem) is gonna age like fine wine :clueless:
+        _flash.Flash(args.Target, null, null, 2f * 1000f, 0f, false, true, stunDuration: TimeSpan.FromSeconds(1f));
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Abilities/HereticFlames.cs b/Content.Server/_Goobstation/Heretic/Abilities/HereticFlames.cs
new file mode 100644
index 0000000000000..7fa809f112fb9
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Abilities/HereticFlames.cs
@@ -0,0 +1,44 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Shared.Atmos;
+
+namespace Content.Server.Heretic.Abilities;
+
+[RegisterComponent]
+public sealed partial class HereticFlamesComponent : Component
+{
+    public float Timer = 0f;
+    public float TimerSeconds = 0f;
+    public float UpdateDuration = .2f;
+    [DataField] public float Duration = 60f;
+}
+
+public sealed partial class HereticFlamesSystem : EntitySystem
+{
+    [Dependency] private readonly AtmosphereSystem _atmos = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        foreach (var hfc in EntityQuery<HereticFlamesComponent>())
+        {
+            hfc.Timer += frameTime;
+            if (hfc.Timer < hfc.UpdateDuration)
+                continue;
+
+            hfc.Timer = 0f;
+            hfc.TimerSeconds += 1f;
+
+            if (hfc.TimerSeconds >= hfc.Duration)
+                RemComp(hfc.Owner, hfc);
+
+            var gasmix = _atmos.GetTileMixture((hfc.Owner, Transform(hfc.Owner)));
+
+            if (gasmix == null)
+                continue;
+
+            gasmix.AdjustMoles(Gas.Plasma, 2f);
+            gasmix.Temperature = Atmospherics.T0C + 125f;
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/AristocratComponent.cs b/Content.Server/_Goobstation/Heretic/Components/AristocratComponent.cs
new file mode 100644
index 0000000000000..5f28a24151332
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/AristocratComponent.cs
@@ -0,0 +1,9 @@
+namespace Content.Server.Heretic.Components;
+
+[RegisterComponent]
+public sealed partial class AristocratComponent : Component
+{
+    public float UpdateTimer = 0f;
+    [DataField] public float UpdateDelay = 1.5f;
+    [DataField] public float Range = 2.5f;
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/EldritchInfluenceComponent.cs b/Content.Server/_Goobstation/Heretic/Components/EldritchInfluenceComponent.cs
new file mode 100644
index 0000000000000..bf425c9d71913
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/EldritchInfluenceComponent.cs
@@ -0,0 +1,12 @@
+using Content.Server.Heretic.EntitySystems;
+
+namespace Content.Server.Heretic.Components;
+
+[RegisterComponent, Access(typeof(EldritchInfluenceSystem))]
+public sealed partial class EldritchInfluenceComponent : Component
+{
+    [DataField] public bool Spent = false;
+
+    // make sure to update it with the prototype !!!
+    [NonSerialized] public static int LayerMask = 69; // 69 idk why not lolol
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/HellSpawnPointComponent.cs b/Content.Server/_Goobstation/Heretic/Components/HellSpawnPointComponent.cs
new file mode 100644
index 0000000000000..d8dd6ee403c52
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/HellSpawnPointComponent.cs
@@ -0,0 +1,6 @@
+namespace Content.Server._Goobstation.Heretic.Components;
+
+[RegisterComponent]
+public sealed partial class HellSpawnPointComponent : Component
+{
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/HellVictimComponent.cs b/Content.Server/_Goobstation/Heretic/Components/HellVictimComponent.cs
new file mode 100644
index 0000000000000..a70f1a6e3d009
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/HellVictimComponent.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Content.Shared.Humanoid.Prototypes;
+using Robust.Shared.Map;
+
+namespace Content.Server.Heretic.Components;
+
+[RegisterComponent]
+[AutoGenerateComponentPause]
+public sealed partial class HellVictimComponent : Component
+{
+    [DataField]
+    public bool AlreadyHelled = false;
+
+    [DataField]
+    public bool CleanupDone = false;
+
+    [ViewVariables]
+    [AutoPausedField]
+    public TimeSpan ExitHellTime = default!;
+
+    [DataField]
+    public EntityUid OriginalBody;
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public EntityCoordinates OriginalPosition;
+
+    [DataField]
+    public SpeciesPrototype? CloneProto;
+
+    [DataField]
+    public EntityUid? Mind;
+
+    [DataField]
+    public Boolean HasMind = false;
+
+    [DataField, AutoNetworkedField]
+    public TimeSpan HellDuration = TimeSpan.FromSeconds(15);
+
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/HereticBladeComponent.cs b/Content.Server/_Goobstation/Heretic/Components/HereticBladeComponent.cs
new file mode 100644
index 0000000000000..a368da707b928
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/HereticBladeComponent.cs
@@ -0,0 +1,7 @@
+namespace Content.Server.Heretic.Components;
+
+[RegisterComponent]
+public sealed partial class HereticBladeComponent : Component
+{
+    [DataField] public string? Path;
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/HereticKnowledgeItemComponent.cs b/Content.Server/_Goobstation/Heretic/Components/HereticKnowledgeItemComponent.cs
new file mode 100644
index 0000000000000..a7aeb8540bca2
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/HereticKnowledgeItemComponent.cs
@@ -0,0 +1,10 @@
+using Content.Server.Heretic.EntitySystems;
+
+namespace Content.Server.Heretic.Components;
+
+[RegisterComponent, Access(typeof(HereticKnowledgeItemSystem))]
+public sealed partial class HereticKnowledgeItemComponent : Component
+{
+    [DataField]
+    public bool Spent;
+}
diff --git a/Content.Server/_Goobstation/Heretic/Components/MansusGraspComponent.cs b/Content.Server/_Goobstation/Heretic/Components/MansusGraspComponent.cs
new file mode 100644
index 0000000000000..d7ae8b71d9769
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Components/MansusGraspComponent.cs
@@ -0,0 +1,9 @@
+using Content.Server.Heretic.EntitySystems;
+
+namespace Content.Server.Heretic.Components;
+
+[RegisterComponent, Access(typeof(MansusGraspSystem))]
+public sealed partial class MansusGraspComponent : Component
+{
+    [DataField] public string? Path = null;
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/AristocratSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/AristocratSystem.cs
new file mode 100644
index 0000000000000..f5d4b8cb44e08
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/AristocratSystem.cs
@@ -0,0 +1,119 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Heretic.Components;
+using Content.Server.Temperature.Components;
+using Content.Server.Temperature.Systems;
+using Content.Shared.Heretic;
+using Content.Shared.Maps;
+using Content.Shared.Speech.Muting;
+using Content.Shared.StatusEffect;
+using Content.Shared.Tag;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using System.Linq;
+using System.Numerics;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+// void path heretic exclusive
+public sealed partial class AristocratSystem : EntitySystem
+{
+    [Dependency] private readonly TileSystem _tile = default!;
+    [Dependency] private readonly IRobustRandom _rand = default!;
+    [Dependency] private readonly IPrototypeManager _prot = default!;
+    [Dependency] private readonly AtmosphereSystem _atmos = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly TemperatureSystem _temp = default!;
+    [Dependency] private readonly StatusEffectsSystem _statusEffect = default!;
+
+    private string _snowWallPrototype = "WallSnowCobblebrick";
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        foreach (var aristocrat in EntityQuery<AristocratComponent>())
+        {
+            aristocrat.UpdateTimer += frameTime;
+
+            if (aristocrat.UpdateTimer >= aristocrat.UpdateDelay)
+            {
+                Cycle((aristocrat.Owner, aristocrat));
+                aristocrat.UpdateTimer = 0;
+            }
+        }
+    }
+
+    private void Cycle(Entity<AristocratComponent> ent)
+    {
+        SpawnTiles(ent);
+
+        var mix = _atmos.GetTileMixture((ent, Transform(ent)));
+        if (mix != null)
+            mix.Temperature -= 50f;
+
+        // replace certain things with their winter analogue
+        var lookup = _lookup.GetEntitiesInRange(Transform(ent).Coordinates, ent.Comp.Range);
+        foreach (var look in lookup)
+        {
+            if (HasComp<HereticComponent>(look) || HasComp<GhoulComponent>(look))
+                continue;
+
+            if (TryComp<TemperatureComponent>(look, out var temp))
+                _temp.ChangeHeat(look, -200f, true, temp);
+
+            _statusEffect.TryAddStatusEffect<MutedComponent>(look, "Muted", TimeSpan.FromSeconds(5), true);
+
+            if (TryComp<TagComponent>(look, out var tag))
+            {
+                var tags = tag.Tags;
+
+                // replace walls with snow ones
+                if (_rand.Prob(.45f) && tags.Contains("Wall")
+                && Prototype(look) != null && Prototype(look)!.ID != _snowWallPrototype)
+                {
+                    Spawn(_snowWallPrototype, Transform(look).Coordinates);
+                    QueueDel(look);
+                }
+            }
+        }
+    }
+
+    private void SpawnTiles(Entity<AristocratComponent> ent)
+    {
+        var xform = Transform(ent);
+
+        if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
+            return;
+
+        var pos = xform.Coordinates.Position;
+        var box = new Box2(pos + new Vector2(-ent.Comp.Range, -ent.Comp.Range), pos + new Vector2(ent.Comp.Range, ent.Comp.Range));
+        var tilerefs = grid.GetLocalTilesIntersecting(box).ToList();
+
+        if (tilerefs.Count == 0)
+            return;
+
+        var tiles = new List<TileRef>();
+        var tiles2 = new List<TileRef>();
+        foreach (var tile in tilerefs)
+        {
+            if (_rand.Prob(.45f))
+                tiles.Add(tile);
+
+            if (_rand.Prob(.05f))
+                tiles2.Add(tile);
+        }
+
+        foreach (var tileref in tiles)
+        {
+            var tile = _prot.Index<ContentTileDefinition>("FloorAstroSnow");
+            _tile.ReplaceTile(tileref, tile);
+        }
+
+        foreach (var tileref in tiles2)
+        {
+            // todo add more tile variety
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/BlazingDashSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/BlazingDashSystem.cs
new file mode 100644
index 0000000000000..35f75daeea77d
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/BlazingDashSystem.cs
@@ -0,0 +1,80 @@
+using Content.Server.Atmos.Components;
+using Robust.Server.Audio;
+using Robust.Shared.Audio;
+using Content.Shared.Heretic;
+using Content.Shared.Movement.Systems;
+using Robust.Shared.Timing;
+using Content.Server.Atmos.EntitySystems;
+using Content.Shared.Heretic.Components;
+
+namespace Content.Server.Heretic.Abilities;
+public sealed partial class BlazingDashSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly MovementSpeedModifierSystem _movementSpeedModifier = default!;
+    [Dependency] private readonly AudioSystem _audio = default!;
+    [Dependency] private readonly FlammableSystem _flammable = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<BlazingDashComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshSpeed);
+    }
+
+    public override void Update(float timeframe)
+    {
+        base.Update(timeframe);
+
+        var dashEndQuery = EntityQueryEnumerator<BlazingDashComponent>();
+        while (dashEndQuery.MoveNext(out var uid, out var dashComp))
+        {
+            RefreshBlazingDash(uid, dashComp);
+        }
+    }
+
+    public void TryDoDash(Entity<HereticComponent> ent, ref EventHereticBlazingDash args)
+    {
+        var dashComp = EnsureComp<BlazingDashComponent>(ent);
+
+        dashComp.BlazingDashActive = true;
+        dashComp.BlazingDashEndTime = _timing.CurTime + dashComp.BlazingDashDuration;
+        _movementSpeedModifier.RefreshMovementSpeedModifiers(ent);
+        _audio.PlayPvs(dashComp.DashSound, ent, AudioParams.Default
+            .WithVolume(-2f)
+            .WithMaxDistance(15f)
+            .WithRolloffFactor(0.8f)
+            );
+        args.Handled = true;
+    }
+
+    private void RefreshBlazingDash(EntityUid uid, BlazingDashComponent dashComp)
+    {
+        if (dashComp.BlazingDashActive && _timing.CurTime >= dashComp.BlazingDashEndTime)
+        {
+            dashComp.BlazingDashActive = false;
+            _movementSpeedModifier.RefreshMovementSpeedModifiers(uid);
+        }
+        else if (dashComp.BlazingDashActive)
+        {
+            //refreshes over and over, so the firestacks are repeatedly transferred to people you touch
+            //performs fine on my localhost but it might get laggy on a server with multiple heretics
+            if (TryComp<FlammableComponent>(uid, out var flam))
+            {
+                _flammable.SetFireStacks(uid, dashComp.DashFireStacks, flam, true);
+            }
+        }
+    }
+
+    private void OnRefreshSpeed(Entity<BlazingDashComponent> ent, ref RefreshMovementSpeedModifiersEvent args)
+    {
+        if (ent.Comp.BlazingDashActive)
+        {
+            args.ModifySpeed(ent.Comp.DashWalkSpeed, ent.Comp.DashRunSpeed);
+        }
+        else
+        {
+            args.ModifySpeed(1f, 1f);
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/EldritchInfluenceSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/EldritchInfluenceSystem.cs
new file mode 100644
index 0000000000000..f7a13dde4b5f9
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/EldritchInfluenceSystem.cs
@@ -0,0 +1,69 @@
+using Content.Server.Heretic.Components;
+using Content.Server.Popups;
+using Content.Shared.DoAfter;
+using Content.Shared.Heretic;
+using Content.Shared.Interaction;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class EldritchInfluenceSystem : EntitySystem
+{
+    [Dependency] private readonly SharedDoAfterSystem _doafter = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly HereticSystem _heretic = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<EldritchInfluenceComponent, InteractHandEvent>(OnInteract);
+        SubscribeLocalEvent<EldritchInfluenceComponent, InteractUsingEvent>(OnInteractUsing);
+        SubscribeLocalEvent<EldritchInfluenceComponent, EldritchInfluenceDoAfterEvent>(OnDoAfter);
+    }
+
+    public bool CollectInfluence(Entity<EldritchInfluenceComponent> influence, Entity<HereticComponent> user, EntityUid? used = null)
+    {
+        if (influence.Comp.Spent)
+            return false;
+
+        var ev = new CheckMagicItemEvent();
+        RaiseLocalEvent(user, ev);
+        if (used != null) RaiseLocalEvent((EntityUid) used, ev);
+
+        var doAfter = new EldritchInfluenceDoAfterEvent()
+        {
+            MagicItemActive = ev.Handled,
+        };
+        var dargs = new DoAfterArgs(EntityManager, user, 10f, doAfter, influence, influence);
+        _popup.PopupEntity(Loc.GetString("heretic-influence-start"), influence, user);
+        return _doafter.TryStartDoAfter(dargs);
+    }
+
+    private void OnInteract(Entity<EldritchInfluenceComponent> ent, ref InteractHandEvent args)
+    {
+        if (args.Handled
+        || !TryComp<HereticComponent>(args.User, out var heretic))
+            return;
+
+        args.Handled = CollectInfluence(ent, (args.User, heretic));
+    }
+    private void OnInteractUsing(Entity<EldritchInfluenceComponent> ent, ref InteractUsingEvent args)
+    {
+        if (args.Handled
+        || !TryComp<HereticComponent>(args.User, out var heretic))
+            return;
+
+        args.Handled = CollectInfluence(ent, (args.User, heretic), args.Used);
+    }
+    private void OnDoAfter(Entity<EldritchInfluenceComponent> ent, ref EldritchInfluenceDoAfterEvent args)
+    {
+        if (args.Cancelled
+        || args.Target == null
+        || !TryComp<HereticComponent>(args.User, out var heretic))
+            return;
+
+        _heretic.UpdateKnowledge(args.User, heretic, args.MagicItemActive ? 2 : 1);
+
+        Spawn("EldritchInfluenceIntermediate", Transform((EntityUid) args.Target).Coordinates);
+        QueueDel(args.Target);
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/GhoulSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/GhoulSystem.cs
new file mode 100644
index 0000000000000..3ffe974083777
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/GhoulSystem.cs
@@ -0,0 +1,154 @@
+using Content.Server.Administration.Systems;
+using Content.Server.Antag;
+using Content.Server.Atmos.Components;
+using Content.Server.Body.Components;
+using Content.Server.Ghost.Roles.Components;
+using Content.Server.Humanoid;
+using Content.Server.Mind.Commands;
+using Content.Server.Roles;
+using Content.Server.Temperature.Components;
+using Content.Shared.Body.Systems;
+using Content.Shared.Damage;
+using Content.Shared.Examine;
+using Content.Shared.Ghost.Roles.Components;
+using Content.Shared.Heretic;
+using Content.Shared.Humanoid;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Mind;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.NPC.Systems;
+using Content.Shared.Nutrition.AnimalHusbandry;
+using Content.Shared.Nutrition.Components;
+using Content.Shared.Roles;
+using Robust.Shared.Audio;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class GhoulSystem : Shared.Heretic.EntitySystems.SharedGhoulSystem
+{
+    [Dependency] private readonly SharedMindSystem _mind = default!;
+    [Dependency] private readonly DamageableSystem _damage = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
+    [Dependency] private readonly HumanoidAppearanceSystem _humanoid = default!;
+    [Dependency] private readonly RejuvenateSystem _rejuvenate = default!;
+    [Dependency] private readonly NpcFactionSystem _faction = default!;
+    [Dependency] private readonly SharedRoleSystem _role = default!;
+    [Dependency] private readonly MobThresholdSystem _threshold = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly SharedBodySystem _body = default!;
+
+    public void GhoulifyEntity(Entity<GhoulComponent> ent)
+    {
+        RemComp<RespiratorComponent>(ent);
+        RemComp<BarotraumaComponent>(ent);
+        RemComp<HungerComponent>(ent);
+        RemComp<ThirstComponent>(ent);
+        RemComp<ReproductiveComponent>(ent);
+        RemComp<ReproductivePartnerComponent>(ent);
+        RemComp<TemperatureComponent>(ent);
+
+        var hasMind = _mind.TryGetMind(ent, out var mindId, out var mind);
+        if (hasMind && ent.Comp.BoundHeretic != null)
+            SendBriefing(ent, mindId, mind);
+
+        if (TryComp<HumanoidAppearanceComponent>(ent, out var humanoid))
+        {
+            // make them "have no eyes" and grey
+            // this is clearly a reference to grey tide
+            var greycolor = Color.FromHex("#505050");
+            _humanoid.SetSkinColor(ent, greycolor, true, false, humanoid);
+            _humanoid.SetBaseLayerColor(ent, HumanoidVisualLayers.Eyes, greycolor, true, humanoid);
+        }
+
+        _rejuvenate.PerformRejuvenate(ent);
+        if (TryComp<MobThresholdsComponent>(ent, out var th))
+        {
+            _threshold.SetMobStateThreshold(ent, ent.Comp.TotalHealth, MobState.Dead, th);
+            _threshold.SetMobStateThreshold(ent, ent.Comp.TotalHealth / 1.25f, MobState.Critical, th);
+        }
+
+        MakeSentientCommand.MakeSentient(ent, EntityManager);
+
+        if (!HasComp<GhostRoleComponent>(ent) && !hasMind)
+        {
+            var ghostRole = EnsureComp<GhostRoleComponent>(ent);
+            ghostRole.RoleName = Loc.GetString("ghostrole-ghoul-name");
+            ghostRole.RoleDescription = Loc.GetString("ghostrole-ghoul-desc");
+            ghostRole.RoleRules = Loc.GetString("ghostrole-ghoul-rules");
+        }
+
+        if (!HasComp<GhostRoleMobSpawnerComponent>(ent) && !hasMind)
+            EnsureComp<GhostTakeoverAvailableComponent>(ent);
+
+        _faction.ClearFactions((ent, null));
+        _faction.AddFaction((ent, null), "Heretic");
+    }
+
+    private void SendBriefing(Entity<GhoulComponent> ent, EntityUid mindId, MindComponent? mind)
+    {
+        var brief = Loc.GetString("heretic-ghoul-greeting-noname");
+
+        if (ent.Comp.BoundHeretic != null)
+            brief = Loc.GetString("heretic-ghoul-greeting", ("ent", Identity.Entity((EntityUid) ent.Comp.BoundHeretic, EntityManager)));
+        var sound = new SoundPathSpecifier("/Audio/_Goobstation/Heretic/Ambience/Antag/Heretic/heretic_gain.ogg");
+        _antag.SendBriefing(ent, brief, Color.MediumPurple, sound);
+
+        if (!TryComp<GhoulRoleComponent>(ent, out _))
+            AddComp<GhoulRoleComponent>(mindId, new(), overwrite: true);
+
+        if (!TryComp<RoleBriefingComponent>(ent, out var rolebrief))
+            AddComp(mindId, new RoleBriefingComponent() { Briefing = brief }, overwrite: true);
+        else rolebrief.Briefing += $"\n{brief}";
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<GhoulComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<GhoulComponent, AttackAttemptEvent>(OnTryAttack);
+        SubscribeLocalEvent<GhoulComponent, TakeGhostRoleEvent>(OnTakeGhostRole);
+        SubscribeLocalEvent<GhoulComponent, ExaminedEvent>(OnExamine);
+        SubscribeLocalEvent<GhoulComponent, MobStateChangedEvent>(OnMobStateChange);
+    }
+
+    private void OnInit(Entity<GhoulComponent> ent, ref ComponentInit args)
+    {
+        foreach (var look in _lookup.GetEntitiesInRange<HereticComponent>(Transform(ent).Coordinates, 1.5f))
+        {
+            if (ent.Comp.BoundHeretic == null)
+                ent.Comp.BoundHeretic = look;
+            else break;
+        }
+
+        GhoulifyEntity(ent);
+    }
+    private void OnTakeGhostRole(Entity<GhoulComponent> ent, ref TakeGhostRoleEvent args)
+    {
+        var hasMind = _mind.TryGetMind(ent, out var mindId, out var mind);
+        if (hasMind)
+            SendBriefing(ent, mindId, mind);
+    }
+
+    private void OnTryAttack(Entity<GhoulComponent> ent, ref AttackAttemptEvent args)
+    {
+        // prevent attacking owner and other heretics
+        if (args.Target == ent.Owner
+        || HasComp<HereticComponent>(args.Target))
+            args.Cancel();
+    }
+
+    private void OnExamine(Entity<GhoulComponent> ent, ref ExaminedEvent args)
+    {
+        args.PushMarkup($"[color=red]{Loc.GetString("heretic-ghoul-examine", ("ent", args.Examined))}[/color]");
+    }
+
+    private void OnMobStateChange(Entity<GhoulComponent> ent, ref MobStateChangedEvent args)
+    {
+        if (args.NewMobState == MobState.Dead)
+            _body.GibBody(ent);
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HellWorldSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HellWorldSystem.cs
new file mode 100644
index 0000000000000..3db65612ad11e
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HellWorldSystem.cs
@@ -0,0 +1,183 @@
+using Content.Server.GameTicking.Events;
+using Content.Shared.Mind.Components;
+using Content.Shared.Mind;
+using Robust.Shared.Timing;
+using System.Linq;
+using Content.Server.Heretic.Components;
+using Content.Shared.Heretic.Prototypes;
+using Content.Shared.Examine;
+using Content.Server.Body.Systems;
+using Content.Server._Goobstation.Heretic.Components;
+using Content.Server._Goobstation.Heretic.UI;
+using System.Collections.Immutable;
+using Content.Server.EUI;
+using Robust.Shared.Random;
+using Content.Server.Humanoid;
+using Content.Shared.Humanoid.Prototypes;
+using Content.Server.Administration.Systems;
+using Content.Shared.Humanoid;
+using Robust.Shared.Utility;
+using Robust.Shared.EntitySerialization;
+using Robust.Shared.EntitySerialization.Systems;
+using Robust.Server.GameObjects;
+using Content.Shared.Eye.Blinding.Systems;
+using Content.Shared.Eye.Blinding.Components;
+using Content.Server.StationEvents;
+
+//this is kind of badly named since we're doing infinite archives stuff now but i dont feel like changing it :)
+
+namespace Content.Server._Goobstation.Heretic.EntitySystems
+{
+
+    public sealed partial class HellWorldSystem : EntitySystem
+    {
+        [Dependency] private readonly SharedMindSystem _mind = default!;
+        [Dependency] private readonly SharedMapSystem _map = default!;
+        [Dependency] private readonly MetaDataSystem _metaSystem = default!;
+        [Dependency] private readonly SharedTransformSystem _xform = default!;
+        [Dependency] private readonly MapLoaderSystem _mapLoader = default!;
+        [Dependency] private readonly EuiManager _euiMan = default!;
+        [Dependency] private readonly HumanoidAppearanceSystem _humanoid = default!;
+        [Dependency] private readonly EntityLookupSystem _lookup = default!;
+        [Dependency] private readonly RejuvenateSystem _rejuvenate = default!;
+        [Dependency] private readonly BlindableSystem _blind = default!;
+        [Dependency] private readonly IGameTiming _timing = default!;
+        [Dependency] private readonly IRobustRandom _random = default!;
+        [Dependency] private readonly IEntityManager _ent = default!;
+
+        private readonly ResPath _mapPath = new("Maps/_Impstation/Nonstations/InfiniteArchives.yml"); 
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<HellVictimComponent, ExaminedEvent>(OnExamine);
+        }
+
+        /// <summary>
+        /// Creates the hell world map.
+        /// </summary>
+        public void MakeHell()
+        {
+            if(_mapLoader.TryLoadMap(_mapPath, out var map, out _, new DeserializationOptions { InitializeMaps = true }))
+            _map.SetPaused(map.Value.Comp.MapId, false);
+        }
+
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+
+            //hell world return
+            var returnQuery = EntityQueryEnumerator<HellVictimComponent>();
+            while (returnQuery.MoveNext(out var uid, out var victimComp))
+            {
+                //if they've been in hell long enough, return and revive them
+                if (_timing.CurTime >= victimComp.ExitHellTime && !victimComp.CleanupDone)
+                {
+                    //make sure they won't get into this loop again
+                    victimComp.CleanupDone = true;
+                    if (victimComp.Mind != null) //if they ghosted before the gib, no need to return the hell mind to the body
+                    {
+                        //put them back in the original body
+                        _mind.TransferTo(victimComp.Mind.Value, victimComp.OriginalBody);
+                        //let them ghost again
+                        MindComponent? mindComp = Comp<MindComponent>(victimComp.Mind.Value);
+                        mindComp.PreventGhosting = false;
+                    }
+                    //give the original body some visual changes
+                    TransformVictim(uid);
+                    //tell them about the metashield
+                    if (_mind.TryGetSession(victimComp.Mind, out var session))
+                        _euiMan.OpenEui(new HellMemoryEui(), session);
+                    //and then revive the old body
+                    _rejuvenate.PerformRejuvenate(uid);
+                }
+            }
+        }
+
+        public void AddVictimComponent(EntityUid victim)
+        {
+            EnsureComp<HellVictimComponent>(victim, out var victimComp);
+            victimComp.OriginalBody = victim;
+            victimComp.ExitHellTime = _timing.CurTime + victimComp.HellDuration;
+            victimComp.OriginalPosition = Transform(victim).Coordinates;
+            //make sure the victim has a mind
+            if (!TryComp<MindContainerComponent>(victim, out var mindContainer) || !mindContainer.HasMind)
+            {
+                return;
+            }
+            victimComp.HasMind = true;
+            victimComp.Mind = mindContainer.Mind.Value;
+        }
+
+        //AddVictimComponent MUST BE RUN BEFORE CALLING THIS!!
+        public void SendToHell(EntityUid target, RitualData args, SpeciesPrototype species)
+        {
+            //get the hell victim component
+            if (!args.EntityManager.TryGetComponent<HellVictimComponent>(target, out var victimComp))
+                return;
+            //if already sent, don't send again
+            if(victimComp.AlreadyHelled)
+                return;
+
+            //get all possible spawn points, choose one, then get the place
+            var spawnPoints = EntityManager.GetAllComponents(typeof(HellSpawnPointComponent)).ToImmutableList();
+            var newSpawn = _random.Pick(spawnPoints);
+            var spawnTgt = Transform(newSpawn.Uid).Coordinates;
+
+            //spawn your hellsona
+            if (!victimComp.HasMind || victimComp.Mind == null) //just in case the 
+            {
+                victimComp.AlreadyHelled = true;
+                return;
+            }
+            MindComponent? mindComp = Comp<MindComponent>(victimComp.Mind.Value);
+            mindComp.PreventGhosting = true;
+            //don't have to change this one's blood because nobody's bringing a forensic scanner to hell
+            var sufferingWhiteBoy = Spawn(species.Prototype, spawnTgt);
+            _metaSystem.SetEntityName(sufferingWhiteBoy, MetaData(target).EntityName);
+            _humanoid.CloneAppearance(victimComp.OriginalBody, sufferingWhiteBoy);
+            if (TryComp<BlindableComponent>(sufferingWhiteBoy, out var blindable))
+            {
+                _blind.AdjustEyeDamage(sufferingWhiteBoy, 5); //make it more disorienting
+
+            }
+
+            //and then send the mind into the hellsona
+            _mind.TransferTo(victimComp.Mind.Value, sufferingWhiteBoy);
+            victimComp.AlreadyHelled = true;
+
+            //returning the mind to the original body happens in Update()
+        }
+
+        public void TeleportRandomly(RitualData args, EntityUid uid) 
+        {
+            //get all possible spawn points, choose one, then get the place
+            var spawnPoints = EntityManager.GetAllComponents(typeof(MidRoundAntagSpawnLocationComponent)).ToImmutableList();
+            var newSpawn = _random.Pick(spawnPoints);
+            var spawnTgt = Transform(newSpawn.Uid).Coordinates;
+
+            _xform.SetCoordinates(uid, spawnTgt);
+        }
+
+        private void TransformVictim(EntityUid ent)
+        {
+            if (TryComp<HumanoidAppearanceComponent>(ent, out var humanoid))
+            {
+                //there's no color saturation methods so you get this garbage instead
+                var skinColor = humanoid.SkinColor;
+                var colorHSV = Color.ToHsv(skinColor);
+                colorHSV.Y /= 4;
+                var newColor = Color.FromHsv(colorHSV);
+                //make them look like they've seen some shit
+                _humanoid.SetSkinColor(ent, newColor, true, false, humanoid);
+                _humanoid.SetBaseLayerColor(ent, HumanoidVisualLayers.Eyes, Color.White, true, humanoid);
+            }
+        }
+
+        private void OnExamine(Entity<HellVictimComponent> ent, ref ExaminedEvent args)
+        {
+            args.PushMarkup($"[color=red]{Loc.GetString("heretic-hell-victim-examine", ("ent", args.Examined))}[/color]");
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticBladeSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticBladeSystem.cs
new file mode 100644
index 0000000000000..a188c1456bba7
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticBladeSystem.cs
@@ -0,0 +1,252 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Body.Systems;
+using Content.Server.Heretic.Components;
+using Content.Server.Temperature.Components;
+using Content.Server.Temperature.Systems;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.Examine;
+using Content.Shared.Heretic;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Physics;
+using Content.Shared.Popups;
+using Content.Shared.Temperature.Systems;
+using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Collections;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticBladeSystem : EntitySystem
+{
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly SharedTransformSystem _xform = default!;
+    [Dependency] private readonly EntityLookupSystem _lookupSystem = default!;
+    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
+    [Dependency] private readonly HereticCombatMarkSystem _combatMark = default!;
+    [Dependency] private readonly FlammableSystem _flammable = default!;
+    [Dependency] private readonly BloodstreamSystem _blood = default!;
+    [Dependency] private readonly DamageableSystem _damage = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly TemperatureSystem _temp = default!;
+
+    private EntityQuery<PhysicsComponent> _physicsQuery;
+    private HashSet<Entity<MapGridComponent>> _targetGrids = [];
+
+    public void ApplySpecialEffect(EntityUid performer, EntityUid target)
+    {
+        if (!TryComp<HereticComponent>(performer, out var hereticComp))
+            return;
+
+        switch (hereticComp.CurrentPath)
+        {
+            case "Ash":
+                _flammable.AdjustFireStacks(target, 2.5f, ignite: true);
+                break;
+
+            case "Blade":
+                // todo: double it's damage
+                break;
+
+            case "Flesh":
+                // ultra bleed
+                _blood.TryModifyBleedAmount(target, 1.5f);
+                break;
+
+            case "Lock":
+                // todo: do something that has weeping and avulsion in it
+                if (_random.Next(0, 10) >= 8)
+                    _blood.TryModifyBleedAmount(target, 10f);
+                break;
+
+            case "Rust":
+                var dmgProt = _proto.Index((ProtoId<DamageGroupPrototype>) "Poison");
+                var dmgSpec = new DamageSpecifier(dmgProt, 7.5f);
+                _damage.TryChangeDamage(target, dmgSpec);
+                break;
+
+            case "Void":
+                if (TryComp<TemperatureComponent>(target, out var temp))
+                    _temp.ForceChangeTemperature(target, temp.CurrentTemperature - 5f, temp);
+                break;
+
+            default:
+                return;
+        }
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _physicsQuery = GetEntityQuery<PhysicsComponent>();
+        SubscribeLocalEvent<HereticBladeComponent, UseInHandEvent>(OnInteract);
+        SubscribeLocalEvent<HereticBladeComponent, ExaminedEvent>(OnExamine);
+        SubscribeLocalEvent<HereticBladeComponent, MeleeHitEvent>(OnMeleeHit);
+    }
+
+    private void OnInteract(Entity<HereticBladeComponent> ent, ref UseInHandEvent args)
+    {
+        if (!TryComp<HereticComponent>(args.User, out var heretic))
+            return;
+
+        var xform = Transform(args.User);
+        // 250 because for some reason it counts "10" as 1 tile
+        var targetCoords = SelectRandomTileInRange(xform, 250f);
+        var queuedel = true;
+
+        // void path exxclusive
+        if (heretic.CurrentPath == "Void" && heretic.PathStage >= 7)
+        {
+            var look = _lookupSystem.GetEntitiesInRange<HereticCombatMarkComponent>(Transform(ent).Coordinates, 20f);
+            if (look.Count > 0)
+            {
+                targetCoords = Transform(look.ToList()[0]).Coordinates;
+                queuedel = false;
+            }
+        }
+
+        if (targetCoords != null)
+        {
+            _xform.SetCoordinates(args.User, targetCoords.Value);
+            _audio.PlayPvs(new SoundPathSpecifier("/Audio/Effects/tesla_consume.ogg"), args.User);
+            args.Handled = true;
+        }
+
+        _popup.PopupEntity(Loc.GetString("heretic-blade-use"), args.User, args.User);
+
+        if (queuedel)
+            QueueDel(ent);
+    }
+
+    private void OnExamine(Entity<HereticBladeComponent> ent, ref ExaminedEvent args)
+    {
+        if (!TryComp<HereticComponent>(args.Examiner, out var heretic))
+            return;
+
+        var isUpgradedVoid = heretic.CurrentPath == "Void" && heretic.PathStage >= 7;
+
+        var sb = new StringBuilder();
+        sb.AppendLine(Loc.GetString("heretic-blade-examine"));
+        if (isUpgradedVoid) sb.AppendLine(Loc.GetString("heretic-blade-void-examine"));
+
+        args.PushMarkup(sb.ToString());
+    }
+
+    private void OnMeleeHit(Entity<HereticBladeComponent> ent, ref MeleeHitEvent args)
+    {
+        if (string.IsNullOrWhiteSpace(ent.Comp.Path))
+            return;
+
+        if (!TryComp<HereticComponent>(args.User, out var hereticComp))
+            return;
+
+        foreach (var hit in args.HitEntities)
+        {
+            // does not work on other heretics
+            if (HasComp<HereticComponent>(hit))
+                continue;
+
+            if (TryComp<HereticCombatMarkComponent>(hit, out var mark))
+            {
+                _combatMark.ApplyMarkEffect(hit, ent.Comp.Path);
+                RemComp(hit, mark);
+            }
+
+            if (hereticComp.PathStage >= 7)
+                ApplySpecialEffect(args.User, hit);
+        }
+    }
+
+    private EntityCoordinates? SelectRandomTileInRange(TransformComponent userXform, float radius)
+    {
+        var userCoords = userXform.Coordinates.ToMap(EntityManager, _xform);
+        _targetGrids.Clear();
+        _lookupSystem.GetEntitiesInRange(userCoords, radius, _targetGrids);
+        Entity<MapGridComponent>? targetGrid = null;
+
+        if (_targetGrids.Count == 0)
+            return null;
+
+        // Give preference to the grid the entity is currently on.
+        // This does not guarantee that if the probability fails that the owner's grid won't be picked.
+        // In reality the probability is higher and depends on the number of grids.
+        if (userXform.GridUid != null && TryComp<MapGridComponent>(userXform.GridUid, out var gridComp))
+        {
+            var userGrid = new Entity<MapGridComponent>(userXform.GridUid.Value, gridComp);
+            if (_random.Prob(0.5f))
+            {
+                _targetGrids.Remove(userGrid);
+                targetGrid = userGrid;
+            }
+        }
+
+        if (targetGrid == null)
+            targetGrid = _random.GetRandom().PickAndTake(_targetGrids);
+
+        EntityCoordinates? targetCoords = null;
+
+        do
+        {
+            var valid = false;
+
+            var range = (float) Math.Sqrt(radius);
+            var box = Box2.CenteredAround(userCoords.Position, new Vector2(range, range));
+            var tilesInRange = _mapSystem.GetTilesEnumerator(targetGrid.Value.Owner, targetGrid.Value.Comp, box, false);
+            var tileList = new ValueList<Vector2i>();
+
+            while (tilesInRange.MoveNext(out var tile))
+            {
+                tileList.Add(tile.GridIndices);
+            }
+
+            while (tileList.Count != 0)
+            {
+                var tile = tileList.RemoveSwap(_random.Next(tileList.Count));
+                valid = true;
+                foreach (var entity in _mapSystem.GetAnchoredEntities(targetGrid.Value.Owner, targetGrid.Value.Comp,
+                             tile))
+                {
+                    if (!_physicsQuery.TryGetComponent(entity, out var body))
+                        continue;
+
+                    if (body.BodyType != BodyType.Static ||
+                        !body.Hard ||
+                        (body.CollisionLayer & (int) CollisionGroup.MobMask) == 0)
+                        continue;
+
+                    valid = false;
+                    break;
+                }
+
+                if (valid)
+                {
+                    targetCoords = new EntityCoordinates(targetGrid.Value.Owner,
+                        _mapSystem.TileCenterToVector(targetGrid.Value, tile));
+                    break;
+                }
+            }
+
+            if (valid || _targetGrids.Count == 0) // if we don't do the check here then PickAndTake will blow up on an empty set.
+                break;
+
+            targetGrid = _random.GetRandom().PickAndTake(_targetGrids);
+        } while (true);
+
+        return targetCoords;
+    }
+
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticCombatMarkSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticCombatMarkSystem.cs
new file mode 100644
index 0000000000000..98a6765b053cd
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticCombatMarkSystem.cs
@@ -0,0 +1,142 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Body.Systems;
+using Content.Server.Popups;
+using Content.Server.Temperature.Systems;
+using Content.Shared.Atmos;
+using Content.Shared.Popups;
+using Content.Shared.Doors.Components;
+using Content.Shared.Doors.Systems;
+using Content.Shared.Heretic;
+using Content.Shared.Inventory;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+using System.Linq;
+using Content.Shared.Humanoid;
+using Content.Server.Temperature.Components;
+using Content.Server.Body.Components;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticCombatMarkSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly FlammableSystem _flammable = default!;
+    [Dependency] private readonly SharedDoorSystem _door = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly TemperatureSystem _temperature = default!;
+    [Dependency] private readonly BloodstreamSystem _blood = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+
+    public bool ApplyMarkEffect(EntityUid target, string? path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+            return false;
+
+        switch (path)
+        {
+            case "Ash":
+                // gives fire stacks
+                _flammable.AdjustFireStacks(target, 5, ignite: true);
+                break;
+
+            case "Blade":
+                // TODO: add rotating protective blade type shit
+                break;
+
+            case "Flesh":
+                if (TryComp<BloodstreamComponent>(target, out var blood))
+                {
+                    _blood.TryModifyBleedAmount(target, 5f, blood);
+                    _blood.SpillAllSolutions(target, blood);
+                }
+                break;
+
+            case "Lock":
+                // bolts nearby doors
+                var lookup = _lookup.GetEntitiesInRange(target, 5f);
+                foreach (var door in lookup)
+                {
+                    if (!TryComp<DoorBoltComponent>(door, out var doorComp))
+                        continue;
+                    _door.SetBoltsDown((door, doorComp), true);
+                }
+                _audio.PlayPvs(new SoundPathSpecifier("/Audio/Magic/knock.ogg"), target);
+                break;
+
+            case "Rust":
+                // TODO: add item damage, for now just break a random item
+                if (!TryComp<InventoryComponent>(target, out var inv))
+                    break;
+
+                var contrandom = _random.Next(0, inv.Containers.Length - 1);
+                if (contrandom < 0)
+                    break;
+                var cont = inv.Containers[contrandom];
+
+                var itemrandom = _random.Next(0, cont.ContainedEntities.Count - 1);
+                if (itemrandom < 0)
+                    break;
+                var item = cont.ContainedEntities[itemrandom];
+
+                _popup.PopupEntity(Loc.GetString("heretic-rust-mark-itembreak", ("name", Name(item))), target, PopupType.LargeCaution);
+                QueueDel(item);
+                break;
+
+            case "Void":
+                // set target's temperature to -40C
+                // is really OP with the new temperature slowing thing :godo:
+                if (TryComp<TemperatureComponent>(target, out var temp))
+                    _temperature.ForceChangeTemperature(target, temp.CurrentTemperature - 100f, temp);
+                break;
+
+            default:
+                return false;
+        }
+
+        // transfers the mark to the next nearby person
+        var look = _lookup.GetEntitiesInRange(target, 2.5f);
+        if (look.Count != 0)
+        {
+            var lookent = look.ToArray()[0];
+            if (HasComp<HumanoidAppearanceComponent>(lookent)
+            && !HasComp<HereticComponent>(lookent))
+            {
+                var markComp = EnsureComp<HereticCombatMarkComponent>(lookent);
+                markComp.Path = path;
+            }
+        }
+
+        return true;
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticCombatMarkComponent, ComponentStartup>(OnStart);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        if (!_timing.IsFirstTimePredicted)
+            return;
+
+        foreach (var comp in EntityQuery<HereticCombatMarkComponent>())
+        {
+            if (_timing.CurTime > comp.Timer)
+                RemComp(comp.Owner, comp);
+        }
+    }
+
+    private void OnStart(Entity<HereticCombatMarkComponent> ent, ref ComponentStartup args)
+    {
+        if (ent.Comp.Timer == TimeSpan.Zero)
+            ent.Comp.Timer = _timing.CurTime + TimeSpan.FromSeconds(ent.Comp.DisappearTime);
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticKnowledgeItemSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticKnowledgeItemSystem.cs
new file mode 100644
index 0000000000000..53b3c16ecda27
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticKnowledgeItemSystem.cs
@@ -0,0 +1,68 @@
+using Content.Server.Heretic.Components;
+using Content.Server.Popups;
+using Content.Shared.DoAfter;
+using Content.Shared.Examine;
+using Content.Shared.Heretic;
+using Content.Shared.Interaction.Events;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticKnowledgeItemSystem : EntitySystem
+{
+    [Dependency] private readonly SharedDoAfterSystem _doafter = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly HereticSystem _heretic = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<HereticKnowledgeItemComponent, UseInHandEvent>(OnUseInHand);
+        SubscribeLocalEvent<HereticKnowledgeItemComponent, HereticKnowledgeItemDoAfterEvent>(OnDoAfter);
+        SubscribeLocalEvent<HereticKnowledgeItemComponent, ExaminedEvent>(OnExamined);
+    }
+
+    private void OnUseInHand(Entity<HereticKnowledgeItemComponent> ent, ref UseInHandEvent args)
+    {
+        if (args.Handled || !HasComp<HereticComponent>(args.User))
+            return;
+
+        var user = args.User;
+        if (ent.Comp.Spent)
+            return;
+
+        var dargs = new DoAfterArgs(EntityManager, args.User, 10f, new HereticKnowledgeItemDoAfterEvent(), ent, used: ent);
+        _popup.PopupEntity(Loc.GetString("heretic-item-start"), ent, user);
+        _doafter.TryStartDoAfter(dargs);
+        args.Handled = true;
+    }
+
+    private void OnDoAfter(Entity<HereticKnowledgeItemComponent> ent, ref HereticKnowledgeItemDoAfterEvent args)
+    {
+        if (args.Cancelled || !TryComp<HereticComponent>(args.User, out var heretic))
+        {
+            return;
+        }
+        _heretic.UpdateKnowledge(args.User, heretic, 1f);
+
+        ent.Comp.Spent = true;
+    }
+
+    private void OnExamined(Entity<HereticKnowledgeItemComponent> ent, ref ExaminedEvent args)
+    {
+        if(TryComp<HereticComponent>(args.Examiner, out _))
+        {
+            if (ent.Comp.Spent)
+            {
+                args.PushMarkup(markup: $"[color=purple]{Loc.GetString("heretic-item-examine-spent")}[/color]");
+            }
+            else
+            {
+                args.PushMarkup(markup: $"[color=purple]{Loc.GetString("heretic-item-examine-unspent")}[/color]");
+            }
+        }
+        else
+        {
+            args.PushMarkup(markup: $"[color=purple]{Loc.GetString("heretic-item-examine-nonheretic")}[/color]");
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticKnowledgeSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticKnowledgeSystem.cs
new file mode 100644
index 0000000000000..ca59ca26a6d12
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticKnowledgeSystem.cs
@@ -0,0 +1,76 @@
+using Content.Shared.Actions;
+using Content.Shared.Heretic.Prototypes;
+using Content.Shared.Heretic;
+using Content.Shared.Popups;
+using Robust.Shared.Prototypes;
+using Content.Shared._Goobstation.Heretic.Components;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticKnowledgeSystem : EntitySystem
+{
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly SharedActionsSystem _action = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly HereticRitualSystem _ritual = default!;
+
+    public HereticKnowledgePrototype GetKnowledge(ProtoId<HereticKnowledgePrototype> id)
+        => _proto.Index(id);
+
+    public void AddKnowledge(EntityUid uid, HereticComponent comp, ProtoId<HereticKnowledgePrototype> id, bool silent = true)
+    {
+        var data = GetKnowledge(id);
+
+        if (data.Event != null)
+            RaiseLocalEvent(uid, (object) data.Event, true);
+
+        if (data.ActionPrototypes != null && data.ActionPrototypes.Count > 0)
+            foreach (var act in data.ActionPrototypes)
+                _action.AddAction(uid, act);
+
+        if (data.RitualPrototypes != null && data.RitualPrototypes.Count > 0)
+            foreach (var ritual in data.RitualPrototypes)
+                comp.KnownRituals.Add(_ritual.GetRitual(ritual));
+
+        Dirty(uid, comp);
+
+        // set path if out heretic doesn't have it, or if it's different from whatever he has atm
+        if (string.IsNullOrWhiteSpace(comp.CurrentPath))
+        {
+            if (!data.SideKnowledge && comp.CurrentPath != data.Path)
+                comp.CurrentPath = data.Path;
+        }
+
+        // make sure we only progress when buying current path knowledge
+        if (data.Stage > comp.PathStage && data.Path == comp.CurrentPath)
+            comp.PathStage = data.Stage;
+
+        if (!silent)
+            _popup.PopupEntity(Loc.GetString("heretic-knowledge-gain"), uid, uid);
+    }
+    public void RemoveKnowledge(EntityUid uid, HereticComponent comp, ProtoId<HereticKnowledgePrototype> id, bool silent = false)
+    {
+        var data = GetKnowledge(id);
+
+        if (data.ActionPrototypes != null && data.ActionPrototypes.Count > 0)
+        {
+            foreach (var act in data.ActionPrototypes)
+            {
+                var actionName = (EntityPrototype) _proto.Index(typeof(EntityPrototype), act);
+                // jesus christ.
+                foreach (var action in _action.GetActions(uid))
+                    if (Name(action.Id) == actionName.Name)
+                        _action.RemoveAction(action.Id);
+            }
+        }
+
+        if (data.RitualPrototypes != null && data.RitualPrototypes.Count > 0)
+            foreach (var ritual in data.RitualPrototypes)
+                comp.KnownRituals.Remove(_ritual.GetRitual(ritual));
+
+        Dirty(uid, comp);
+
+        if (!silent)
+            _popup.PopupEntity(Loc.GetString("heretic-knowledge-loss"), uid, uid);
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticMagicItemSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticMagicItemSystem.cs
new file mode 100644
index 0000000000000..e302bdcd30005
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticMagicItemSystem.cs
@@ -0,0 +1,48 @@
+using Content.Shared.Clothing.Components;
+using Content.Shared.Examine;
+using Content.Shared.Hands;
+using Content.Shared.Heretic;
+using Content.Shared.Inventory;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticMagicItemSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticMagicItemComponent, CheckMagicItemEvent>(OnCheckMagicItem);
+        SubscribeLocalEvent<HereticMagicItemComponent, HeldRelayedEvent<CheckMagicItemEvent>>(OnCheckMagicItem);
+        SubscribeLocalEvent<HereticMagicItemComponent, InventoryRelayedEvent<CheckMagicItemEvent>>(OnCheckMagicItem);
+        SubscribeLocalEvent<HereticMagicItemComponent, ExaminedEvent>(OnMagicItemExamine);
+    }
+
+    private void OnCheckMagicItem(Entity<HereticMagicItemComponent> ent, ref CheckMagicItemEvent args)
+    {
+        args.Handled = true;
+    }
+
+    private void OnCheckMagicItem(Entity<HereticMagicItemComponent> ent, ref HeldRelayedEvent<CheckMagicItemEvent> args)
+    {
+        //extra check to make sure clothing-based focus doesn't work in hand
+        if (!HasComp<ClothingComponent>(ent))
+        {
+            args.Args.Handled = true;
+        }
+        else
+        {
+            args.Args.Handled = false;
+        }
+    }
+    private void OnCheckMagicItem(Entity<HereticMagicItemComponent> ent, ref InventoryRelayedEvent<CheckMagicItemEvent> args)
+        => args.Args.Handled = true;
+
+    private void OnMagicItemExamine(Entity<HereticMagicItemComponent> ent, ref ExaminedEvent args)
+    {
+        if (!HasComp<HereticComponent>(args.Examiner))
+            return;
+
+        args.PushMarkup(Loc.GetString("heretic-magicitem-examine"));
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticRitualSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticRitualSystem.cs
new file mode 100644
index 0000000000000..fe040af21ba3a
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticRitualSystem.cs
@@ -0,0 +1,218 @@
+using Content.Server.Heretic.Components;
+using Content.Shared.Heretic.Prototypes;
+using Content.Shared.Heretic;
+using Content.Shared.Interaction;
+using Content.Shared.Popups;
+using Content.Shared.Tag;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Prototypes;
+using System.Text;
+using System.Linq;
+using Robust.Shared.Serialization.Manager;
+using Content.Shared.Examine;
+using Content.Shared._Goobstation.Heretic.Components;
+using Robust.Shared.Containers;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticRitualSystem : EntitySystem
+{
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly ISerializationManager _series = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly HereticKnowledgeSystem _knowledge = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedUserInterfaceSystem _uiSystem = default!;
+    [Dependency] private readonly SharedContainerSystem _container = default!;
+
+    public SoundSpecifier RitualSuccessSound = new SoundPathSpecifier("/Audio/_Goobstation/Heretic/castsummon.ogg");
+
+    public HereticRitualPrototype GetRitual(ProtoId<HereticRitualPrototype>? id)
+    {
+        if (id == null) throw new ArgumentNullException();
+        return _proto.Index<HereticRitualPrototype>(id);
+    }
+
+    /// <summary>
+    ///     Try to perform a selected ritual
+    /// </summary>
+    /// <returns> If the ritual succeeded or not </returns>
+    public bool TryDoRitual(EntityUid performer, EntityUid platform, ProtoId<HereticRitualPrototype> ritualId)
+    {
+        // here i'm introducing locals for basically everything
+        // because if i access stuff directly shit is bound to break.
+        // please don't access stuff directly from the prototypes or else shit will break.
+        // regards
+
+        if (!TryComp<HereticComponent>(performer, out var hereticComp))
+            return false;
+
+        var rit = _series.CreateCopy((HereticRitualPrototype) GetRitual(ritualId).Clone(), notNullableOverride: true);
+        var lookup = _lookup.GetEntitiesInRange(platform, .75f);
+
+        var missingList = new List<string>();
+        var toDelete = new List<EntityUid>();
+
+        // check for all conditions
+        // this is god awful but it is that it is
+        var behaviors = rit.CustomBehaviors ?? new();
+        var requiredTags = rit.RequiredTags?.ToDictionary(e => e.Key, e => e.Value) ?? new();
+
+        foreach (var behavior in behaviors)
+        {
+            var ritData = new RitualData(performer, platform, ritualId, EntityManager);
+
+            if (!behavior.Execute(ritData, out var missingStr))
+            {
+                if (missingStr != null)
+                    _popup.PopupEntity(missingStr, platform, performer);
+                return false;
+            }
+        }
+
+        foreach (var look in lookup)
+        {
+            // check for matching tags
+            foreach (var tag in requiredTags)
+            {
+                if (!TryComp<TagComponent>(look, out var tags) // no tags?
+                || _container.IsEntityInContainer(look)) // using your own eyes for amber focus?
+                    continue;
+
+                var ltags = tags.Tags;
+
+                if (ltags.Contains(tag.Key))
+                {
+                    requiredTags[tag.Key] -= 1;
+
+                    // prevent deletion of more items than needed
+                    if (requiredTags[tag.Key] >= 0)
+                        toDelete.Add(look);
+                }
+            }
+        }
+
+        // add missing tags
+        foreach (var tag in requiredTags)
+            if (tag.Value > 0)
+                missingList.Add(tag.Key);
+
+        // are we missing anything?
+        if (missingList.Count > 0)
+        {
+            // we are! notify the performer about that!
+            var sb = new StringBuilder();
+            for (int i = 0; i < missingList.Count; i++)
+            {
+                // makes a nice, list, of, missing, items.
+                if (i != missingList.Count - 1)
+                    sb.Append($"{missingList[i]}, ");
+                else sb.Append(missingList[i]);
+            }
+
+            _popup.PopupEntity(Loc.GetString("heretic-ritual-fail-items", ("itemlist", sb.ToString())), platform, performer);
+            return false;
+        }
+
+        // yay! ritual successfull!
+
+        // reset fields to their initial values
+        // BECAUSE FOR SOME REASON IT DOESN'T FUCKING WORK OTHERWISE!!!
+
+        // finalize all of the custom ones
+        foreach (var behavior in behaviors)
+        {
+            var ritData = new RitualData(performer, platform, ritualId, EntityManager);
+            behavior.Finalize(ritData);
+        }
+
+        // ya get some, ya lose some
+        foreach (var ent in toDelete)
+            QueueDel(ent);
+
+        // add stuff
+        var output = rit.Output ?? new();
+        foreach (var ent in output.Keys)
+            for (int i = 0; i < output[ent]; i++)
+                Spawn(ent, Transform(platform).Coordinates);
+
+        if (rit.OutputEvent != null)
+            RaiseLocalEvent(performer, rit.OutputEvent, true);
+
+        if (rit.OutputKnowledge != null)
+            _knowledge.AddKnowledge(performer, hereticComp, (ProtoId<HereticKnowledgePrototype>) rit.OutputKnowledge);
+
+        return true;
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticRitualRuneComponent, InteractHandEvent>(OnInteract);
+        SubscribeLocalEvent<HereticRitualRuneComponent, InteractUsingEvent>(OnInteractUsing);
+        SubscribeLocalEvent<HereticRitualRuneComponent, ExaminedEvent>(OnExamine);
+        SubscribeLocalEvent<HereticRitualRuneComponent, HereticRitualMessage>(OnRitualChosenMessage);
+    }
+
+    private void OnInteract(Entity<HereticRitualRuneComponent> ent, ref InteractHandEvent args)
+    {
+        if (!TryComp<HereticComponent>(args.User, out var heretic))
+            return;
+
+        if (heretic.KnownRituals.Count == 0)
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-ritual-norituals"), args.User, args.User);
+            return;
+        }
+
+        _uiSystem.OpenUi(ent.Owner, HereticRitualRuneUiKey.Key, args.User);
+    }
+
+    private void OnRitualChosenMessage(Entity<HereticRitualRuneComponent> ent, ref HereticRitualMessage args)
+    {
+        var user = args.Actor;
+
+        if (!TryComp<HereticComponent>(user, out var heretic))
+            return;
+
+        heretic.ChosenRitual = args.ProtoId;
+
+        var ritualName = Loc.GetString(GetRitual(heretic.ChosenRitual).LocName);
+        _popup.PopupEntity(Loc.GetString("heretic-ritual-switch", ("name", ritualName)), user, user);
+    }
+
+    private void OnInteractUsing(Entity<HereticRitualRuneComponent> ent, ref InteractUsingEvent args)
+    {
+        if (!TryComp<HereticComponent>(args.User, out var heretic))
+            return;
+
+        if (!TryComp<MansusGraspComponent>(args.Used, out var grasp))
+            return;
+
+        if (heretic.ChosenRitual == null)
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-ritual-noritual"), args.User, args.User);
+            return;
+        }
+
+        if (!TryDoRitual(args.User, ent, (ProtoId<HereticRitualPrototype>) heretic.ChosenRitual))
+            return;
+
+        _audio.PlayPvs(RitualSuccessSound, ent, AudioParams.Default.WithVolume(-3f));
+        _popup.PopupEntity(Loc.GetString("heretic-ritual-success"), ent, args.User);
+        Spawn("HereticRuneRitualAnimation", Transform(ent).Coordinates);
+    }
+
+    private void OnExamine(Entity<HereticRitualRuneComponent> ent, ref ExaminedEvent args)
+    {
+        if (!TryComp<HereticComponent>(args.Examiner, out var h))
+            return;
+
+        var ritual = h.ChosenRitual != null ? GetRitual(h.ChosenRitual).LocName : null;
+        var name = ritual != null ? Loc.GetString(ritual) : "None";
+        args.PushMarkup(Loc.GetString("heretic-ritualrune-examine", ("rit", name)));
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/HereticSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticSystem.cs
new file mode 100644
index 0000000000000..8463d403446f9
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/HereticSystem.cs
@@ -0,0 +1,151 @@
+using Content.Server.Objectives.Components;
+using Content.Server.Store.Systems;
+using Content.Shared.Examine;
+using Content.Shared.FixedPoint;
+using Content.Shared.Roles;
+using Content.Shared.Heretic;
+using Content.Shared.Mind;
+using Content.Shared.Store.Components;
+using Content.Shared.Heretic.Prototypes;
+using Content.Server.Chat.Systems;
+using Robust.Shared.Audio;
+using Content.Server.Temperature.Components;
+using Content.Server.Body.Components;
+using Content.Server.Atmos.Components;
+using Content.Shared.Damage;
+using Content.Server.Heretic.Components;
+using Content.Server.Antag;
+using Robust.Shared.Random;
+using System.Linq;
+using Content.Shared.Humanoid;
+using Robust.Server.Player;
+using Content.Server.Revolutionary.Components;
+using Content.Shared.Random.Helpers;
+using Content.Shared.Roles.Jobs;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class HereticSystem : EntitySystem
+{
+    [Dependency] private readonly SharedMindSystem _mind = default!;
+    [Dependency] private readonly StoreSystem _store = default!;
+    [Dependency] private readonly HereticKnowledgeSystem _knowledge = default!;
+    [Dependency] private readonly ChatSystem _chat = default!;
+    [Dependency] private readonly SharedJobSystem _jobs = default!;
+    [Dependency] private readonly SharedEyeSystem _eye = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
+    [Dependency] private readonly IRobustRandom _rand = default!;
+    [Dependency] private readonly IPlayerManager _playerMan = default!;
+    [Dependency] private readonly IPrototypeManager _prot = default!;
+
+    private float _timer = 0f;
+    private float _passivePointCooldown = 20f * 60f;
+    private static readonly ProtoId<JobPrototype> SecOffJobProtoID = "SecurityOfficer";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticComponent, ComponentInit>(OnCompInit);
+        SubscribeLocalEvent<HereticComponent, EventHereticAscension>(OnAscension);
+        SubscribeLocalEvent<HereticComponent, BeforeDamageChangedEvent>(OnBeforeDamage);
+        SubscribeLocalEvent<HereticComponent, DamageModifyEvent>(OnDamage);
+
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        _timer += frameTime;
+
+        if (_timer < _passivePointCooldown)
+            return;
+
+        _timer = 0f;
+
+        foreach (var heretic in EntityQuery<HereticComponent>())
+        {
+            // passive point gain every 20 minutes
+            UpdateKnowledge(heretic.Owner, heretic, 1f);
+        }
+    }
+
+    public void UpdateKnowledge(EntityUid uid, HereticComponent comp, float amount)
+    {
+        if (TryComp<StoreComponent>(uid, out var store))
+        {
+            _store.TryAddCurrency(new Dictionary<string, FixedPoint2> { { "KnowledgePoint", amount } }, uid, store);
+            _store.UpdateUserInterface(uid, uid, store);
+        }
+
+        if (_mind.TryGetMind(uid, out var mindId, out var mind))
+            if (_mind.TryGetObjectiveComp<HereticKnowledgeConditionComponent>(mindId, out var objective, mind))
+                objective.Researched += amount;
+    }
+
+    private void OnCompInit(Entity<HereticComponent> ent, ref ComponentInit args)
+    {
+        // add influence layer
+        if (TryComp<EyeComponent>(ent, out var eye))
+            _eye.SetVisibilityMask(ent, eye.VisibilityMask | EldritchInfluenceComponent.LayerMask);
+
+        foreach (var knowledge in ent.Comp.BaseKnowledge)
+            _knowledge.AddKnowledge(ent, ent.Comp, knowledge);
+    }
+
+    #region Internal events (target reroll, ascension, etc.)
+    // notify the crew of how good the person is and play the cool sound :godo:
+    private void OnAscension(Entity<HereticComponent> ent, ref EventHereticAscension args)
+    {
+        ent.Comp.Ascended = true;
+
+        // how???
+        if (ent.Comp.CurrentPath == null)
+            return;
+
+        var pathLoc = ent.Comp.CurrentPath!.ToLower();
+        var ascendSound = new SoundPathSpecifier($"/Audio/_Goobstation/Heretic/Ambience/Antag/Heretic/ascend_{pathLoc}.ogg");
+        _chat.DispatchGlobalAnnouncement(Loc.GetString($"heretic-ascension-{pathLoc}"), Name(ent), true, ascendSound, Color.Pink);
+
+        // do other logic, e.g. make heretic immune to whatever
+        switch (ent.Comp.CurrentPath!)
+        {
+            case "Ash":
+                RemComp<TemperatureComponent>(ent);
+                RemComp<RespiratorComponent>(ent);
+                RemComp<BarotraumaComponent>(ent);
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    #endregion
+
+    #region External events (damage, etc.)
+
+    private void OnBeforeDamage(Entity<HereticComponent> ent, ref BeforeDamageChangedEvent args)
+    {
+        // ignore damage from heretic stuff
+        if (args.Origin.HasValue && HasComp<HereticBladeComponent>(args.Origin))
+            args.Cancelled = true;
+    }
+    private void OnDamage(Entity<HereticComponent> ent, ref DamageModifyEvent args)
+    {
+        if (!ent.Comp.Ascended)
+            return;
+
+        switch (ent.Comp.CurrentPath)
+        {
+            case "Ash":
+                // nullify heat damage because zased
+                args.Damage.DamageDict["Heat"] = 0;
+                break;
+        }
+    }
+
+    #endregion
+}
diff --git a/Content.Server/_Goobstation/Heretic/EntitySystems/MansusGraspSystem.cs b/Content.Server/_Goobstation/Heretic/EntitySystems/MansusGraspSystem.cs
new file mode 100644
index 0000000000000..c4b27ee1d22ec
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/EntitySystems/MansusGraspSystem.cs
@@ -0,0 +1,207 @@
+using Content.Server.Chat.Systems;
+using Content.Server.EntityEffects.Effects.StatusEffects;
+using Content.Server.Heretic.Components;
+using Content.Server.Speech.EntitySystems;
+using Content.Server.Temperature.Components;
+using Content.Server.Temperature.Systems;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Systems;
+using Content.Shared.DoAfter;
+using Content.Shared.Doors.Components;
+using Content.Shared.Doors.Systems;
+using Content.Shared.Explosion.Components;
+using Content.Shared.Eye.Blinding.Systems;
+using Content.Shared.Hands;
+using Content.Shared.Heretic;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Silicons.Borgs.Components;
+using Content.Shared.Speech.Muting;
+using Content.Shared.StatusEffect;
+using Content.Shared.Stunnable;
+using Content.Shared.Tag;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+
+namespace Content.Server.Heretic.EntitySystems;
+
+public sealed partial class MansusGraspSystem : EntitySystem
+{
+    [Dependency] private readonly StaminaSystem _stamina = default!;
+    [Dependency] private readonly SharedStunSystem _stun = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly ChatSystem _chat = default!;
+    [Dependency] private readonly RatvarianLanguageSystem _language = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
+    [Dependency] private readonly SharedDoorSystem _door = default!;
+    [Dependency] private readonly StatusEffectsSystem _statusEffect = default!;
+    [Dependency] private readonly DamageableSystem _damage = default!;
+    [Dependency] private readonly TemperatureSystem _temperature = default!;
+
+    public void ApplyGraspEffect(EntityUid performer, EntityUid target, string path)
+    {
+        switch (path)
+        {
+            case "Ash":
+                var timeSpan = TimeSpan.FromSeconds(5f);
+                _statusEffect.TryAddStatusEffect(target, TemporaryBlindnessSystem.BlindingStatusEffect, timeSpan, false, TemporaryBlindnessSystem.BlindingStatusEffect);
+                break;
+
+            case "Blade":
+                // blade is basically an upgrade to the current grasp
+                _stamina.TakeStaminaDamage(target, 100f);
+                break;
+
+            case "Lock":
+                if (!TryComp<DoorComponent>(target, out var door))
+                    break;
+
+                if (TryComp<DoorBoltComponent>(target, out var doorBolt))
+                    _door.SetBoltsDown((target, doorBolt), false);
+
+                _door.StartOpening(target, door);
+                _audio.PlayPvs(new SoundPathSpecifier("/Audio/_Goobstation/Heretic/hereticknock.ogg"), target);
+                break;
+
+            case "Flesh":
+                if (TryComp<MobStateComponent>(target, out var mobState) && mobState.CurrentState == Shared.Mobs.MobState.Dead)
+                {
+                    var ghoul = EnsureComp<GhoulComponent>(target);
+                    ghoul.BoundHeretic = performer;
+                }
+                break;
+
+            case "Rust":
+                if (!TryComp<DamageableComponent>(target, out var dmg))
+                    break;
+                // hopefully damage only walls and cyborgs
+                if (HasComp<BorgChassisComponent>(target) || !HasComp<StatusEffectsComponent>(target))
+                    _damage.SetAllDamage(target, dmg, 50f);
+                break;
+
+            case "Void":
+                if (TryComp<TemperatureComponent>(target, out var temp))
+                    _temperature.ForceChangeTemperature(target, temp.CurrentTemperature - 20f, temp);
+                _statusEffect.TryAddStatusEffect<MutedComponent>(target, "Muted", TimeSpan.FromSeconds(8), false);
+                break;
+
+            default:
+                return;
+        }
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<MansusGraspComponent, AfterInteractEvent>(OnAfterInteract);
+
+        SubscribeLocalEvent<TagComponent, AfterInteractEvent>(OnAfterInteract);
+        SubscribeLocalEvent<HereticComponent, DrawRitualRuneDoAfterEvent>(OnRitualRuneDoAfter);
+        SubscribeLocalEvent<MansusGraspComponent, UseInHandEvent>(OnUseInHand);
+    }
+
+    private void OnAfterInteract(Entity<MansusGraspComponent> ent, ref AfterInteractEvent args)
+    {
+        if (args.Handled || !args.CanReach)
+            return;
+
+        if (args.Target == null || args.Target == args.User)
+            return;
+
+        if (!TryComp<HereticComponent>(args.User, out var hereticComp))
+        {
+            QueueDel(ent);
+            return;
+        }
+
+        var target = (EntityUid) args.Target;
+
+        if ((TryComp<HereticComponent>(args.Target, out var th) && th.CurrentPath == ent.Comp.Path))
+            return;
+
+        args.Handled = true;
+
+        if (HasComp<StatusEffectsComponent>(target))
+        {
+            _chat.TrySendInGameICMessage(args.User, Loc.GetString("heretic-speech-mansusgrasp"), InGameICChatType.Speak, false);
+            _audio.PlayPvs(new SoundPathSpecifier("/Audio/Items/welder.ogg"), target);
+            _stun.TryKnockdown(target, TimeSpan.FromSeconds(3f), true);
+            _stamina.TakeStaminaDamage(target, 80f);
+            _language.DoRatvarian(target, TimeSpan.FromSeconds(10f), true);
+        }
+
+        // upgraded grasp
+        if (hereticComp.CurrentPath != null)
+        {
+            if (hereticComp.PathStage >= 2)
+                ApplyGraspEffect(args.User, target, hereticComp.CurrentPath!);
+
+            if (hereticComp.PathStage >= 4 && HasComp<StatusEffectsComponent>(target))
+            {
+                var markComp = EnsureComp<HereticCombatMarkComponent>(target);
+                markComp.Path = hereticComp.CurrentPath;
+            }
+        }
+
+        hereticComp.MansusGraspActive = false;
+        QueueDel(ent);
+    }
+
+    private void OnUseInHand(EntityUid uid, MansusGraspComponent component, UseInHandEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!TryComp<HereticComponent>(args.User, out var hereticComp))
+        {
+            QueueDel(uid);
+            return;
+        }
+
+        args.Handled = true;
+        hereticComp.MansusGraspActive = false;
+        QueueDel(uid);
+    }
+
+    private void OnAfterInteract(Entity<TagComponent> ent, ref AfterInteractEvent args)
+    {
+        var tags = ent.Comp.Tags;
+
+        if (!args.CanReach
+        || !args.ClickLocation.IsValid(EntityManager)
+        || !TryComp<HereticComponent>(args.User, out var heretic) // not a heretic - how???
+        || !heretic.MansusGraspActive // no grasp - not special
+        || HasComp<ActiveDoAfterComponent>(args.User) // prevent rune shittery
+        || (!tags.Contains("Write") && !tags.Contains("DecapoidClaw"))) // not a writing implement or decapoid claw
+            return;
+
+        // remove our rune if clicked
+        if (args.Target != null && HasComp<HereticRitualRuneComponent>(args.Target))
+        {
+            // todo: add more fluff
+            QueueDel(args.Target);
+            return;
+        }
+
+        // spawn our rune
+        var rune = Spawn("HereticRuneRitualDrawAnimation", args.ClickLocation);
+        var dargs = new DoAfterArgs(EntityManager, args.User, 14f, new DrawRitualRuneDoAfterEvent(rune, args.ClickLocation), args.User)
+        {
+            BreakOnDamage = true,
+            BreakOnHandChange = true,
+            BreakOnMove = true,
+            CancelDuplicate = false,
+        };
+        _doAfter.TryStartDoAfter(dargs);
+    }
+    private void OnRitualRuneDoAfter(Entity<HereticComponent> ent, ref DrawRitualRuneDoAfterEvent ev)
+    {
+        // delete the animation rune regardless
+        QueueDel(ev.RitualRune);
+
+        if (!ev.Cancelled)
+            Spawn("HereticRuneRitual", ev.Coords);
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.AshAscend.cs b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.AshAscend.cs
new file mode 100644
index 0000000000000..2a7068de2bb8b
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.AshAscend.cs
@@ -0,0 +1,52 @@
+using Content.Server.Atmos.Components;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.Heretic.Prototypes;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.Heretic.Ritual;
+
+public sealed partial class RitualAshAscendBehavior : RitualSacrificeBehavior
+{
+    private List<EntityUid> burningUids = new();
+
+    // check for burning corpses
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        if (!base.Execute(args, out outstr))
+            return false;
+
+        for (int i = 0; i < Max; i++)
+        {
+            if (args.EntityManager.TryGetComponent<FlammableComponent>(uids[i], out var flam))
+                if (flam.OnFire)
+                    burningUids.Add(uids[i]);
+        }
+
+        if (burningUids.Count < Min)
+        {
+            outstr = Loc.GetString("heretic-ritual-fail-sacrifice-ash");
+            return false;
+        }
+
+        outstr = null;
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        for (int i = 0; i < Max; i++)
+        {
+            // YES!!! ASH!!!
+            if (args.EntityManager.TryGetComponent<DamageableComponent>(uids[i], out var dmg))
+            {
+                var prot = (ProtoId<DamageGroupPrototype>) "Burn";
+                var dmgtype = _proto.Index(prot);
+                _damage.TryChangeDamage(uids[i], new DamageSpecifier(dmgtype, 3984f), true);
+            }
+        }
+
+        // reset it because blehhh
+        uids = new();
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Knowledge.cs b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Knowledge.cs
new file mode 100644
index 0000000000000..6c0797a359c5a
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Knowledge.cs
@@ -0,0 +1,100 @@
+using Content.Server.Heretic.EntitySystems;
+using Content.Shared.Dataset;
+using Content.Shared.Heretic;
+using Content.Shared.Heretic.Prototypes;
+using Content.Shared.Tag;
+using Robust.Shared.Containers;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using System.Text;
+
+namespace Content.Server.Heretic.Ritual;
+
+public sealed partial class RitualKnowledgeBehavior : RitualCustomBehavior
+{
+    // made static so that it doesn't regenerate itself each time
+    private static Dictionary<ProtoId<TagPrototype>, int> requiredTags = new();
+    private List<EntityUid> toDelete = new();
+
+    private IPrototypeManager _prot = default!;
+    private IRobustRandom _rand = default!;
+    private EntityLookupSystem _lookup = default!;
+    private HereticSystem _heretic = default!;
+    private SharedContainerSystem _container = default!;
+
+
+    [ValidatePrototypeId<DatasetPrototype>]
+    public const string EligibleTagsDataset = "EligibleTags";
+
+    // this is basically a ripoff from hereticritualsystem
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        _prot = IoCManager.Resolve<IPrototypeManager>();
+        _rand = IoCManager.Resolve<IRobustRandom>();
+        _lookup = args.EntityManager.System<EntityLookupSystem>();
+        _heretic = args.EntityManager.System<HereticSystem>();
+
+
+        outstr = null;
+
+        // generate new set of tags
+        if (requiredTags.Count == 0)
+            for (int i = 0; i < 4; i++)
+                requiredTags.Add(_rand.Pick(_prot.Index<DatasetPrototype>(EligibleTagsDataset).Values), 1);
+
+        var lookup = _lookup.GetEntitiesInRange(args.Platform, .75f);
+        var missingList = new List<string>();
+
+        foreach (var look in lookup)
+        {
+            foreach (var tag in requiredTags)
+            {
+                //WHY DID THEY JUST COPY-PASTE THE NORMAL RITUAL CODE. JUST USE THE NORMAL RITUAL CODE I AM BEGGING
+                if (!args.EntityManager.TryGetComponent<TagComponent>(look, out var tags)
+                    || _container.IsEntityInContainer(look))
+                    continue;
+                var ltags = tags.Tags;
+
+                if (ltags.Contains(tag.Key))
+                {
+                    requiredTags[tag.Key] -= 1;
+                    toDelete.Add(look);
+                }
+            }
+        }
+
+        foreach (var tag in requiredTags)
+            if (tag.Value > 0)
+                missingList.Add(tag.Key);
+
+        if (missingList.Count > 0)
+        {
+            var sb = new StringBuilder();
+            for (int i = 0; i < missingList.Count; i++)
+            {
+                if (i != missingList.Count - 1)
+                    sb.Append($"{missingList[i]}, ");
+                else sb.Append(missingList[i]);
+            }
+
+            outstr = Loc.GetString("heretic-ritual-fail-items", ("itemlist", sb.ToString()));
+            return false;
+        }
+
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        // delete all and reset
+        foreach (var ent in toDelete)
+            args.EntityManager.QueueDeleteEntity(ent);
+        toDelete = new();
+
+        if (args.EntityManager.TryGetComponent<HereticComponent>(args.Performer, out var hereticComp))
+            _heretic.UpdateKnowledge(args.Performer, hereticComp, 4);
+
+        // reset tags
+        requiredTags = new();
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.MuteGhoulify.cs b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.MuteGhoulify.cs
new file mode 100644
index 0000000000000..957cc6f276b77
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.MuteGhoulify.cs
@@ -0,0 +1,26 @@
+using Content.Shared.Heretic;
+using Content.Shared.Heretic.Prototypes;
+using Content.Shared.Speech.Muting;
+
+namespace Content.Server.Heretic.Ritual;
+
+public sealed partial class RitualMuteGhoulifyBehavior : RitualSacrificeBehavior
+{
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        return base.Execute(args, out outstr);
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        foreach (var uid in uids)
+        {
+            var ghoul = new GhoulComponent()
+            {
+                TotalHealth = 125f,
+            };
+            args.EntityManager.AddComponent(uid, ghoul, overwrite: true);
+            args.EntityManager.EnsureComponent<MutedComponent>(uid);
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.ReagentPuddle.cs b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.ReagentPuddle.cs
new file mode 100644
index 0000000000000..d85a2ca3e54ba
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.ReagentPuddle.cs
@@ -0,0 +1,74 @@
+using Content.Shared.Chemistry.Components.SolutionManager;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Fluids.Components;
+using Content.Shared.Heretic.Prototypes;
+using Robust.Shared.Prototypes;
+using System.Linq;
+
+namespace Content.Server.Heretic.Ritual;
+
+public sealed partial class RitualReagentPuddleBehavior : RitualCustomBehavior
+{
+    protected EntityLookupSystem _lookup = default!;
+
+    [DataField] public List<ProtoId<ReagentPrototype>>? Reagents;
+
+    private List<EntityUid> uids = new();
+
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        if (Reagents == null)
+        {
+            //should only happen if someone fucked up their ritual yaml
+            outstr = Loc.GetString("heretic-ritual-unknown");
+            return false;
+        }
+        string reagStrings = "";
+
+        foreach(var Reagent in Reagents)
+        {
+            reagStrings += (Reagent.Id + ", ");
+
+            outstr = null;
+            _lookup = args.EntityManager.System<EntityLookupSystem>();
+
+            var lookup = _lookup.GetEntitiesInRange(args.Platform, .75f);
+
+            foreach (var ent in lookup)
+            {
+                if (!args.EntityManager.TryGetComponent<PuddleComponent>(ent, out var puddle))
+                    continue;
+
+                if (puddle.Solution == null)
+                    continue;
+
+                var soln = puddle.Solution.Value;
+
+                if (!soln.Comp.Solution.ContainsPrototype(Reagent))
+                    continue;
+
+                uids.Add(ent);
+            }
+
+            if (uids.Count == 0)
+            {
+                continue;
+            }
+
+            return true;
+        }
+
+        //take off the comma + space on the end of the reagStrings
+        reagStrings = reagStrings.Substring(0, reagStrings.Length - 2);
+        outstr = Loc.GetString("heretic-ritual-fail-reagentpuddle", ("reagentname", reagStrings));
+        return false;
+
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        foreach (var uid in uids)
+            args.EntityManager.QueueDeleteEntity(uid);
+        uids = new();
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Sacrifice.cs b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Sacrifice.cs
new file mode 100644
index 0000000000000..7bbb79931f135
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Sacrifice.cs
@@ -0,0 +1,214 @@
+using Content.Shared.Heretic.Prototypes;
+using Content.Shared.Mobs.Components;
+using Robust.Shared.Prototypes;
+using Content.Shared.Humanoid;
+using Content.Server.Revolutionary.Components;
+using Content.Server.Objectives.Components;
+using Content.Shared.Mind;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.Heretic;
+using Content.Server.Heretic.EntitySystems;
+using Content.Server.Humanoid;
+using Content.Shared.Forensics.Components;
+using Robust.Shared.Toolshed.TypeParsers;
+using Robust.Server.GameObjects;
+using System;
+using System.Linq;
+using Content.Server._Goobstation.Heretic.EntitySystems;
+using Content.Server.Heretic.Components;
+using Content.Server.Forensics;
+using Content.Server.Body.Systems;
+using Content.Server.Body.Components;
+using Content.Shared.Forensics;
+using Content.Shared.Chemistry.Reagent;
+using Robust.Shared.GameObjects;
+using Content.Shared.Chemistry.EntitySystems;
+
+
+
+namespace Content.Server.Heretic.Ritual;
+
+/// <summary>
+///     Checks for a nearest dead body,
+///     gibs it and gives the heretic knowledge points.
+/// </summary>
+// these classes should be lead out and shot
+[Virtual] public partial class RitualSacrificeBehavior : RitualCustomBehavior
+{
+    /// <summary>
+    ///     Minimal amount of corpses.
+    /// </summary>
+    [DataField] public float Min = 1;
+
+    /// <summary>
+    ///     Maximum amount of corpses.
+    /// </summary>
+    [DataField] public float Max = 1;
+
+    /// <summary>
+    ///     Should we count only targets?
+    /// </summary>
+    [DataField] public bool OnlyTargets = false;
+
+    // this is awful but it works so i'm not complaining
+    // i'm complaining -kandiyaki
+    protected SharedMindSystem _mind = default!;
+    protected HereticSystem _heretic = default!;
+    protected SharedTransformSystem _xform = default!;
+    protected DamageableSystem _damage = default!;
+    protected EntityLookupSystem _lookup = default!;
+    protected HumanoidAppearanceSystem _humanoid = default!;
+    protected TransformSystem _transformSystem = default!;
+    protected HellWorldSystem _hellworld = default!;
+    protected BloodstreamSystem _bloodstream = default!;
+    protected SharedSolutionContainerSystem _solutionContainerSystem = default!;
+
+
+    [Dependency] protected IPrototypeManager _proto = default!;
+    [Dependency] protected IEntityManager _entmanager = default!;
+
+
+    protected List<EntityUid> uids = new();
+
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        //it was like this when i got here -kandiyaki
+        _mind = args.EntityManager.System<SharedMindSystem>();
+        _heretic = args.EntityManager.System<HereticSystem>();
+        _xform = args.EntityManager.System<SharedTransformSystem>();
+        _damage = args.EntityManager.System<DamageableSystem>();
+        _lookup = args.EntityManager.System<EntityLookupSystem>();
+        _humanoid = args.EntityManager.System<HumanoidAppearanceSystem>();
+        _transformSystem = args.EntityManager.System<TransformSystem>();
+        _hellworld = args.EntityManager.System<HellWorldSystem>();
+        _bloodstream = args.EntityManager.System<BloodstreamSystem>();
+        _solutionContainerSystem = args.EntityManager.System<SharedSolutionContainerSystem>();
+
+        _proto = IoCManager.Resolve<IPrototypeManager>();
+        _entmanager = IoCManager.Resolve<IEntityManager>();
+
+
+        if (!args.EntityManager.TryGetComponent<HereticComponent>(args.Performer, out var hereticComp))
+        {
+            outstr = string.Empty;
+            return false;
+        }
+
+        var lookup = _lookup.GetEntitiesInRange(args.Platform, .75f);
+        if (lookup.Count == 0 || lookup == null)
+        {
+            outstr = Loc.GetString("heretic-ritual-fail-sacrifice");
+            return false;
+        }
+
+        // get all the dead ones
+        foreach (var look in lookup)
+        {
+            if (!args.EntityManager.TryGetComponent<MobStateComponent>(look, out var mobstate) // only mobs
+            || !args.EntityManager.HasComponent<HumanoidAppearanceComponent>(look)) // only humans
+                continue;
+
+            if (mobstate.CurrentState == Shared.Mobs.MobState.Dead)
+                uids.Add(look);
+        }
+
+        if (uids.Count < Min)
+        {
+            outstr = Loc.GetString("heretic-ritual-fail-sacrifice-ineligible");
+            return false;
+        }
+
+        outstr = null;
+        return true;
+    }
+
+    //this does way too much
+    public override void Finalize(RitualData args)
+    {
+
+        for (int i = 0; i < Max; i++)
+        {
+            var isCommand = args.EntityManager.HasComponent<CommandStaffComponent>(uids[i]);
+            var knowledgeGain = isCommand ? 2f : 1f;
+
+            //get the humanoid appearance component
+            if (!args.EntityManager.TryGetComponent<HumanoidAppearanceComponent>(uids[i], out var humanoid))
+                return;
+
+            //get the species prototype from that
+            if (!_proto.TryIndex(humanoid.Species, out var speciesPrototype))
+                return;
+
+            //spawn a clone of the victim
+            //this should really use the cloningsystem but i coded this before that existed
+            //and it works so i'm not changing it unless it causes issues
+            var sacrificialWhiteBoy = args.EntityManager.Spawn(speciesPrototype.Prototype, _transformSystem.GetMapCoordinates(uids[i]));
+            _humanoid.CloneAppearance(uids[i], sacrificialWhiteBoy);
+            //make sure it has the right DNA
+            if (args.EntityManager.TryGetComponent<DnaComponent>(uids[i], out var victimDna))
+            {
+                if (args.EntityManager.TryGetComponent<BloodstreamComponent>(sacrificialWhiteBoy, out var dummyBlood))
+                {
+                    //this is copied from BloodstreamSystem's OnDnaGenerated
+                    //i hate it
+                    if(_solutionContainerSystem.ResolveSolution(sacrificialWhiteBoy, dummyBlood.BloodSolutionName, ref dummyBlood.BloodSolution, out var bloodSolution))
+                    {
+                        foreach (var reagent in bloodSolution.Contents)
+                        {
+                            List<ReagentData> reagentData = reagent.Reagent.EnsureReagentData();
+                            reagentData.RemoveAll(x => x is DnaData);
+                            reagentData.AddRange(_bloodstream.GetEntityBloodData(uids[i]));
+                        }
+                    }
+                }
+            }
+            //beat the clone to death. this is just to get matching organs
+            if (args.EntityManager.TryGetComponent<DamageableComponent>(uids[i], out var dmg))
+            {
+                var prot = (ProtoId<DamageGroupPrototype>) "Brute";
+                var dmgtype = _proto.Index(prot);
+                _damage.TryChangeDamage(sacrificialWhiteBoy, new DamageSpecifier(dmgtype, 1984f), true);
+            }
+
+            //send the target to hell world
+            _hellworld.AddVictimComponent(uids[i]);
+
+            //teleport the body to a midround antag spawn spot so it's not just tossed into space
+            _hellworld.TeleportRandomly(args, uids[i]);
+
+            //make sure that my shitty AddVictimComponent thing actually worked before trying to use a mind that isn't there
+            if (args.EntityManager.TryGetComponent<HellVictimComponent>(uids[i], out var hellVictim))
+            {
+                //i'm so sorry to all of my computer science professors. i've failed you
+                if(hellVictim.HasMind)
+                {
+                    _hellworld.SendToHell(uids[i], args, speciesPrototype);
+                }
+
+            }
+
+            //update the heretic's knowledge
+            if (args.EntityManager.TryGetComponent<HereticComponent>(args.Performer, out var hereticComp))
+                _heretic.UpdateKnowledge(args.Performer, hereticComp, knowledgeGain);
+
+            // update objectives
+            if (_mind.TryGetMind(args.Performer, out var mindId, out var mind))
+            {
+                // this is godawful dogshit. but it works :)
+                if (_mind.TryFindObjective((mindId, mind), "HereticSacrificeObjective", out var crewObj)
+                && args.EntityManager.TryGetComponent<HereticSacrificeConditionComponent>(crewObj, out var crewObjComp))
+                    crewObjComp.Sacrificed += 1;
+
+                if (_mind.TryFindObjective((mindId, mind), "HereticSacrificeHeadObjective", out var crewHeadObj)
+                && args.EntityManager.TryGetComponent<HereticSacrificeConditionComponent>(crewHeadObj, out var crewHeadObjComp)
+                && isCommand)
+                    crewHeadObjComp.Sacrificed += 1;
+            }
+        }
+
+        // reset it because it refuses to work otherwise.
+        uids = new();
+        args.EntityManager.EventBus.RaiseLocalEvent(args.Performer, new EventHereticUpdateTargets());
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Temperature.cs b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Temperature.cs
new file mode 100644
index 0000000000000..6de59c8e1cff9
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/Ritual/CustomBehavior.Temperature.cs
@@ -0,0 +1,50 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Shared.Atmos;
+using Content.Shared.Heretic.Prototypes;
+
+namespace Content.Server.Heretic.Ritual;
+
+[Virtual] public sealed partial class RitualTemperatureBehavior : RitualCustomBehavior
+{
+    /// <summary>
+    ///     Min temp in celsius
+    /// </summary>
+    [DataField] public float MinThreshold = 0f;
+
+    /// <summary>
+    ///     Max temp in celsius
+    /// </summary>
+    [DataField] public float MaxThreshold = float.PositiveInfinity;
+
+    private AtmosphereSystem _atmos = default!;
+
+    public override bool Execute(RitualData args, out string? outstr)
+    {
+        outstr = null;
+
+        _atmos = args.EntityManager.System<AtmosphereSystem>();
+
+        var mix = _atmos.GetTileMixture(args.Platform);
+
+        if (mix == null || mix.TotalMoles == 0) // just accept space as it is
+            return true;
+
+        if (mix.Temperature > Atmospherics.T0C + MaxThreshold)
+        {
+            outstr = Loc.GetString("heretic-ritual-fail-temperature-hot");
+            return false;
+        }
+        if (mix.Temperature > Atmospherics.T0C + MinThreshold)
+        {
+            outstr = Loc.GetString("heretic-ritual-fail-temperature-cold");
+            return false;
+        }
+
+        return true;
+    }
+
+    public override void Finalize(RitualData args)
+    {
+        // do nothing
+    }
+}
diff --git a/Content.Server/_Goobstation/Heretic/UI/HellMemoryEui.cs b/Content.Server/_Goobstation/Heretic/UI/HellMemoryEui.cs
new file mode 100644
index 0000000000000..c543303a19b4e
--- /dev/null
+++ b/Content.Server/_Goobstation/Heretic/UI/HellMemoryEui.cs
@@ -0,0 +1,8 @@
+using Content.Server.EUI;
+
+namespace Content.Server._Goobstation.Heretic.UI;
+
+public sealed class HellMemoryEui : BaseEui
+{
+    // serverside does nothing!
+}
diff --git a/Content.Server/_Goobstation/Magic/ChainFireballComponent.cs b/Content.Server/_Goobstation/Magic/ChainFireballComponent.cs
new file mode 100644
index 0000000000000..a629f7170f625
--- /dev/null
+++ b/Content.Server/_Goobstation/Magic/ChainFireballComponent.cs
@@ -0,0 +1,12 @@
+namespace Content.Server.Magic;
+
+[RegisterComponent]
+public sealed partial class ChainFireballComponent : Component
+{
+    /// <summary>
+    ///     The chance of the ball disappearing (in %)
+    /// </summary>
+    [DataField] public float DisappearChance = 0.05f;
+
+    public List<EntityUid> IgnoredTargets = new();
+}
diff --git a/Content.Server/_Goobstation/Magic/ChainFireballSystem.cs b/Content.Server/_Goobstation/Magic/ChainFireballSystem.cs
new file mode 100644
index 0000000000000..5909b28a94ef8
--- /dev/null
+++ b/Content.Server/_Goobstation/Magic/ChainFireballSystem.cs
@@ -0,0 +1,91 @@
+using Content.Server.Popups;
+using Content.Shared.Projectiles;
+using Content.Shared.StatusEffect;
+using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Server.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Random;
+
+namespace Content.Server.Magic;
+
+public sealed partial class ChainFireballSystem : EntitySystem
+{
+    [Dependency] private readonly SharedGunSystem _gun = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly PhysicsSystem _physics = default!;
+    [Dependency] private readonly IMapManager _mapMan = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ChainFireballComponent, ProjectileHitEvent>(OnHit);
+    }
+
+    private void OnHit(Entity<ChainFireballComponent> ent, ref ProjectileHitEvent args)
+    {
+        if (_random.Prob(ent.Comp.DisappearChance))
+            return;
+
+        // spawn new fireball on target
+        Spawn(args.Target, ent.Comp.IgnoredTargets);
+
+        QueueDel(ent);
+    }
+
+    public bool Spawn(EntityUid source, List<EntityUid> ignoredTargets)
+    {
+        var lookup = _lookup.GetEntitiesInRange(source, 5f);
+
+        List<EntityUid> mobs = new();
+        foreach (var look in lookup)
+        {
+            if (ignoredTargets.Contains(look)
+            || !HasComp<StatusEffectsComponent>(look)) // ignore non mobs
+                continue;
+
+            mobs.Add(look);
+        }
+        if (mobs.Count == 0)
+        {
+            _popup.PopupEntity(Loc.GetString("heretic-ability-fail-notarget"), source, source);
+            return false;
+        }
+
+        return Spawn(source, mobs[_random.Next(0, mobs.Count - 1)], ignoredTargets);
+    }
+    public bool Spawn(EntityUid source, EntityUid target, List<EntityUid> ignoredTargets)
+    {
+        return SpawnFireball(source, target, ignoredTargets);
+    }
+    public bool SpawnFireball(EntityUid uid, EntityUid target, List<EntityUid> ignoredTargets)
+    {
+        var ball = Spawn("FireballChain", Transform(uid).Coordinates);
+
+        // set ignore list if it wasn't set already
+        if (TryComp<ChainFireballComponent>(ball, out var sfc))
+            sfc.IgnoredTargets = sfc.IgnoredTargets.Count > 0 ? sfc.IgnoredTargets : ignoredTargets;
+
+        // launch it towards the target
+        var fromCoords = Transform(uid).Coordinates;
+        var toCoords = Transform(target).Coordinates;
+        var userVelocity = _physics.GetMapLinearVelocity(uid);
+
+        // If applicable, this ensures the projectile is parented to grid on spawn, instead of the map.
+        var fromMap = fromCoords.ToMap(EntityManager, _transform);
+        var spawnCoords = _mapMan.TryFindGridAt(fromMap, out var gridUid, out _)
+            ? fromCoords.WithEntityId(gridUid, EntityManager)
+            : new(_mapMan.GetMapEntityId(fromMap.MapId), fromMap.Position);
+
+
+        var direction = toCoords.ToMapPos(EntityManager, _transform) -
+                        spawnCoords.ToMapPos(EntityManager, _transform);
+
+        _gun.ShootProjectile(ball, direction, userVelocity, uid, uid);
+
+        return true;
+    }
+}
diff --git a/Content.Server/_Goobstation/Magic/ImmovableVoidRodComponent.cs b/Content.Server/_Goobstation/Magic/ImmovableVoidRodComponent.cs
new file mode 100644
index 0000000000000..c77fa7b84d97f
--- /dev/null
+++ b/Content.Server/_Goobstation/Magic/ImmovableVoidRodComponent.cs
@@ -0,0 +1,10 @@
+using Robust.Shared.Audio;
+
+namespace Content.Server.Magic;
+
+[RegisterComponent]
+public sealed partial class ImmovableVoidRodComponent : Component
+{
+    [DataField] public TimeSpan Lifetime = TimeSpan.FromSeconds(1f);
+    public float Accumulator = 0f;
+}
diff --git a/Content.Server/_Goobstation/Magic/ImmovableVoidRodSystem.cs b/Content.Server/_Goobstation/Magic/ImmovableVoidRodSystem.cs
new file mode 100644
index 0000000000000..fc3257446b188
--- /dev/null
+++ b/Content.Server/_Goobstation/Magic/ImmovableVoidRodSystem.cs
@@ -0,0 +1,70 @@
+using Content.Server.Heretic.Components;
+using Content.Shared.Heretic;
+using Content.Shared.Maps;
+using Content.Shared.Stunnable;
+using Content.Shared.Tag;
+using Robust.Shared.Map;
+using Robust.Shared.Physics.Events;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Map.Components;
+
+namespace Content.Server.Magic;
+
+public sealed partial class ImmovableVoidRodSystem : EntitySystem
+{
+    [Dependency] private readonly IPrototypeManager _prot = default!;
+    [Dependency] private readonly IMapManager _map = default!;
+    [Dependency] private readonly TileSystem _tile = default!;
+    [Dependency] private readonly SharedStunSystem _stun = default!;
+    [Dependency] private readonly IEntityManager _ent = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        // we are deliberately including paused entities. rod hungers for all
+        foreach (var (rod, trans) in EntityManager.EntityQuery<ImmovableVoidRodComponent, TransformComponent>(true))
+        {
+            rod.Accumulator += frameTime;
+
+            if (rod.Accumulator > rod.Lifetime.TotalSeconds)
+            {
+                QueueDel(rod.Owner);
+                return;
+            }
+
+            if (!_ent.TryGetComponent<MapGridComponent>(trans.GridUid, out var grid))
+                continue;
+
+
+
+            var tileref = grid.GetTileRef(trans.Coordinates);
+            var tile = _prot.Index<ContentTileDefinition>("FloorAstroSnow");
+            _tile.ReplaceTile(tileref, tile);
+        }
+    }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<ImmovableVoidRodComponent, StartCollideEvent>(OnCollide);
+    }
+
+    private void OnCollide(Entity<ImmovableVoidRodComponent> ent, ref StartCollideEvent args)
+    {
+        if ((TryComp<HereticComponent>(args.OtherEntity, out var th) && th.CurrentPath == "Void")
+        || HasComp<GhoulComponent>(args.OtherEntity))
+            return;
+
+        _stun.TryParalyze(args.OtherEntity, TimeSpan.FromSeconds(2.5f), false);
+
+        TryComp<TagComponent>(args.OtherEntity, out var tag);
+        var tags = tag?.Tags ?? new();
+
+        if (tags.Contains("Wall") && Prototype(args.OtherEntity) != null && Prototype(args.OtherEntity)!.ID != "WallSnowCobblebrick")
+        {
+            Spawn("WallSnowCobblebrick", Transform(args.OtherEntity).Coordinates);
+            QueueDel(args.OtherEntity);
+        }
+    }
+}
diff --git a/Content.Server/_Goobstation/Objectives/Components/HereticKnowledgeConditionComponent.cs b/Content.Server/_Goobstation/Objectives/Components/HereticKnowledgeConditionComponent.cs
new file mode 100644
index 0000000000000..3904ecbbb6e15
--- /dev/null
+++ b/Content.Server/_Goobstation/Objectives/Components/HereticKnowledgeConditionComponent.cs
@@ -0,0 +1,10 @@
+using Content.Server.Heretic;
+using Content.Server.Objectives.Systems;
+
+namespace Content.Server.Objectives.Components;
+
+[RegisterComponent]
+public sealed partial class HereticKnowledgeConditionComponent : Component
+{
+    [DataField] public float Researched = 0f;
+}
diff --git a/Content.Server/_Goobstation/Objectives/Components/HereticSacrificeConditionComponent.cs b/Content.Server/_Goobstation/Objectives/Components/HereticSacrificeConditionComponent.cs
new file mode 100644
index 0000000000000..303ad69a52fce
--- /dev/null
+++ b/Content.Server/_Goobstation/Objectives/Components/HereticSacrificeConditionComponent.cs
@@ -0,0 +1,14 @@
+using Content.Server.Heretic;
+using Content.Server.Objectives.Systems;
+
+namespace Content.Server.Objectives.Components;
+
+[RegisterComponent]
+public sealed partial class HereticSacrificeConditionComponent : Component
+{
+    [DataField] public float Sacrificed = 0f;
+    /// <summary>
+    ///     Indicates that a victim should be a head role / command.
+    /// </summary>
+    [DataField] public bool IsCommand = false;
+}
diff --git a/Content.Server/_Goobstation/Objectives/Components/RandomTraitorTargetComponent.cs b/Content.Server/_Goobstation/Objectives/Components/RandomTraitorTargetComponent.cs
new file mode 100644
index 0000000000000..e544e752cee2d
--- /dev/null
+++ b/Content.Server/_Goobstation/Objectives/Components/RandomTraitorTargetComponent.cs
@@ -0,0 +1,12 @@
+using Content.Server.Objectives.Components;
+
+namespace Content.Server._Goobstation.Objectives.Components;
+
+/// <summary>
+/// Sets the target for <see cref="KeepAliveConditionComponent"/>
+/// to protect a player that is targeted to kill by another traitor
+/// </summary>
+[RegisterComponent]
+public sealed partial class RandomTraitorTargetComponent : Component
+{
+}
diff --git a/Content.Server/_Goobstation/Objectives/Systems/HereticObjectiveSystem.cs b/Content.Server/_Goobstation/Objectives/Systems/HereticObjectiveSystem.cs
new file mode 100644
index 0000000000000..d71aeef2612a0
--- /dev/null
+++ b/Content.Server/_Goobstation/Objectives/Systems/HereticObjectiveSystem.cs
@@ -0,0 +1,33 @@
+using Content.Server._Goobstation.Objectives.Components;
+using Content.Server.Objectives.Components;
+using Content.Shared.Objectives.Components;
+
+namespace Content.Server.Objectives.Systems;
+
+public sealed partial class HereticObjectiveSystem : EntitySystem
+{
+    [Dependency] private readonly NumberObjectiveSystem _number = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HereticKnowledgeConditionComponent, ObjectiveGetProgressEvent>(OnGetKnowledgeProgress);
+        SubscribeLocalEvent<HereticSacrificeConditionComponent, ObjectiveGetProgressEvent>(OnGetSacrificeProgress);
+    }
+
+    private void OnGetKnowledgeProgress(Entity<HereticKnowledgeConditionComponent> ent, ref ObjectiveGetProgressEvent args)
+    {
+        var target = _number.GetTarget(ent);
+        if (target != 0)
+            args.Progress = MathF.Min(ent.Comp.Researched / target, 1f);
+        else args.Progress = 1f;
+    }
+    private void OnGetSacrificeProgress(Entity<HereticSacrificeConditionComponent> ent, ref ObjectiveGetProgressEvent args)
+    {
+        var target = _number.GetTarget(ent);
+        if (target != 0)
+            args.Progress = MathF.Min(ent.Comp.Sacrificed / target, 1f);
+        else args.Progress = 1f;
+    }
+}
diff --git a/Content.Server/_Goobstation/Roles/GhoulRoleComponent.cs b/Content.Server/_Goobstation/Roles/GhoulRoleComponent.cs
new file mode 100644
index 0000000000000..e10b211d49c11
--- /dev/null
+++ b/Content.Server/_Goobstation/Roles/GhoulRoleComponent.cs
@@ -0,0 +1,8 @@
+using Content.Shared.Roles;
+
+namespace Content.Server.Roles;
+
+[RegisterComponent]
+public sealed partial class GhoulRoleComponent : BaseMindRoleComponent
+{
+}
diff --git a/Content.Server/_Goobstation/Roles/HereticRoleComponent.cs b/Content.Server/_Goobstation/Roles/HereticRoleComponent.cs
new file mode 100644
index 0000000000000..1215d0a69457c
--- /dev/null
+++ b/Content.Server/_Goobstation/Roles/HereticRoleComponent.cs
@@ -0,0 +1,8 @@
+using Content.Shared.Roles;
+
+namespace Content.Server.Roles;
+
+[RegisterComponent]
+public sealed partial class HereticRoleComponent : BaseMindRoleComponent
+{
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Components/BlazingDashComponent.cs b/Content.Shared/_Goobstation/Heretic/Components/BlazingDashComponent.cs
new file mode 100644
index 0000000000000..365d6c56bd103
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/BlazingDashComponent.cs
@@ -0,0 +1,24 @@
+using Robust.Shared.Audio;
+
+namespace Content.Shared.Heretic.Components;
+
+[RegisterComponent, AutoGenerateComponentPause, AutoGenerateComponentState]
+public sealed partial class BlazingDashComponent : Component
+{
+    /// <summary>
+    ///     Indicates whether the heretic is using blazing dash.
+    /// </summary>
+    [DataField, AutoNetworkedField] public bool BlazingDashActive;
+
+    /// <summary>
+    ///     Indicates when blazing dash should end.
+    /// </summary>
+    [ViewVariables, AutoPausedField] public TimeSpan BlazingDashEndTime;
+
+    public TimeSpan BlazingDashDuration = TimeSpan.FromSeconds(5);
+    public SoundSpecifier DashSound = new SoundPathSpecifier("/Audio/Magic/fireball.ogg");
+    public int DashFireStacks = 4;
+    public float DashWalkSpeed = 1.5f;
+    public float DashRunSpeed = 2f;
+}
+
diff --git a/Content.Shared/_Goobstation/Heretic/Components/GhoulComponent.cs b/Content.Shared/_Goobstation/Heretic/Components/GhoulComponent.cs
new file mode 100644
index 0000000000000..1983575faecb5
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/GhoulComponent.cs
@@ -0,0 +1,23 @@
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameStates;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Shared.Heretic;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class GhoulComponent : Component
+{
+    /// <summary>
+    ///     Indicates who ghouled the entity.
+    /// </summary>
+    [DataField] public EntityUid? BoundHeretic = null;
+
+    /// <summary>
+    ///     Total health for ghouls.
+    /// </summary>
+    [DataField] public FixedPoint2 TotalHealth = 50;
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Components/HereticCombatMarkComponent.cs b/Content.Shared/_Goobstation/Heretic/Components/HereticCombatMarkComponent.cs
new file mode 100644
index 0000000000000..f0cd8ec55eb99
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/HereticCombatMarkComponent.cs
@@ -0,0 +1,14 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Heretic;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class HereticCombatMarkComponent : Component
+{
+    [DataField, AutoNetworkedField] public string Path = "Blade";
+
+    [DataField] public float DisappearTime = 5f;
+    public TimeSpan Timer = TimeSpan.Zero;
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Components/HereticComponent.cs b/Content.Shared/_Goobstation/Heretic/Components/HereticComponent.cs
new file mode 100644
index 0000000000000..017db1f018a0b
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/HereticComponent.cs
@@ -0,0 +1,49 @@
+using Content.Shared.Heretic.Prototypes;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Heretic;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
+public sealed partial class HereticComponent : Component
+{
+    #region Prototypes
+
+    [DataField] public List<ProtoId<HereticKnowledgePrototype>> BaseKnowledge = new()
+    {
+        "BreakOfDawn",
+        "HeartbeatOfMansus",
+        "AmberFocus",
+        "CodexCicatrix",
+    };
+
+    #endregion
+
+    [DataField, AutoNetworkedField] public List<ProtoId<HereticRitualPrototype>> KnownRituals = new();
+    [DataField] public ProtoId<HereticRitualPrototype>? ChosenRitual;
+
+    // hardcoded paths because i hate it
+    // "Ash", "Lock", "Flesh", "Void", "Blade", "Rust"
+    /// <summary>
+    ///     Indicates a path the heretic is on.
+    /// </summary>
+    [DataField, AutoNetworkedField] public string? CurrentPath = null;
+
+    /// <summary>
+    ///     Indicates a stage of a path the heretic is on. 0 is no path, 10 is ascension
+    /// </summary>
+    [DataField, AutoNetworkedField] public int PathStage = 0;
+
+    [DataField, AutoNetworkedField] public bool Ascended = false;
+
+    /// <summary>
+    ///     Used to prevent double casting mansus grasp.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadOnly)] public bool MansusGraspActive = false;
+
+    /// <summary>
+    ///     Indicates if a heretic is able to cast advanced spells.
+    ///     Requires wearing focus, codex cicatrix, hood or anything else that allows him to do so.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)] public bool CanCastSpells = false;
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Components/HereticMagicItemComponent.cs b/Content.Shared/_Goobstation/Heretic/Components/HereticMagicItemComponent.cs
new file mode 100644
index 0000000000000..2202af9203fdd
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/HereticMagicItemComponent.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Heretic;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class HereticMagicItemComponent : Component
+{
+
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Components/HereticRitualEvents.cs b/Content.Shared/_Goobstation/Heretic/Components/HereticRitualEvents.cs
new file mode 100644
index 0000000000000..21db97bb2a41e
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/HereticRitualEvents.cs
@@ -0,0 +1,22 @@
+using Content.Shared.Heretic.Prototypes;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Goobstation.Heretic.Components;
+
+[Serializable, NetSerializable]
+public sealed class HereticRitualMessage : BoundUserInterfaceMessage
+{
+    public ProtoId<HereticRitualPrototype> ProtoId;
+
+    public HereticRitualMessage(ProtoId<HereticRitualPrototype> protoId)
+    {
+        ProtoId = protoId;
+    }
+}
+
+[Serializable, NetSerializable]
+public enum HereticRitualRuneUiKey : byte
+{
+    Key
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Components/HereticRitualRuneComponent.cs b/Content.Shared/_Goobstation/Heretic/Components/HereticRitualRuneComponent.cs
new file mode 100644
index 0000000000000..7fe93de81a0c7
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Components/HereticRitualRuneComponent.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Heretic;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class HereticRitualRuneComponent : Component
+{
+
+}
diff --git a/Content.Shared/_Goobstation/Heretic/EntitySystems/SharedGhoulSystem.cs b/Content.Shared/_Goobstation/Heretic/EntitySystems/SharedGhoulSystem.cs
new file mode 100644
index 0000000000000..d2323bd8565d3
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/EntitySystems/SharedGhoulSystem.cs
@@ -0,0 +1,12 @@
+using Content.Shared.Heretic;
+
+
+namespace Content.Shared.Heretic.EntitySystems;
+
+public abstract class SharedGhoulSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+    }
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Heretic.Abilites.cs b/Content.Shared/_Goobstation/Heretic/Heretic.Abilites.cs
new file mode 100644
index 0000000000000..1dcd4a48b20fc
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Heretic.Abilites.cs
@@ -0,0 +1,98 @@
+using Content.Shared.Actions;
+using Content.Shared.DoAfter;
+using Content.Shared.Inventory;
+using Robust.Shared.GameStates;
+using Robust.Shared.Map;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Heretic;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class HereticActionComponent : Component
+{
+    /// <summary>
+    ///     Indicates that a user should wear a heretic amulet, a hood or something else.
+    /// </summary>
+    [DataField] public bool RequireMagicItem = true;
+
+    [DataField] public string? MessageLoc = null;
+}
+
+#region DoAfters
+
+[Serializable, NetSerializable] public sealed partial class EldritchInfluenceDoAfterEvent : SimpleDoAfterEvent
+{
+    public bool MagicItemActive = false;
+}
+
+[Serializable, NetSerializable] public sealed partial class HereticKnowledgeItemDoAfterEvent : SimpleDoAfterEvent;
+
+[Serializable, NetSerializable] public sealed partial class DrawRitualRuneDoAfterEvent : SimpleDoAfterEvent
+{
+    [NonSerialized] public EntityCoordinates Coords;
+    [NonSerialized] public EntityUid RitualRune;
+
+    public DrawRitualRuneDoAfterEvent(EntityUid ritualRune, EntityCoordinates coords)
+    {
+        RitualRune = ritualRune;
+        Coords = coords;
+    }
+}
+[Serializable, NetSerializable] public sealed partial class HereticMansusLinkDoAfter : SimpleDoAfterEvent
+{
+    [NonSerialized] public EntityUid Target;
+
+    public HereticMansusLinkDoAfter(EntityUid target)
+    {
+        Target = target;
+    }
+}
+[Serializable, NetSerializable] public sealed partial class EventHereticFleshSurgeryDoAfter : SimpleDoAfterEvent
+{
+    [NonSerialized] public EntityUid? Target;
+
+    public EventHereticFleshSurgeryDoAfter(EntityUid target)
+    {
+        Target = target;
+    }
+}
+
+#endregion
+
+#region Abilities
+
+/// <summary>
+///     Raised whenever we need to check for a magic item before casting a spell that requires one to be worn.
+/// </summary>
+public sealed partial class CheckMagicItemEvent : HandledEntityEventArgs, IInventoryRelayEvent
+{
+    public SlotFlags TargetSlots => SlotFlags.WITHOUT_POCKET;
+}
+
+// basic
+public sealed partial class EventHereticOpenStore : InstantActionEvent { }
+public sealed partial class EventHereticMansusGrasp : InstantActionEvent { }
+
+// for mobs
+public sealed partial class EventHereticMansusLink : EntityTargetActionEvent { }
+
+// ash
+public sealed partial class EventHereticAshenShift : InstantActionEvent { }
+public sealed partial class EventHereticVolcanoBlast : InstantActionEvent { }
+public sealed partial class EventHereticBlazingDash : InstantActionEvent { }
+public sealed partial class EventHereticNightwatcherRebirth : InstantActionEvent { }
+public sealed partial class EventHereticFlames : InstantActionEvent { }
+public sealed partial class EventHereticCascade : InstantActionEvent { }
+
+
+// flesh
+public sealed partial class EventHereticFleshSurgery : EntityTargetActionEvent { }
+public sealed partial class EventHereticFleshAscend : InstantActionEvent { }
+
+// void (including upgrades)
+[Serializable, NetSerializable, DataDefinition] public sealed partial class HereticAristocratWayEvent : EntityEventArgs { }
+[Serializable, NetSerializable, DataDefinition] public sealed partial class HereticAscensionVoidEvent : EntityEventArgs { }
+public sealed partial class HereticVoidBlastEvent : InstantActionEvent { }
+public sealed partial class HereticVoidBlinkEvent : WorldTargetActionEvent { }
+public sealed partial class HereticVoidPullEvent : InstantActionEvent { }
+#endregion
diff --git a/Content.Shared/_Goobstation/Heretic/Prototypes/Heretic.Data.cs b/Content.Shared/_Goobstation/Heretic/Prototypes/Heretic.Data.cs
new file mode 100644
index 0000000000000..0097292fb9dcb
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Prototypes/Heretic.Data.cs
@@ -0,0 +1,12 @@
+using Content.Shared.Tag;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Heretic.Prototypes;
+
+
+
+[Serializable, NetSerializable, DataDefinition] public sealed partial class EventHereticAscension : EntityEventArgs { }
+[Serializable, NetSerializable, DataDefinition] public sealed partial class EventHereticRerollTargets : EntityEventArgs { }
+[Serializable, NetSerializable, DataDefinition] public sealed partial class EventHereticUpdateTargets : EntityEventArgs { }
diff --git a/Content.Shared/_Goobstation/Heretic/Prototypes/HereticKnowledgePrototype.cs b/Content.Shared/_Goobstation/Heretic/Prototypes/HereticKnowledgePrototype.cs
new file mode 100644
index 0000000000000..70c2835c5b98c
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Prototypes/HereticKnowledgePrototype.cs
@@ -0,0 +1,45 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Heretic.Prototypes;
+
+[Serializable, NetSerializable, DataDefinition]
+[Prototype("hereticKnowledge")]
+public sealed partial class HereticKnowledgePrototype : IPrototype
+{
+    [IdDataField] public string ID { get; private set; } = default!;
+
+    [DataField] public string? Path;
+
+    [DataField] public int Stage = 1;
+
+    /// <summary>
+    ///     Indicates that this should not be on a main branch.
+    /// </summary>
+    [DataField] public bool SideKnowledge = false;
+
+    /// <summary>
+    ///     What event should be raised
+    /// </summary>
+    [DataField] public object? Event;
+
+    /// <summary>
+    ///     What rituals should be given
+    /// </summary>
+    [DataField] public List<ProtoId<HereticRitualPrototype>>? RitualPrototypes;
+
+    /// <summary>
+    ///     What actions should be given
+    /// </summary>
+    [DataField] public List<EntProtoId>? ActionPrototypes;
+
+    /// <summary>
+    ///     Used for codex
+    /// </summary>
+    [DataField] public string LocName = string.Empty;
+
+    /// <summary>
+    ///     Used for codex
+    /// </summary>
+    [DataField] public string LocDesc = string.Empty;
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Prototypes/HereticRitualPrototype.cs b/Content.Shared/_Goobstation/Heretic/Prototypes/HereticRitualPrototype.cs
new file mode 100644
index 0000000000000..e42961d395209
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Prototypes/HereticRitualPrototype.cs
@@ -0,0 +1,74 @@
+using Content.Shared.Tag;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Heretic.Prototypes;
+
+[Serializable, NetSerializable, DataDefinition]
+[Prototype("hereticRitual")]
+public sealed partial class HereticRitualPrototype : IPrototype, ICloneable
+{
+    [IdDataField] public string ID { get; private set; } = default!;
+
+    /// <summary>
+    ///     How many entitites with specific names are required for the ritual?
+    /// </summary>
+    [DataField] public Dictionary<string, int>? RequiredEntityNames;
+
+    /// <summary>
+    ///     How many items with certain tags are required for the ritual?
+    /// </summary>
+    [DataField] public Dictionary<ProtoId<TagPrototype>, int>? RequiredTags;
+
+    /// <summary>
+    ///     Is there a custom behavior that needs to be executed?
+    /// </summary>
+    [DataField] public List<RitualCustomBehavior>? CustomBehaviors;
+
+    /// <summary>
+    ///     How many other entities will be created from the ritual?
+    /// </summary>
+    [DataField] public Dictionary<EntProtoId, int>? Output;
+    /// <summary>
+    ///     What event will be raised on success?
+    /// </summary>
+    [DataField] public object? OutputEvent;
+    /// <summary>
+    ///     What knowledge will be given on success?
+    /// </summary>
+    [DataField] public ProtoId<HereticKnowledgePrototype>? OutputKnowledge;
+
+    /// <summary>
+    ///     Used for codex and radial menu.
+    /// </summary>
+    [DataField] public string LocName = "heretic-ritual-unknown";
+
+    /// <summary>
+    ///     Used for codex
+    /// </summary>
+    [DataField] public string LocDesc = string.Empty;
+
+    /// <summary>
+    ///     Icon for codex and radial menu.
+    /// </summary>
+    [DataField] public SpriteSpecifier Icon = new SpriteSpecifier.Rsi(new("_Goobstation/Heretic/amber_focus.rsi"), "icon");
+
+    /// <remarks> Please use this instead of editing the prototype. Shit WILL break if you don't. </remarks>
+    public object Clone()
+    {
+        return new HereticRitualPrototype()
+        {
+            ID = ID,
+            RequiredEntityNames = RequiredEntityNames,
+            RequiredTags = RequiredTags,
+            CustomBehaviors = CustomBehaviors,
+            Output = Output,
+            OutputEvent = OutputEvent,
+            OutputKnowledge = OutputKnowledge,
+            LocName = LocName,
+            LocDesc = LocDesc,
+            Icon = Icon
+        };
+    }
+}
diff --git a/Content.Shared/_Goobstation/Heretic/Prototypes/Ritual.CustomBehaviors.cs b/Content.Shared/_Goobstation/Heretic/Prototypes/Ritual.CustomBehaviors.cs
new file mode 100644
index 0000000000000..ffa8d640fd471
--- /dev/null
+++ b/Content.Shared/_Goobstation/Heretic/Prototypes/Ritual.CustomBehaviors.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Heretic.Prototypes;
+
+[ImplicitDataDefinitionForInheritors]
+public abstract partial class RitualCustomBehavior
+{
+    /// <param name="outstr">Output string in case something is missing</param>
+    /// <returns>If the behavior was successful or not</returns>
+    public abstract bool Execute(RitualData args, out string? outstr);
+
+    /// <summary>
+    ///     If the ritual is successful do *this*.
+    /// </summary>
+    /// <param name="args"></param>
+    public abstract void Finalize(RitualData args);
+}
+
+public readonly record struct RitualData(EntityUid Performer, EntityUid Platform, ProtoId<HereticRitualPrototype> RitualId, IEntityManager EntityManager);
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/basic.yml b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/basic.yml
new file mode 100644
index 0000000000000..7467299625d71
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/basic.yml
@@ -0,0 +1,48 @@
+# actions
+- type: entity
+  id: ActionHereticOpenStore
+  name: Open Knowledge Store
+  description: Open the Knowledge Store.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: open_store
+    event: !type:EventHereticOpenStore {}
+  - type: HereticAction
+    requireMagicItem: false
+
+- type: entity
+  id: ActionHereticMansusGrasp
+  name: Mansus Grasp
+  description: Channel the power of the Old Gods through your grip.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 10
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: mansus_grasp
+    event: !type:EventHereticMansusGrasp {}
+  - type: HereticAction
+    requireMagicItem: false
+
+- type: entity
+  id: ActionHereticMansusLink
+  name: Manse Link
+  description: Pierce through reality and connect minds to one another. Default radio key is :z
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: EntityTargetAction
+    useDelay: 10
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: mansus_link
+    event: !type:EventHereticMansusLink {}
+  - type: HereticAction
+    requireMagicItem: false
+    messageLoc: heretic-speech-link
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_ash.yml b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_ash.yml
new file mode 100644
index 0000000000000..e5aa88efbff9b
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_ash.yml
@@ -0,0 +1,101 @@
+- type: entity
+  id: ActionHereticJaunt
+  name: Ashen Passage
+  description: A short range spell that allows you to pass unimpeded through walls.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 20
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: ashen_shift
+    event: !type:EventHereticAshenShift
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-ash-jaunt
+
+- type: entity
+  id: ActionHereticBlazingDash
+  name: Blazing Dash
+  description: A spell that sets you ablaze and temporarily grants you the speed of a wildfire. Be sure to bring a firesuit.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 10
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: ashen_shift
+    event: !type:EventHereticBlazingDash
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-ash-dash
+
+- type: entity
+  id: ActionHereticVolcanoBlast
+  name: Volcanic Blast
+  description: Charge up a blast of fire that chains between nearby targets, setting them ablaze.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 10
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: volcano_blast
+    event: !type:EventHereticVolcanoBlast
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-ash-volcano
+
+- type: entity
+  id: ActionHereticNightwatcherRebirth
+  name: Nightwatcher's Rebirth
+  description: A spell that extinguishes you and drains nearby heathens engulfed in flames of their life force.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 15
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: nightwatcher_rebirth
+    event: !type:EventHereticNightwatcherRebirth
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-ash-rebirth
+
+- type: entity
+  id: ActionHereticAscension1
+  name: Oath of Flame
+  description: For a minute, you will passively create a ring of fire around you.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 90
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: ashlord_rite1
+    event: !type:EventHereticFlames
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-ash-flame
+
+- type: entity
+  id: ActionHereticAscension2
+  name: Fire Cascade
+  description: Heats the air around you.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 30
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: ashlord_rite2
+    event: !type:EventHereticCascade
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-ash-cascade
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_flesh.yml b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_flesh.yml
new file mode 100644
index 0000000000000..25b823d2e0f03
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_flesh.yml
@@ -0,0 +1,29 @@
+- type: entity
+  id: ActionHereticFleshSurgery
+  name: flesh surgery
+  description: Remove a random organ from someone, or heal your teammates.
+  components:
+  - type: EntityTargetAction
+    useDelay: 30
+    event: !type:EventHereticFleshSurgery
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: flesh_surgery
+  - type: HereticAction
+    messageLoc: heretic-speech-flesh-surgery
+
+- type: entity
+  id: ActionPolymorphHereticHorror
+  name: REALITY UNCOIL
+  description: Transform into an eldritch horror.
+  components:
+  - type: InstantAction
+    useDelay: 60
+    event: !type:EventHereticFleshAscend
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: final_hymn
+  - type: HereticAction
+    messageLoc: heretic-speech-flesh-worm
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_side.yml b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_side.yml
new file mode 100644
index 0000000000000..4f729951623f0
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_side.yml
@@ -0,0 +1 @@
+# actions
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_void.yml b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_void.yml
new file mode 100644
index 0000000000000..cda3a3707fa25
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Actions/Heretic/path_void.yml
@@ -0,0 +1,53 @@
+- type: entity
+  id: ActionHereticVoidBlast
+  name: Void Blast
+  description: Fire off a cone of ice in front of you.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 15
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: void_blast
+    event: !type:HereticVoidBlastEvent
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-void-blast
+
+- type: entity
+  id: ActionHereticVoidPhase
+  name: Void Phase
+  description: Shift through the void, knocking down everyone around you.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: WorldTargetAction
+    useDelay: 15
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: void_phase
+    event: !type:HereticVoidBlinkEvent
+    checkCanAccess: false
+    range: 0
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-void-phase
+
+- type: entity
+  id: ActionHereticVoidPull
+  name: Void Pull
+  description: Pull and damage nearby heathens.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: InstantAction
+    useDelay: 20
+    itemIconStyle: NoItem
+    icon:
+      sprite: _Goobstation/Heretic/abilities_heretic.rsi
+      state: void_pull
+    event: !type:HereticVoidPullEvent
+  - type: HereticAction
+    requireMagicItem: true
+    messageLoc: heretic-speech-void-pull
+
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_ash.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_ash.yml
new file mode 100644
index 0000000000000..35f3d901f635e
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_ash.yml
@@ -0,0 +1,164 @@
+- type: listing
+  id: HereticAshPath1
+  name: knowledge-path-ash-s1-name
+  description: knowledge-path-ash-s1-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_ash.rsi, state: icon }
+  productHereticKnowledge: NightwatcherSecret
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 0
+    # add every path here because you shouldn't be able to buy more starter knowledge
+    blacklist:
+    - Ash
+    - Blade
+    - Flesh
+    - Lock
+    - Rust
+    - Void
+
+- type: listing
+  id: HereticAshPath2
+  name: knowledge-path-ash-s2-name
+  description: knowledge-path-ash-s2-desc
+  icon: { sprite: _Goobstation/Heretic/mansus_grasp.rsi, state: icon }
+  productHereticKnowledge: GraspOfAsh
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 1
+    whitelist:
+    - Ash
+
+# side
+- type: listing
+  id: HereticAshPath3
+  name: knowledge-path-ash-s3-name
+  description: knowledge-path-ash-s3-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: ashen_shift }
+  productHereticKnowledge: BlazingDash
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 2
+
+- type: listing
+  id: HereticAshPath4
+  name: knowledge-path-ash-s4-name
+  description: knowledge-path-ash-s4-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_ash.rsi, state: icon }
+  productHereticKnowledge: MarkOfAsh
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 3
+    whitelist:
+    - Ash
+
+- type: listing
+  id: HereticAshPath5
+  name: knowledge-path-ash-s5-name
+  description: knowledge-path-ash-s5-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: volcano_blast }
+  productHereticKnowledge: VolcanicBlast
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 4
+    whitelist:
+    - Ash
+
+# side
+- type: listing
+  id: HereticAshPath6
+  name: knowledge-path-ash-s6-name
+  description: knowledge-path-ash-s6-desc
+  icon: { sprite: _Goobstation/Heretic/mad_mask.rsi, state: icon }
+  productHereticKnowledge: MaskOfMadness
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 5
+
+- type: listing
+  id: HereticAshPath7
+  name: knowledge-path-ash-s7-name
+  description: knowledge-path-ash-s7-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_ash.rsi, state: icon }
+  productHereticKnowledge: FieryBlade
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 6
+    whitelist:
+    - Ash
+
+# side
+- type: listing
+  id: HereticAshPath8
+  name: knowledge-path-ash-s8-name
+  description: knowledge-path-ash-s8-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: nightwatcher_rebirth }
+  productHereticKnowledge: NightwatcherRebirth
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 7
+
+- type: listing
+  id: HereticAshPath9
+  name: knowledge-path-ash-s9-name
+  description: knowledge-path-ash-s9-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: ashlord_rite1 }
+  productHereticKnowledge: AscensionAsh
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathAsh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 8
+    whitelist:
+    - Ash
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_blade.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_blade.yml
new file mode 100644
index 0000000000000..f12fae2999817
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_blade.yml
@@ -0,0 +1,23 @@
+- type: listing
+  id: KnowledgePathStartBlade
+  name: knowledge-path-blade-s1-name
+  description: knowledge-path-blade-s1-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_blade.rsi, state: icon }
+  #productHereticKnowledge:
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathBlade
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 0
+    # add every path here because you shouldn't be able to buy more starter knowledge
+    blacklist:
+    - Ash
+    - Blade
+    - Flesh
+    - Lock
+    - Rust
+    - Void
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_flesh.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_flesh.yml
new file mode 100644
index 0000000000000..0eea8f352851a
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_flesh.yml
@@ -0,0 +1,164 @@
+- type: listing
+  id: KnowledgePathStartFlesh
+  name: knowledge-path-flesh-s1-name
+  description: knowledge-path-flesh-s1-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_flesh.rsi, state: icon }
+  productHereticKnowledge: PrincipleOfHunger
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 0
+    # add every path here because you shouldn't be able to buy more starter knowledge
+    blacklist:
+    - Ash
+    - Blade
+    - Flesh
+    - Lock
+    - Rust
+    - Void
+
+- type: listing
+  id: HereticFleshPath2
+  name: knowledge-path-flesh-s2-name
+  description: knowledge-path-flesh-s2-desc
+  icon: { sprite: _Goobstation/Heretic/mansus_grasp.rsi, state: icon }
+  productHereticKnowledge: GraspOfFlesh
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 1
+    whitelist:
+    - Flesh
+
+# side
+- type: listing
+  id: HereticFleshPath3
+  name: knowledge-path-flesh-s3-name
+  description: knowledge-path-flesh-s3-desc
+  icon: { sprite: Objects/Specific/Hydroponics/poppy.rsi, state: dead }
+  productHereticKnowledge: ImperfectRitual
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 2
+
+- type: listing
+  id: HereticFleshPath4
+  name: knowledge-path-flesh-s4-name
+  description: knowledge-path-flesh-s4-desc
+  icon: { sprite: _Goobstation/Heretic/mansus_grasp.rsi, state: icon }
+  productHereticKnowledge: MarkOfFlesh
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 3
+    whitelist:
+    - Flesh
+
+- type: listing
+  id: HereticFleshPath5
+  name: knowledge-path-flesh-s5-name
+  description: knowledge-path-flesh-s5-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: flesh_surgery }
+  productHereticKnowledge: KnittingOfFlesh
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 4
+    whitelist:
+    - Flesh
+
+# side
+- type: listing
+  id: HereticFleshPath6
+  name: knowledge-path-flesh-s6-name
+  description: knowledge-path-flesh-s6-desc
+  icon: { sprite: _Goobstation/Heretic/eldritch_mobs.rsi, state: raw_prophet }
+  productHereticKnowledge: RawRitual
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 5
+
+- type: listing
+  id: HereticFleshPath7
+  name: knowledge-path-flesh-s7-name
+  description: knowledge-path-flesh-s7-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_flesh.rsi, state: icon }
+  productHereticKnowledge: BleedingSteel
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 6
+    whitelist:
+    - Flesh
+
+# side
+- type: listing
+  id: HereticFleshPath8
+  name: knowledge-path-flesh-s8-name
+  description: knowledge-path-flesh-s8-desc
+  icon: { sprite: _Goobstation/Heretic/eldritch_mobs.rsi, state: stalker }
+  productHereticKnowledge: LonelyRitual
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 7
+
+- type: listing
+  id: HereticFleshPath9
+  name: knowledge-path-flesh-s9-name
+  description: knowledge-path-flesh-s9-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: final_hymn }
+  productHereticKnowledge: AscensionFlesh
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathFlesh
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 8
+    whitelist:
+    - Flesh
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_lock.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_lock.yml
new file mode 100644
index 0000000000000..fbaed2f87355a
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_lock.yml
@@ -0,0 +1,23 @@
+- type: listing
+  id: KnowledgePathStartLock
+  name: knowledge-path-lock-s1-name
+  description: knowledge-path-lock-s1-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_lock.rsi, state: icon }
+  #productHereticKnowledge:
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathLock
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 0
+    # add every path here because you shouldn't be able to buy more starter knowledge
+    blacklist:
+    - Ash
+    - Blade
+    - Flesh
+    - Lock
+    - Rust
+    - Void
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_rust.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_rust.yml
new file mode 100644
index 0000000000000..0d1fe2d93a1c0
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_rust.yml
@@ -0,0 +1,23 @@
+- type: listing
+  id: KnowledgePathStartRust
+  name: knowledge-path-rust-s1-name
+  description: knowledge-path-rust-s1-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_rust.rsi, state: icon }
+  #productHereticKnowledge:
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathRust
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 0
+    # add every path here because you shouldn't be able to buy more starter knowledge
+    blacklist:
+    - Ash
+    - Blade
+    - Flesh
+    - Lock
+    - Rust
+    - Void
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_side.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_side.yml
new file mode 100644
index 0000000000000..9eab88b9c628d
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_side.yml
@@ -0,0 +1,47 @@
+# store catalog
+- type: listing
+  id: HereticSidePath3Armor
+  name: knowledge-path-side-s3-armor-name
+  description: knowledge-path-side-s3-armor-desc
+  icon: { sprite: _Goobstation/Heretic/eldritch_hood.rsi, state: icon }
+  productHereticKnowledge: ArmorerRitual
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathSide
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 2
+
+- type: listing
+  id: HereticSidePath3Flask
+  name: knowledge-path-side-s3-flask-name
+  description: knowledge-path-side-s3-flask-desc
+  icon: { sprite: _Goobstation/Heretic/items.rsi, state: eldritch_flask }
+  productHereticKnowledge: PriestRitual
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathSide
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 2
+
+- type: listing
+  id: HereticSidePathKnowledge
+  name: knowledge-path-side-s5-name
+  description: knowledge-path-side-s5-desc
+  productHereticKnowledge: RitualOfKnowledge
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathSide
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 5
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_void.yml b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_void.yml
new file mode 100644
index 0000000000000..1e9c8f04efd9a
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Catalog/Heretic/path_void.yml
@@ -0,0 +1,161 @@
+- type: listing
+  id: HereticVoidPath1
+  name: knowledge-path-void-s1-name
+  description: knowledge-path-void-s1-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_void.rsi, state: icon }
+  productHereticKnowledge: GlimmerOfWinter
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 0
+    # add every path here because you shouldn't be able to buy more starter knowledge
+    blacklist:
+    - Ash
+    - Blade
+    - Flesh
+    - Lock
+    - Rust
+    - Void
+
+- type: listing
+  id: HereticVoidPath2
+  name: knowledge-path-void-s2-name
+  description: knowledge-path-void-s2-desc
+  icon: { sprite: _Goobstation/Heretic/mansus_grasp.rsi, state: icon }
+  productHereticKnowledge: GraspOfVoid
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 1
+    whitelist:
+    - Void
+
+- type: listing
+  id: HereticVoidPath3
+  name: knowledge-path-void-s3-name
+  description: knowledge-path-void-s3-desc
+  icon: { sprite: Interface/Alerts/temperature.rsi, state: cold1 }
+  productHereticKnowledge: AristocratWay
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 2
+
+- type: listing
+  id: HereticVoidPath4
+  name: knowledge-path-void-s4-name
+  description: knowledge-path-void-s4-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_void.rsi, state: icon }
+  productHereticKnowledge: MarkOfVoid
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 3
+    whitelist:
+    - Void
+
+- type: listing
+  id: HereticVoidPath5
+  name: knowledge-path-void-s5-name
+  description: knowledge-path-void-s5-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: void_blast }
+  productHereticKnowledge: VoidBlast
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 4
+    whitelist:
+    - Void
+
+- type: listing
+  id: HereticVoidPath6
+  name: knowledge-path-void-s6-name
+  description: knowledge-path-void-s6-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: void_phase }
+  productHereticKnowledge: VoidPhase
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 5
+
+- type: listing
+  id: HereticVoidPath7
+  name: knowledge-path-void-s7-name
+  description: knowledge-path-void-s7-desc
+  icon: { sprite: _Goobstation/Heretic/Blades/blade_void.rsi, state: icon }
+  productHereticKnowledge: SeekingBlade
+  cost:
+    KnowledgePoint: 1
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 6
+    whitelist:
+    - Void
+
+- type: listing
+  id: HereticVoidPath8
+  name: knowledge-path-void-s8-name
+  description: knowledge-path-void-s8-desc
+  icon: { sprite: _Goobstation/Heretic/abilities_heretic.rsi, state: void_pull }
+  productHereticKnowledge: VoidPull
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 7
+
+- type: listing
+  id: HereticVoidPath9
+  name: knowledge-path-void-s9-name
+  description: knowledge-path-void-s9-desc
+  icon: { sprite: Interface/Alerts/temperature.rsi, state: cold3 }
+  productHereticKnowledge: AscensionVoid
+  cost:
+    KnowledgePoint: 2
+  categories:
+  - HereticPathVoid
+  conditions:
+  - !type:ListingLimitedStockCondition
+    stock: 1
+  - !type:HereticPathCondition
+    stage: 8
+    whitelist:
+    - Void
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Datasets/tags.yml b/Resources/Prototypes/_Goobstation/Heretic/Datasets/tags.yml
new file mode 100644
index 0000000000000..2573188baf16f
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Datasets/tags.yml
@@ -0,0 +1,122 @@
+- type: dataset
+  id: EligibleTags
+  values:
+  - BreathMask
+  - ClownEmergencyOxygenTank
+  - EmergencyMedipen
+  - EmergencyNitrogenTank
+  - EmergencyOxygenTank
+  - ExtendedEmergencyOxygenTank
+  - SecurityBreathMask
+  - AirAlarm
+  - AirAlarmElectronics
+  - Airlock
+  - AirSensor
+  - Ambrosia
+  - AppraisalTool
+  - Arrow
+  - ArtifactFragment
+  - Banana
+  - BananaPeel
+  - BaseballBat
+  - BBQsauce
+  - Bedsheet
+  - Beer
+  - BikeHorn
+  - Bloodpack
+  - BodyBag
+  - Book
+  - BorgArm
+  - BorgHead
+  - BorgLeg
+  - BotanyHatchet
+  - BotanyHoe
+  - BotanyShovel
+  - Bottle
+  - Brain
+  - Bread
+  - Briefcase
+  - BrimFlatcapBrown
+  - BrimFlatcapGrey
+  - Brutepack
+  - Bucket
+  - CableCoil
+  - Candle
+  - Cake
+  - CaptainSabre
+  - Carpet
+  - Carrot
+  - Chicken
+  - Cigarette
+  - CigFilter
+  - CigPack
+  - Cleaver
+  - ClownMask
+  - ClownRecorder
+  - ClownShoes
+  - ClownSuit
+  - CombatKnife
+  - ConveyorAssembly
+  - Cow
+  - Crayon
+  - Crowbar
+  - DoorElectronics
+  - Egg
+  - Eyes
+  - Figurine
+  - FireAlarm
+  - FireAlarmElectronics
+  - Flare
+  - Flashlight
+  - Flower
+  - Folder
+  - Fruit
+  - Galaxythistle
+  - GasMask
+  - GasScrubber
+  - GasTank
+  - GasVent
+  - Gauze
+  - GeigerCounter
+  - GlassAirlock
+  - GlassBeaker
+  - GlassShard
+  - Goat
+  - GPS
+  - HudMedical
+  - HudSecurity
+  - Hamster
+  - Hardsuit
+  - Heart
+  - HelmetEVA
+  - Igniter
+  - Liver
+  - Lungs
+  - Mask
+  - Mayo
+  - Meat
+  - Medal
+  - Medkit
+  - MicrowaveMachineBoard
+  - MonkeyCube
+  - Mop
+  - Mouse
+  - Multitool
+  - Ointment
+  - Organ
+  - Paper
+  - Pen
+  - Pickaxe
+  - Pill
+  - PillCanister
+  - Pipe
+  - PowerCell
+  - Shiv
+  - Soap
+  - Stomach
+  - Steak
+  - Sunglasses
+  - SurgeryTool
+  - Trash
+  - Wirecutter
+  - Wrench
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Head/hoods.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Head/hoods.yml
new file mode 100644
index 0000000000000..ac15292f3ba42
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Head/hoods.yml
@@ -0,0 +1,18 @@
+- type: entity
+  parent: [ ClothingHeadBase, TierXContraband ]
+  id: ClothingHeadHatHoodHeretic
+  name: ominous hood
+  description: A torn, dust-caked hood. Strange eyes line the inside.
+  components:
+  - type: HereticMagicItem
+  - type: Sprite
+    sprite: _Goobstation/Heretic/eldritch_hood.rsi
+    state: icon
+  - type: Clothing
+    sprite: _Goobstation/Heretic/eldritch_hood.rsi
+  - type: Tag
+    tags:
+    - WhitelistChameleon
+  - type: HideLayerClothing
+    slots:
+    - Hair
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Mask/masks.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Mask/masks.yml
new file mode 100644
index 0000000000000..0a3ccdf4004dd
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Mask/masks.yml
@@ -0,0 +1,23 @@
+- type: entity
+  parent: [ ClothingMaskBase, TierXContraband ]
+  id: ClothingMaskMadHeretic
+  name: abyssal mask
+  description: A mask created from suffering. When you look into its eyes, it looks back.
+  components:
+  # what heretic would remove the mask that will shit on everyone around him?
+  # also forcing the mask on heathens will be funny.
+  - type: SelfUnremovableClothing
+  - type: MadnessMask
+  - type: Sprite
+    sprite: _Goobstation/Heretic/mad_mask.rsi
+  - type: Clothing
+    sprite: _Goobstation/Heretic/mad_mask.rsi
+  - type: BreathMask
+  - type: IdentityBlocker
+  - type: Tag
+    tags:
+    - Mask
+    - WhitelistChameleon
+  - type: HideLayerClothing
+    slots:
+    - Snout
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Neck/specific.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Neck/specific.yml
new file mode 100644
index 0000000000000..9d3600688d0c8
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/Neck/specific.yml
@@ -0,0 +1,13 @@
+- type: entity
+  parent: [ ClothingNeckBase, TierXContraband ]
+  id: ClothingNeckAmberFocus
+  name: amber focus
+  description: An amber focusing glass that provides a link to the world beyond. The necklace seems to twitch, but only when you look at it from the corner of your eye.
+  suffix: MagicItem
+  components:
+    - type: HereticMagicItem
+    - type: Sprite
+      sprite: _Goobstation/Heretic/amber_focus.rsi
+      state: icon
+    - type: Clothing
+      sprite: _Goobstation/Heretic/amber_focus.rsi
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/OuterClothing/armor.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/OuterClothing/armor.yml
new file mode 100644
index 0000000000000..802e528ff84d1
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Clothing/OuterClothing/armor.yml
@@ -0,0 +1,24 @@
+- type: entity
+  parent: [ ClothingOuterBaseMedium, ClothingOuterStorageToggleableBase, TierXContraband ]
+  id: ClothingOuterArmorHeretic
+  name: ominous armor
+  description: A ragged, dusty set of robes. Strange eyes line the inside.
+  components:
+  - type: Sprite
+    sprite: _Goobstation/Heretic/eldritch_armor.rsi
+    state: icon
+  - type: Clothing
+    sprite: _Goobstation/Heretic/eldritch_armor.rsi
+  - type: Armor
+    modifiers:
+      coefficients:
+        Blunt: 0.50
+        Slash: 0.50
+        Piercing: 0.50
+        Heat: 0.50
+        Caustic: 0.50
+  - type: ExplosionResistance
+    damageCoefficient: 0.25
+  - type: ToggleableClothing
+    clothingPrototype: ClothingHeadHatHoodHeretic
+    slot: head
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Mobs/NPC/eldritch_mobs.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Mobs/NPC/eldritch_mobs.yml
new file mode 100644
index 0000000000000..f3489164406c0
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Mobs/NPC/eldritch_mobs.yml
@@ -0,0 +1,138 @@
+- type: entity
+  parent: [ SimpleMobBase, MobCombat ]
+  id: BaseMobGhoul
+  abstract: true
+  components:
+  - type: Ghoul
+  - type: MovementSpeedModifier
+    baseWalkSpeed: 2.00
+    baseSprintSpeed: 3.00
+  - type: InputMover
+  - type: MobMover
+  - type: Reactive
+    groups:
+      Flammable: [Touch]
+      Extinguish: [Touch]
+  - type: NpcFactionMember
+    factions:
+    - Heretic
+  - type: Physics
+    bodyType: KinematicController
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeCircle
+          radius: 0.35
+        density: 250
+        mask:
+        - MobMask
+        layer:
+        - MobLayer
+  - type: MobState
+  - type: MobThresholds
+    thresholds:
+      0: Alive
+      90: Critical
+      100: Dead
+  - type: MeleeWeapon
+    altDisarm: false
+    soundHit:
+        path: /Audio/Weapons/Xeno/alien_claw_flesh1.ogg
+    angle: 0
+    animation: WeaponArcClaw
+    damage:
+      types:
+        Slash: 12
+        Piercing: 8
+  - type: NoSlip
+  - type: Grammar
+    attributes:
+      gender: male
+  - type: GhostRole
+    allowMovement: true
+    allowSpeech: true
+    makeSentient: true
+    name: ghostrole-ghoul-name
+    description: ghostrole-ghoul-desc
+    rules: ghostrole-ghoul-rules
+    raffle:
+      settings: short
+    mindRoles: # imp
+    - MindRoleGhostRoleFamiliar
+  - type: ActiveRadio
+    channels:
+    - Mansus
+  - type: IntrinsicRadioReceiver
+  - type: IntrinsicRadioTransmitter
+    channels:
+    - Mansus
+
+
+- type: entity
+  parent: BaseMobGhoul
+  id: MobGhoulStalker
+  name: flesh stalker
+  description: An abomination cobbled together from varied remains. Its appearance changes slightly every time you blink.
+  components:
+  - type: Ghoul
+    totalHealth: 150
+  - type: Sprite
+    sprite: _Goobstation/Heretic/eldritch_mobs.rsi
+    state: stalker
+  - type: GhostRole
+    name: ghostrole-stalker-name
+    description: ghostrole-stalker-desc
+    mindRoles: # imp
+    - MindRoleGhostRoleFamiliar
+  - type: ActionsProvider
+    actions:
+    - ActionHereticJaunt
+  # basically an EMP implant. don't feel like making 1 more emp action
+    - ActionActivateEmpImplant
+  - type: TriggerImplantAction
+  - type: EmpOnTrigger
+    range: 5
+    energyConsumption: 50000
+    disableDuration: 20
+
+- type: entity
+  parent: BaseMobGhoul
+  id: MobGhoulProphet
+  name: raw prophet
+  description: An abomination stitched together from a few severed arms and one swollen, orphaned eye.
+  components:
+  - type: Ghoul
+    totalHealth: 75
+  - type: Sprite
+    noRot: true
+    sprite: _Goobstation/Heretic/eldritch_mobs.rsi
+    layers:
+    - map: [ "movement" ]
+      state: raw_prophet
+  - type: SpriteMovement
+    movementLayers:
+      movement:
+        state: raw_prophet-move
+    noMovementLayers:
+      movement:
+        state: raw_prophet
+  - type: GhostRole
+    name: ghostrole-prophet-name
+    description: ghostrole-prophet-desc
+    mindRoles: # imp
+    - MindRoleGhostRoleFamiliar
+  - type: ActionsProvider
+    actions:
+    - ActionHereticJaunt
+    - ActionHereticMansusLink
+
+- type: entity
+  parent: BaseMobGhoul
+  id: MobGhoulRustWalker
+  name: rust walker
+  description: A grinding, clanking construct which leaches life from its surroundings with every armoured step.
+  categories: [ DoNotMap ] # imp
+  components:
+  - type: Ghoul
+    totalHealth: 100
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Mobs/NPC/polymorph.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Mobs/NPC/polymorph.yml
new file mode 100644
index 0000000000000..18ae63f538c93
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Mobs/NPC/polymorph.yml
@@ -0,0 +1,211 @@
+- type: entity
+  id: PolymorphAshJauntAnimation
+  name: Unknown
+  description: You can't figure out what that is.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: Sprite
+    drawdepth: WallMountedItems
+    sprite: _Goobstation/Heretic/polymorphs.rsi
+    state: ash_jaunt
+    loop: false
+  - type: TimedDespawn
+    lifetime: 1
+
+- type: entity
+  id: PolymorphAshJauntEndAnimation
+  name: Unknown
+  description: You can't figure out what that is.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: Sprite
+    drawdepth: WallMountedItems
+    sprite: _Goobstation/Heretic/polymorphs.rsi
+    state: ash_jaunt_end
+    loop: false
+  - type: TimedDespawn
+    lifetime: 1
+
+- type: entity
+  id: PolymorphAshJaunt
+  name: Unknown
+  description: You can't figure out what that is.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: MindContainer
+  - type: InputMover
+  - type: MobMover
+  - type: Input
+    context: "ghost"
+  - type: MovementSpeedModifier
+    baseWalkSpeed: 3
+    baseSprintSpeed: 3
+  - type: Physics
+    bodyType: KinematicController
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeCircle
+          radius: 0.40
+        density: 80
+        mask:
+        - GhostImpassable
+  - type: MovementIgnoreGravity
+  - type: Actions
+  - type: NoSlip
+  - type: Eye
+    drawFov: false
+    visMask:
+      - Normal
+      - Ghost
+  - type: ContentEye
+    maxZoom: 1.2, 1.2
+  - type: DoAfter
+  - type: Alerts
+
+# heretic ascend flesh form
+- type: entity
+  parent: BaseMob
+  id: MobHereticFleshAscend
+  name: eldritch horror
+  description: An incomprehensible mess of limbs and eyes. You can feel it's stare into your soul.
+  categories: [ DoNotMap ] # imp
+  components:
+  - type: NpcFactionMember
+    factions:
+    - Heretic
+  - type: CombatMode
+  - type: MovementSpeedModifier
+    baseWalkSpeed: 5
+    baseSprintSpeed: 7.5
+    weightlessModifier: 1.5
+  - type: Sprite # contains imp changes
+    drawdepth: Mobs
+    sprite: _Goobstation/Heretic/eldritch_horror.rsi
+    noRot: true
+    layers:
+    - map: [ "fleshMap" ]
+      state: flesh
+    - map: [ "bloodMap" ]
+      state: blood
+    - map: [ "eyesMap" ]
+      state: eyes
+  - type: RandomSprite # imp. it's not actually random, but we do what we must with the tools we are given. this gets edited by HereticAbilitySystem.Flesh on ascention.
+    selected:
+      fleshMap:
+        flesh: "#ffd2ba"
+      bloodMap:
+        blood: "#9e0000"
+      eyesMap:
+        eyes: "#000000"
+  - type: Destructible # imp. replaces DamageSpriteVisuals
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 1000
+      behaviors:
+      - !type:DoActsBehavior
+        acts: [ "Destruction" ]
+      - !type:SpawnEntitiesBehavior # don't want this to be more complicated than it needs to be
+        spawn:
+          EldritchInfluenceSpent:
+            min: 1
+            max: 1
+      - !type:SpillBehavior
+        solution: blood
+  - type: SolutionContainerManager # imp. Little bit o' everybody in there.
+    solutions:
+      blood:
+        maxVol: 800
+        reagents:
+        - ReagentId: ShimmeringBlood
+          Quantity: 100
+        - ReagentId: InsectBlood
+          Quantity: 100
+        - ReagentId: Slime
+          Quantity: 100
+        - ReagentId: GrayBlood
+          Quantity: 100
+        - ReagentId: CopperBlood
+          Quantity: 100
+        - ReagentId: BloodKodepiia
+          Quantity: 100
+        - ReagentId: AmmoniaBlood
+          Quantity: 100
+        - ReagentId: Blood
+          Quantity: 100
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Physics
+    bodyType: KinematicController
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeCircle
+          radius: 0.40
+        density: 100
+        mask:
+        - FlyingMobMask
+        layer:
+        - FlyingMobLayer
+  - type: MobState
+    allowedStates:
+      - Alive
+      - Dead
+  - type: MobThresholds
+    thresholds:
+      0: Alive
+      500: Critical
+      1000: Dead
+  - type: Damageable
+    damageContainer: Biological
+  - type: StatusEffects
+    allowed:
+    - SlowedDown
+    - RadiationProtection
+  - type: MeleeWeapon
+    hidden: false
+    altDisarm: false
+    autoAttack: true
+    attackRate: 2.5
+    damage:
+      types:
+       Blunt: 20
+       Structural: 60
+    soundHit:
+      collection: Punch
+    animation: WeaponArcFist
+  - type: Devourer
+    foodPreference: Humanoid
+    shouldStoreDevoured: true
+    chemical: Ichor
+    healRate: 15.0
+    whitelist:
+      components:
+      - MobState
+      - Door
+      tags:
+      - Wall
+  - type: Metabolizer
+    solutionOnBody: false
+    updateInterval: 0.25
+    metabolizerTypes: [ Dragon ]
+    groups:
+    - id: Medicine
+    - id: Poison
+  # imp note - removed Butcherable because it now explodes into blood when it dies.
+  - type: Tag
+    tags:
+    - CannotSuicide
+    - DoorBumpOpener
+  - type: ActiveRadio
+    channels:
+    - Mansus
+  - type: IntrinsicRadioReceiver
+  - type: IntrinsicRadioTransmitter
+    channels:
+    - Mansus
+  - type: Examiner
+  - type: Pullable
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Specific/heretic.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Specific/heretic.yml
new file mode 100644
index 0000000000000..f80eb9c146162
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Specific/heretic.yml
@@ -0,0 +1,103 @@
+- type: entity
+  parent: [ BaseItem ]
+  id: CodexCicatrix
+  name: codex cicatrix
+  description: An ominous book you've never seen before. The letters seem to be constantly rearranging themselves.
+  components:
+  - type: Sprite
+    sprite: _Goobstation/Heretic/book.rsi
+    layers:
+    - state: icon
+      map: [ "base" ]
+  - type: GenericVisualizer
+    visuals:
+      enum.ToggleVisuals.Toggled:
+        base:
+          True: { state: icon-on }
+          False: { state: icon }
+  - type: Item
+    size: Small
+    sprite: _Goobstation/Heretic/book.rsi
+  - type: UseDelay
+    delay: 1.0
+  - type: PointLight
+    enabled: false
+    radius: 2
+    energy: 1
+    color: "#6e7500"    
+    netsync: false
+  - type: Appearance
+  - type: ItemToggle
+    predictable: false
+  - type: ItemToggleUserRestrict
+    restrictMessage: heretic-book-open-failure
+    closeRestrict: false
+    components:
+    - type: Heretic
+  - type: ComponentToggler
+    components:
+    - type: HereticMagicItem
+    - type: Contraband
+      severity: TierXContraband
+  - type: ItemTogglePointLight
+  - type: ToggleableLightVisuals
+  - type: ItemToggleSize
+    activatedSize: Normal
+
+- type: entity
+  parent: [ DrinkBase, TierXContraband ]
+  id: HereticEldritchFlask
+  name: eldritch flask
+  description: A flask filled with an unknown substance. Who knows what will happen when you take a sip from it.
+  components:
+  - type: Sprite
+    sprite: _Goobstation/Heretic/items.rsi
+    state: eldritch_flask
+  - type: Icon
+    sprite: _Goobstation/Heretic/items.rsi
+    state: eldritch_flask
+  - type: SolutionContainerManager
+    solutions:
+      drink:
+        # it's a cryostasis flash filled with healing goodies what could possibly go wrong?
+        # i will certainly not abuse it as a heretic chemist
+        # imp edit: ^^^^this guy no longer has his free 100u cryostasis beaker to pwn noobs with. jesus christ
+        maxVol: 75
+        canReact: true
+        reagents:
+        - ReagentId: Omnizine
+          Quantity: 60
+        - ReagentId: TranexamicAcid
+          Quantity: 15
+
+- type: entity
+  id: AlwaysPoweredHellLight
+  parent: MarkerBase
+  name: hellworldlight
+  description: "An always powered light."
+  suffix: Always powered
+  components:
+  - type: PointLight
+    color: "#FF7777" # 5000K color temp
+    energy: 0.8
+    radius: 10
+    softness: 1
+    offset: "0, -0.5"
+  - type: Sprite
+    layers:
+      - state: green
+      - sprite: Structures/Wallmounts/Lighting/light_tube.rsi
+        state: base
+
+- type: entity
+  id: HellSpawnPointMarker
+  parent: MarkerBase
+  name: hellworldtarget
+  description: "You go here if you do drugs."
+  components:
+  - type: HellSpawnPoint
+  - type: Sprite
+    layers:
+      - state: green
+      - sprite: Mobs/Species/Human/parts.rsi
+        state: full
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
new file mode 100644
index 0000000000000..0bd118ac8d74b
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
@@ -0,0 +1,28 @@
+- type: entity
+  parent: BaseBulletTrigger
+  id: FireballChain
+  name: twisted fireball
+  description: Uh oh.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: ChainFireball
+  - type: Sprite
+    sprite: Objects/Weapons/Guns/Projectiles/magic.rsi
+    layers:
+    - state: fireball
+      shader: unshaded
+  - type: IgnitionSource
+    temperature: 1000
+    ignited: true
+  - type: IgniteOnCollide
+    fireStacks: 0.5
+  - type: PointLight
+    color: "#E25822"
+    radius: 2.0
+    energy: 5.0
+  - type: Projectile
+    damage:
+      types:
+        Heat: 5
+  - type: TimedDespawn
+    lifetime: 1
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Melee/heretic_blades.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Melee/heretic_blades.yml
new file mode 100644
index 0000000000000..cd22ae9a765c7
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Melee/heretic_blades.yml
@@ -0,0 +1,122 @@
+- type: entity
+  parent: [ BaseItem, TierXContraband ]
+  id: HereticBladeBase
+  name: eldritch blade
+  description: The sickly blade used by sinister individuals for rituals and sacrifices.
+  components:
+  - type: HereticBlade
+  - type: Sharp
+  - type: Sprite
+    sprite: _Goobstation/Heretic/Blades/blade_blade.rsi
+    state: icon
+  - type: MeleeWeapon
+    wideAnimationRotation: -125
+    attackRate: 1
+    damage:
+      types:
+        Slash: 17.5
+    soundHit:
+      path: /Audio/Weapons/bladeslice.ogg
+  - type: Item
+    size: Normal
+    sprite: _Goobstation/Heretic/Blades/blade_blade-inhand.rsi
+  - type: ItemToggle
+  - type: DamageOtherOnHit
+    staminaCost: 7
+
+- type: entity
+  parent: HereticBladeBase
+  id: HereticBladeAsh
+  name: ashen blade
+  suffix: Ash
+  components:
+  - type: HereticBlade
+    path: Ash
+  - type: Sprite
+    sprite: _Goobstation/Heretic/Blades/blade_ash.rsi
+    state: icon
+  - type: Item
+    sprite: _Goobstation/Heretic/Blades/blade_ash-inhand.rsi
+  - type: MeleeWeapon
+    wideAnimationRotation: -125
+    attackRate: 1
+    damage:
+      types:
+        Heat: 10
+        Slash: 7.5
+    soundHit:
+      path: /Audio/Weapons/bladeslice.ogg
+
+- type: entity
+  parent: HereticBladeBase
+  id: HereticBladeBlade
+  name: sundered blade
+  suffix: Blade
+  components:
+  - type: HereticBlade
+    path: Blade
+
+- type: entity
+  parent: HereticBladeBase
+  id: HereticBladeFlesh
+  name: bloody blade
+  suffix: Flesh
+  components:
+  - type: HereticBlade
+    path: Flesh
+  - type: Sprite
+    sprite: _Goobstation/Heretic/Blades/blade_flesh.rsi
+    state: icon
+  - type: Item
+    sprite: _Goobstation/Heretic/Blades/blade_flesh-inhand.rsi
+
+- type: entity
+  parent: HereticBladeBase
+  id: HereticBladeLock
+  name: key blade
+  suffix: Lock
+  components:
+  - type: HereticBlade
+    path: Lock
+  - type: Sprite
+    sprite: _Goobstation/Heretic/Blades/blade_lock.rsi
+    state: icon
+  - type: Item
+    sprite: _Goobstation/Heretic/Blades/blade_lock-inhand.rsi
+
+- type: entity
+  parent: HereticBladeBase
+  id: HereticBladeRust
+  name: rusty blade
+  suffix: Rust
+  components:
+  - type: HereticBlade
+    path: Rust
+  - type: Sprite
+    sprite: _Goobstation/Heretic/Blades/blade_rust.rsi
+    state: icon
+  - type: Item
+    sprite: _Goobstation/Heretic/Blades/blade_rust-inhand.rsi
+
+- type: entity
+  parent: HereticBladeBase
+  id: HereticBladeVoid
+  name: void blade
+  suffix: Void
+  components:
+  - type: HereticBlade
+    path: Void
+  - type: Sprite
+    sprite: _Goobstation/Heretic/Blades/blade_void.rsi
+    state: icon
+  - type: Item
+    sprite: _Goobstation/Heretic/Blades/blade_void-inhand.rsi
+  - type: MeleeWeapon
+    wideAnimationRotation: -125
+    attackRate: 1
+    damage:
+      types:
+        Cold: 10
+        Slash: 7.5
+    soundHit:
+      path: /Audio/Weapons/bladeslice.ogg
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Touchspell/mansus_grasp.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Touchspell/mansus_grasp.yml
new file mode 100644
index 0000000000000..37a34ae46422a
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/Weapons/Touchspell/mansus_grasp.yml
@@ -0,0 +1,19 @@
+- type: entity
+  id: TouchSpellMansus
+  name: mansus grasp
+  description: The power of the Old Gods, channeled through your grip.
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: Unremoveable
+  - type: Item
+  - type: MansusGrasp
+  - type: Sprite
+    sprite: _Goobstation/Heretic/mansus_grasp.rsi
+    state: icon
+  - type: Appearance
+  - type: UseDelay
+  - type: PointLight
+    enabled: true
+    radius: 1.4
+    energy: 1
+    color: "#329a00"
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/magic_contraband.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/magic_contraband.yml
new file mode 100644
index 0000000000000..97c36d8c41313
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Objects/magic_contraband.yml
@@ -0,0 +1,12 @@
+- type: entity
+  id: BaseMagicContraband
+  abstract: true
+  components:
+  - type: Contraband
+    severity: Magic
+    allowedDepartments: []
+
+- type: contrabandSeverity
+  id: Magic
+  examineColor: crimson
+  examineText: contraband-examine-text-magic
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Structures/Specific/Heretic/eldritch_influence.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Structures/Specific/Heretic/eldritch_influence.yml
new file mode 100644
index 0000000000000..1aa54a248fa20
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Structures/Specific/Heretic/eldritch_influence.yml
@@ -0,0 +1,37 @@
+- type: entity
+  id: EldritchInfluence
+  name: reality shift
+  description: Your eyes start to burn just from a single look. Should you delve deeper?
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: InteractionOutline
+  - type: EldritchInfluence
+  - type: Sprite
+    sprite: _Goobstation/Heretic/reality_fracture.rsi
+    state: icon
+  - type: Clickable
+  - type: Visibility
+    layer: 69
+
+- type: entity
+  id: EldritchInfluenceIntermediate
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: TimedDespawn
+    lifetime: 30
+  - type: SpawnOnDespawn
+    prototype: EldritchInfluenceSpent
+
+- type: entity
+  id: EldritchInfluenceSpent
+  name: reality fracture
+  description: A reality fracture. Something keeps leaking out of it, should you really be near this thing?
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: InteractionOutline
+  - type: Sprite
+    sprite: _Goobstation/Heretic/reality_fracture.rsi
+    state: icon_harvested
+  - type: Clickable
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Entities/Structures/Specific/Heretic/ritual_rune.yml b/Resources/Prototypes/_Goobstation/Heretic/Entities/Structures/Specific/Heretic/ritual_rune.yml
new file mode 100644
index 0000000000000..180c843ecbc57
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Entities/Structures/Specific/Heretic/ritual_rune.yml
@@ -0,0 +1,45 @@
+- type: entity
+  id: HereticRuneRitual
+  name: transmutation rune
+  description: An ancient drawing used by sinister individuals for sacrifices.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: HereticRitualRune
+  - type: Sprite
+    drawdepth: HighFloorObjects
+    sprite: _Goobstation/Heretic/ritual_rune.rsi
+    state: icon
+  - type: Clickable
+  - type: UserInterface
+    interfaces:
+       enum.HereticRitualRuneUiKey.Key:
+        type: HereticRitualRuneBoundUserInterface
+
+- type: entity
+  id: HereticRuneRitualDrawAnimation
+  name: unfinished transmutation rune
+  description: An unfinished ancient drawing used by sinister individuals for sacrifices.
+  categories: [ HideSpawnMenu ]
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Sprite
+    drawdepth: HighFloorObjects
+    sprite: _Goobstation/Heretic/ritual_rune.rsi
+    state: icon_drawanim
+
+- type: entity
+  id: HereticRuneRitualAnimation
+  name: transmutation rune
+  description: you shouldn't be seeing this description
+  placement:
+    mode: SnapgridCenter
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: TimedDespawn
+    lifetime: 1
+  - type: Sprite
+    drawdepth: HighFloorObjects
+    sprite: _Goobstation/Heretic/ritual_rune.rsi
+    state: icon_ritualanim
diff --git a/Resources/Prototypes/_Goobstation/Heretic/GameRules/roundstart.yml b/Resources/Prototypes/_Goobstation/Heretic/GameRules/roundstart.yml
new file mode 100644
index 0000000000000..fb8ae91e0b574
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/GameRules/roundstart.yml
@@ -0,0 +1,30 @@
+- type: entity
+  parent: BaseGameRule
+  id: Heretic
+  components:
+  - type: HereticRule
+  - type: GameRule
+    minPlayers: 20
+    cancelPresetOnTooFewPlayers: false
+    delay:
+      min: 30
+      max: 60
+  - type: AntagObjectives
+    objectives:
+    - HereticKnowledgeObjective
+    - HereticSacrificeObjective
+    - HereticSacrificeHeadObjective
+  - type: AntagSelection
+    selectionTime: IntraPlayerSpawn # Imp edit
+    agentName: heretic-roundend-name
+    definitions:
+    - prefRoles: [ Heretic ]
+      max: 6
+      playerRatio: 12 # little less than syndicates. maxes to 6 at >60 pop, previously 4
+      lateJoinAdditional: true
+      blacklist:
+        components:
+          - AntagImmune
+      mindRoles:
+      - MindRoleHeretic
+      startingGear: HereticGear # see Roles/Antags/heretic.yml
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Guidebook/antagonist.yml b/Resources/Prototypes/_Goobstation/Heretic/Guidebook/antagonist.yml
new file mode 100644
index 0000000000000..3ce1cf4fb83ee
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Guidebook/antagonist.yml
@@ -0,0 +1,54 @@
+- type: guideEntry
+  id: Heretics
+  name: guide-entry-heretics
+  text: "/ServerInfo/_Impstation/Guidebook/Antagonist/Heretics.xml" # given a consistency pass by dark, keeping in imp directory 4 now
+  children:
+  - HereticsKnowledge
+  - HereticsSpells
+  - HereticsRituals
+  - HereticsPaths
+  - HereticsSide
+
+- type: guideEntry
+  id: HereticsPaths
+  name: guide-entry-heretics-paths
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsPaths.xml"
+  children:
+    - HereticsAsh
+    - HereticsFlesh
+    - HereticsVoid
+
+- type: guideEntry
+  id: HereticsKnowledge
+  name: guide-entry-heretics-knowledge
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsKnowledge.xml"
+
+- type: guideEntry
+  id: HereticsSpells
+  name: guide-entry-heretics-spells
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsSpells.xml"
+
+- type: guideEntry
+  id: HereticsRituals
+  name: guide-entry-heretics-rituals
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsRituals.xml"
+
+- type: guideEntry
+  id: HereticsAsh
+  name: guide-entry-heretics-ash
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsAsh.xml"
+
+- type: guideEntry
+  id: HereticsFlesh
+  name: guide-entry-heretics-flesh
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsFlesh.xml"
+
+- type: guideEntry
+  id: HereticsVoid
+  name: guide-entry-heretics-void
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsVoid.xml"
+
+- type: guideEntry
+  id: HereticsSide
+  name: guide-entry-heretics-side
+  text: "/ServerInfo/_Goobstation/Guidebook/Antagonist/HereticsSide.xml"
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Heretic/heretic_knowledge.yml b/Resources/Prototypes/_Goobstation/Heretic/Heretic/heretic_knowledge.yml
new file mode 100644
index 0000000000000..b32c2d5e9476f
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Heretic/heretic_knowledge.yml
@@ -0,0 +1,256 @@
+### basic knowledge
+- type: hereticKnowledge
+  id: BreakOfDawn
+  actionPrototypes:
+  - ActionHereticOpenStore
+  - ActionHereticMansusGrasp
+
+- type: hereticKnowledge
+  id: HeartbeatOfMansus
+  ritualPrototypes:
+  - Sacrifice  
+
+- type: hereticKnowledge
+  id: AmberFocus
+  ritualPrototypes:
+  - AmberFocus
+
+- type: hereticKnowledge
+  id: CodexCicatrix
+  ritualPrototypes:
+  - CodexCicatrix
+
+### ash path
+- type: hereticKnowledge
+  id: NightwatcherSecret
+  path: Ash
+  stage: 1
+  ritualPrototypes:
+  - BladeAsh  
+
+- type: hereticKnowledge
+  id: GraspOfAsh
+  path: Ash
+  stage: 2
+
+- type: hereticKnowledge
+  id: BlazingDash
+  path: Ash
+  sideKnowledge: true
+  stage: 3
+  actionPrototypes:
+  - ActionHereticBlazingDash
+
+- type: hereticKnowledge
+  id: AshenShift
+  path: Ash
+  sideKnowledge: true
+  stage: 3
+  actionPrototypes:
+  - ActionHereticJaunt
+
+- type: hereticKnowledge
+  id: MarkOfAsh
+  path: Ash
+  stage: 4
+
+- type: hereticKnowledge
+  id: VolcanicBlast
+  path: Ash
+  stage: 5
+  actionPrototypes:
+  - ActionHereticVolcanoBlast
+
+- type: hereticKnowledge
+  id: MaskOfMadness
+  path: Ash
+  sideKnowledge: true
+  stage: 6
+  ritualPrototypes:
+  - MaskOfMadness
+
+- type: hereticKnowledge
+  id: FieryBlade
+  path: Ash
+  stage: 7
+
+- type: hereticKnowledge
+  id: NightwatcherRebirth
+  path: Ash
+  sideKnowledge: true
+  stage: 8
+  actionPrototypes:
+  - ActionHereticNightwatcherRebirth
+
+- type: hereticKnowledge
+  id: AscensionAsh
+  path: Ash
+  stage: 9
+  ritualPrototypes:
+  - AscensionAsh
+
+- type: hereticKnowledge
+  id: AshlordRite
+  path: Ash
+  stage: 10
+  actionPrototypes:
+  - ActionHereticAscension1
+  - ActionHereticAscension2
+
+### flesh path
+- type: hereticKnowledge
+  id: PrincipleOfHunger
+  path: Flesh
+  stage: 1
+  ritualPrototypes:
+  - BladeFlesh
+
+- type: hereticKnowledge
+  id: GraspOfFlesh
+  path: Flesh
+  stage: 2
+
+- type: hereticKnowledge
+  id: ImperfectRitual
+  path: Flesh
+  sideKnowledge: true
+  stage: 3
+  ritualPrototypes:
+  - ImperfectRitual
+
+- type: hereticKnowledge
+  id: MarkOfFlesh
+  path: Flesh
+  stage: 4
+
+- type: hereticKnowledge
+  id: KnittingOfFlesh
+  path: Flesh
+  stage: 5
+  actionPrototypes:
+  - ActionHereticFleshSurgery
+
+- type: hereticKnowledge
+  id: RawRitual
+  path: Flesh
+  sideKnowledge: true
+  stage: 6
+  ritualPrototypes:
+  - RawRitual
+
+- type: hereticKnowledge
+  id: BleedingSteel
+  path: Flesh
+  stage: 7
+
+- type: hereticKnowledge
+  id: LonelyRitual
+  path: Flesh
+  sideKnowledge: true
+  stage: 8
+  ritualPrototypes:
+  - LonelyRitual
+
+- type: hereticKnowledge
+  id: AscensionFlesh
+  path: Flesh
+  stage: 9
+  ritualPrototypes:
+  - AscensionFlesh
+
+- type: hereticKnowledge
+  id: PriestFinalHymn
+  path: Flesh
+  stage: 10
+  actionPrototypes:
+  - ActionPolymorphHereticHorror
+
+### void path
+- type: hereticKnowledge
+  id: GlimmerOfWinter
+  path: Void
+  stage: 1
+  ritualPrototypes:
+  - BladeVoid
+
+- type: hereticKnowledge
+  id: GraspOfVoid
+  path: Void
+  stage: 2
+
+- type: hereticKnowledge
+  id: AristocratWay
+  path: Void
+  sideKnowledge: true
+  stage: 3
+  event: !type:HereticAristocratWayEvent
+
+- type: hereticKnowledge
+  id: MarkOfVoid
+  path: Void
+  stage: 4
+
+- type: hereticKnowledge
+  id: VoidBlast
+  path: Void
+  stage: 5
+  actionPrototypes:
+  - ActionHereticVoidBlast
+
+- type: hereticKnowledge
+  id: VoidPhase
+  path: Void
+  sideKnowledge: true
+  stage: 6
+  actionPrototypes:
+  - ActionHereticVoidPhase
+
+- type: hereticKnowledge
+  id: SeekingBlade
+  path: Void
+  stage: 7
+
+- type: hereticKnowledge
+  id: VoidPull
+  path: Void
+  sideKnowledge: true
+  stage: 8
+  actionPrototypes:
+  - ActionHereticVoidPull
+
+- type: hereticKnowledge
+  id: AscensionVoid
+  stage: 9
+  path: Void
+  ritualPrototypes:
+  - AscensionVoid
+
+- type: hereticKnowledge
+  id: WaltzAtTheEndOfTime
+  stage: 10
+  path: Void
+  event: !type:HereticAscensionVoidEvent
+
+### side paths
+- type: hereticKnowledge
+  id: RitualOfKnowledge
+  sideKnowledge: true
+  ritualPrototypes:
+  - RitualOfKnowledge
+
+## stage 3
+- type: hereticKnowledge
+  id: ArmorerRitual
+  sideKnowledge: true
+  stage: 3
+  ritualPrototypes:
+  - ArmorerRitual  
+
+- type: hereticKnowledge
+  id: PriestRitual
+  sideKnowledge: true
+  stage: 3
+  ritualPrototypes:
+  - PriestRitual
+
+## stage 7
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Heretic/heretic_rituals.yml b/Resources/Prototypes/_Goobstation/Heretic/Heretic/heretic_rituals.yml
new file mode 100644
index 0000000000000..79dc8d5239912
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Heretic/heretic_rituals.yml
@@ -0,0 +1,266 @@
+### basic
+# Heartbeat of the Mansus (sacrifice)
+- type: hereticRitual
+  id: Sacrifice
+  locName: heretic-ritual-basic-sacrifice
+  locDesc: heretic-ritual-basic-sacrifice-desc
+  icon:
+    sprite: Mobs/Species/Human/organs.rsi
+    state: heart-on
+  customBehaviors:
+  - !type:RitualSacrificeBehavior
+    onlyTargets: true
+
+- type: hereticRitual
+  id: AmberFocus
+  locName: heretic-ritual-basic-focus
+  locDesc: heretic-ritual-basic-focus-desc
+  icon:
+    sprite: _Goobstation/Heretic/amber_focus.rsi
+    state: icon
+  requiredTags:
+    GlassShard: 1
+    Eyes: 1
+  output:
+    ClothingNeckAmberFocus: 1
+
+- type: hereticRitual
+  id: CodexCicatrix
+  locName: heretic-ritual-basic-codex
+  locDesc: heretic-ritual-basic-codex-desc
+  icon:
+    sprite: _Goobstation/Heretic/book.rsi
+    state: icon-on
+  requiredTags:
+    Heart: 1
+    Book: 1
+    Write: 1
+  output:
+    CodexCicatrix: 1
+
+### ash path
+- type: hereticRitual
+  id: BladeAsh
+  locName: knowledge-path-ash-s1-name
+  locDesc: knowledge-path-ash-s1-desc
+  icon:
+    sprite: _Goobstation/Heretic/Blades/blade_ash.rsi
+    state: icon
+  requiredTags:
+    Knife: 1
+    WeldingTool: 1
+  output:
+    HereticBladeAsh: 1
+
+- type: hereticRitual
+  id: MaskOfMadness
+  locName: knowledge-path-ash-s6-name
+  locDesc: knowledge-path-ash-s6-desc
+  icon:
+    sprite: _Goobstation/Heretic/mad_mask.rsi
+    state: icon
+  requiredTags:
+    Mask: 1
+    Candle: 4
+    Stunbaton: 1
+    Liver: 1
+  output:
+    ClothingMaskMadHeretic: 1
+
+- type: hereticRitual
+  id: AscensionAsh
+  locName: knowledge-path-ash-s9-name
+  locDesc: knowledge-path-ash-s9-desc
+  icon:
+    sprite: _Goobstation/Heretic/abilities_heretic.rsi
+    state: ashlord_rite2
+  customBehaviors:
+  - !type:RitualAshAscendBehavior
+    min: 3
+    max: 3
+  outputKnowledge: AshlordRite
+  outputEvent: !type:EventHereticAscension
+
+
+
+### flesh path
+- type: hereticRitual
+  id: BladeFlesh
+  locName: knowledge-path-flesh-s1-name
+  locDesc: knowledge-path-flesh-s1-desc
+  icon:
+    sprite: _Goobstation/Heretic/Blades/blade_flesh.rsi
+    state: icon
+  customBehaviors:
+  - !type:RitualReagentPuddleBehavior
+    reagents:
+    - Blood
+    - GrayBlood #imp
+    - InsectBlood
+    - Slime
+    - Sap
+    - CopperBlood
+    - AmmoniaBlood
+    - ZombieBlood
+    - ShimmeringBlood #imp
+    - BloodKodepiia # imp
+  requiredTags:
+    Knife: 1
+  output:
+    HereticBladeFlesh: 1
+
+- type: hereticRitual
+  id: ImperfectRitual
+  locName: knowledge-path-flesh-s3-name
+  locDesc: knowledge-path-flesh-s3-desc
+  icon:
+    sprite: Mobs/Species/Skeleton/parts.rsi
+    state: full
+  customBehaviors:
+  - !type:RitualMuteGhoulifyBehavior
+  requiredTags:
+    Poppy: 1
+
+- type: hereticRitual
+  id: RawRitual
+  locName: knowledge-path-flesh-s6-name
+  locDesc: knowledge-path-flesh-s6-desc
+  icon:
+    sprite: _Goobstation/Heretic/eldritch_mobs.rsi
+    state: raw_prophet
+  customBehaviors:
+  - !type:RitualReagentPuddleBehavior
+    reagents:
+    - Blood
+    - GrayBlood #imp
+    - InsectBlood
+    - Slime
+    - Sap
+    - CopperBlood
+    - AmmoniaBlood
+    - ZombieBlood
+    - ShimmeringBlood #imp
+    - BloodKodepiia # imp
+  requiredTags:
+    Eyes: 1
+    Stomach: 1
+  output:
+    MobGhoulProphet: 1
+
+- type: hereticRitual
+  id: LonelyRitual
+  locName: knowledge-path-flesh-s8-name
+  locDesc: knowledge-path-flesh-s8-desc
+  icon:
+    sprite: _Goobstation/Heretic/eldritch_mobs.rsi
+    state: stalker
+  customBehaviors:
+  - !type:RitualReagentPuddleBehavior
+    reagents:
+    - Blood
+    - GrayBlood #imp
+    - InsectBlood
+    - Slime
+    - Sap
+    - CopperBlood
+    - AmmoniaBlood
+    - ZombieBlood
+    - ShimmeringBlood #imp
+    - BloodKodepiia # imp
+  requiredTags:
+    Pen: 1
+    Heart: 1
+    Stomach: 1
+    Lungs: 1
+  output:
+    MobGhoulStalker: 1
+
+- type: hereticRitual
+  id: AscensionFlesh
+  locName: knowledge-path-flesh-s9-name
+  locDesc: knowledge-path-flesh-s9-desc
+  icon:
+    sprite: _Goobstation/Heretic/abilities_heretic.rsi
+    state: final_hymn
+  customBehaviors:
+  - !type:RitualSacrificeBehavior
+    min: 4
+    max: 4
+  outputKnowledge: PriestFinalHymn
+  outputEvent: !type:EventHereticAscension
+
+
+
+### void path
+- type: hereticRitual
+  id: BladeVoid
+  locName: knowledge-path-void-s1-name
+  locDesc: knowledge-path-void-s1-desc
+  icon:
+    sprite: _Goobstation/Heretic/Blades/blade_void.rsi
+    state: icon
+  customBehaviors:
+  - !type:RitualTemperatureBehavior
+    minThreshold: 0 # ~= -1 celcius. or sub zero temperatures
+  requiredTags:
+    Knife: 1
+  output:
+    HereticBladeVoid: 1
+
+- type: hereticRitual
+  id: AscensionVoid
+  locName: knowledge-path-void-s9-name
+  locDesc: knowledge-path-void-s9-desc
+  icon:
+    sprite: Interface/Alerts/temperature.rsi
+    state: cold3
+  customBehaviors:
+  - !type:RitualSacrificeBehavior
+    min: 3
+    max: 3
+  - !type:RitualTemperatureBehavior
+    minThreshold: -20
+  outputKnowledge: WaltzAtTheEndOfTime
+  outputEvent: !type:EventHereticAscension
+
+
+
+### side knowledge
+- type: hereticRitual
+  id: RitualOfKnowledge
+  locName: heretic-ritual-side-knowledge
+  locDesc: knowledge-path-side-knowledge-desc
+  icon:
+    sprite: _Goobstation/Heretic/book.rsi
+    state: icon
+  customBehaviors:
+  - !type:RitualKnowledgeBehavior
+
+## stage 3
+- type: hereticRitual
+  id: ArmorerRitual
+  locName: knowledge-path-side-s3-armor-name
+  locDesc: knowledge-path-side-s3-armor-desc
+  icon:
+    sprite: _Goobstation/Heretic/eldritch_armor.rsi
+    state: icon
+  requiredTags:
+    Table: 1
+    GasMask: 1
+  output:
+    ClothingOuterArmorHeretic: 1
+
+- type: hereticRitual
+  id: PriestRitual
+  locName: knowledge-path-side-s3-flask-name
+  locDesc: knowledge-path-side-s3-flask-desc
+  icon:
+    sprite: _Goobstation/Heretic/items.rsi
+    state: eldritch_flask
+  requiredTags:
+    WaterTank: 1
+    GlassShard: 1
+  output:
+    HereticEldritchFlask: 1
+
+## stage 7
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Objectives/heretic.yml b/Resources/Prototypes/_Goobstation/Heretic/Objectives/heretic.yml
new file mode 100644
index 0000000000000..d65e8a8816570
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Objectives/heretic.yml
@@ -0,0 +1,51 @@
+- type: entity
+  abstract: true
+  parent: BaseObjective
+  id: BaseHereticObjective
+  components:
+  - type: Objective
+    difficulty: 1.5
+    issuer: objective-issuer-heretic
+
+- type: entity
+  parent: BaseHereticObjective
+  id: HereticKnowledgeObjective
+  components:
+  - type: Objective
+    icon:
+      sprite: _Goobstation/Heretic/reality_fracture.rsi
+      state: icon_harvested
+  - type: NumberObjective
+    min: 12
+    max: 18
+    title: objective-condition-knowledge-title
+  - type: HereticKnowledgeCondition
+
+- type: entity
+  parent: BaseHereticObjective
+  id: HereticSacrificeObjective
+  components:
+  - type: Objective
+    icon:
+      sprite: _Goobstation/Heretic/Blades/blade_blade.rsi
+      state: icon
+  - type: NumberObjective
+    min: 2
+    max: 4
+    title: objective-condition-sacrifice-title
+  - type: HereticSacrificeCondition
+
+- type: entity
+  parent: BaseHereticObjective
+  id: HereticSacrificeHeadObjective
+  components:
+  - type: Objective
+    icon:
+      sprite: _Goobstation/Heretic/Blades/blade_blade.rsi
+      state: icon
+  - type: NumberObjective
+    min: 1
+    max: 1
+    title: objective-condition-sacrifice-head-title
+  - type: HereticSacrificeCondition
+    isCommand: true
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Polymorphs/polymorphs.yml b/Resources/Prototypes/_Goobstation/Heretic/Polymorphs/polymorphs.yml
new file mode 100644
index 0000000000000..a69a3fcd85d27
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Polymorphs/polymorphs.yml
@@ -0,0 +1,15 @@
+- type: polymorph
+  id: AshJaunt
+  configuration:
+    entity: PolymorphAshJaunt
+    forced: true
+    duration: 5
+
+- type: polymorph
+  id: EldritchHorror
+  configuration:
+    entity: MobHereticFleshAscend
+    transferName: true
+    transferDamage: true
+    revertOnCrit: false
+    revertOnDeath: false
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Roles/Antags/heretic.yml b/Resources/Prototypes/_Goobstation/Heretic/Roles/Antags/heretic.yml
new file mode 100644
index 0000000000000..d920a0f28ea41
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Roles/Antags/heretic.yml
@@ -0,0 +1,15 @@
+- type: antag
+  id: Heretic
+  name: roles-antag-heretic-name
+  antagonist: true
+  playTimeTracker: AntagHeretic
+  setPreference: true
+  objective: roles-antag-heretic-description
+  guides: [ Heretics ]
+
+- type: startingGear
+  id: HereticGear
+  storage:
+    back:
+    - CodexCicatrix
+    - OrganHumanHeart
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Store/categories.yml b/Resources/Prototypes/_Goobstation/Heretic/Store/categories.yml
new file mode 100644
index 0000000000000..254fb62f7bbb6
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Store/categories.yml
@@ -0,0 +1,36 @@
+# heretic
+
+- type: storeCategory
+  id: HereticPathAsh
+  name: store-heretic-path-ash
+  priority: 0
+
+- type: storeCategory
+  id: HereticPathLock
+  name: store-heretic-path-lock
+  priority: 0
+
+- type: storeCategory
+  id: HereticPathFlesh
+  name: store-heretic-path-flesh
+  priority: 0
+
+- type: storeCategory
+  id: HereticPathVoid
+  name: store-heretic-path-void
+  priority: 0
+
+- type: storeCategory
+  id: HereticPathBlade
+  name: store-heretic-path-blade
+  priority: 0
+
+- type: storeCategory
+  id: HereticPathRust
+  name: store-heretic-path-rust
+  priority: 0
+
+- type: storeCategory
+  id: HereticPathSide
+  name: store-heretic-path-side
+  priority: 999 # lowest possible
diff --git a/Resources/Prototypes/_Goobstation/Heretic/Store/currency.yml b/Resources/Prototypes/_Goobstation/Heretic/Store/currency.yml
new file mode 100644
index 0000000000000..6827c82311942
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/Store/currency.yml
@@ -0,0 +1,4 @@
+- type: currency
+  id: KnowledgePoint
+  displayName: store-currency-display-knowledgepoint
+  canWithdraw: false
diff --git a/Resources/Prototypes/_Goobstation/Heretic/ai_factions.yml b/Resources/Prototypes/_Goobstation/Heretic/ai_factions.yml
new file mode 100644
index 0000000000000..60a1d02e65656
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/ai_factions.yml
@@ -0,0 +1,9 @@
+- type: npcFaction
+  id: Heretic
+  hostile:
+  - NanoTrasen
+  - Syndicate
+  - Zombie
+  - Revolutionary
+  - Changeling
+  - Dino
\ No newline at end of file
diff --git a/Resources/Prototypes/_Goobstation/Heretic/radio_channels.yml b/Resources/Prototypes/_Goobstation/Heretic/radio_channels.yml
new file mode 100644
index 0000000000000..1ce51f47345e6
--- /dev/null
+++ b/Resources/Prototypes/_Goobstation/Heretic/radio_channels.yml
@@ -0,0 +1,7 @@
+- type: radioChannel
+  id: Mansus
+  name: chat-radio-mansus
+  keycode: 'z'
+  frequency: 80085
+  color: "#237500"
+  longRange: true
\ No newline at end of file
diff --git a/Resources/Prototypes/_Impstation/Heretic/Entities/Objects/Specific/heretic.yml b/Resources/Prototypes/_Impstation/Heretic/Entities/Objects/Specific/heretic.yml
new file mode 100644
index 0000000000000..e6dd374ced4f5
--- /dev/null
+++ b/Resources/Prototypes/_Impstation/Heretic/Entities/Objects/Specific/heretic.yml
@@ -0,0 +1,58 @@
+- type: entity
+  parent: BaseItem
+  id: EldritchTome
+  name: eldritch tome
+  description: A strange book with some kind of ritualistic rune emblazoned on the front.
+  components:
+  - type: Sprite
+    sprite: _Impstation/Heretic/eldritch_book.rsi
+    layers:
+    - state: eldritch-book-base1
+      map : [ "cover" ]
+    - state: eldritch-book-icon1
+      map : [ "icon" ]
+  - type: RandomSprite
+    available:
+      - cover:
+          eldritch-book-base1: ""
+          eldritch-book-base2: ""
+          eldritch-book-base3: ""
+          eldritch-book-base4: ""
+          eldritch-book-base5: ""
+          eldritch-book-base6: ""
+          eldritch-book-base7: ""
+          eldritch-book-base8: ""
+        icon:
+          eldritch-book-icon1: ""
+          eldritch-book-icon2: ""
+          eldritch-book-icon3: ""
+          eldritch-book-icon4: ""
+          eldritch-book-icon5: ""
+          eldritch-book-icon6: ""          
+  - type: HereticKnowledgeItem
+  - type: PointLight
+    radius: 1.5
+    energy: 0.5
+    color: "#6e7500"
+  - type: Tag
+    tags:
+      - Book
+    
+- type: entity
+  id: RealityTear
+  name: reality tear
+  description: It hurts your head to look at. 
+  components:
+  - type: TimedDespawn
+    lifetime: 1
+  - type: SpawnOnDespawn
+    prototype: EldritchTome
+  - type: PointLight
+    radius: 3
+    energy: 2.5
+    color: "#6e7500"
+  - type: InteractionOutline
+  - type: Sprite
+    sprite: _Goobstation/Heretic/reality_fracture.rsi
+    state: icon_harvested
+  - type: Clickable
\ No newline at end of file