diff --git a/Content.Client/ADT/AshWalker/UI/ADTNecropolisCompassBoundUserInterface.cs b/Content.Client/ADT/AshWalker/UI/ADTNecropolisCompassBoundUserInterface.cs
new file mode 100644
index 00000000000..715bb632d6d
--- /dev/null
+++ b/Content.Client/ADT/AshWalker/UI/ADTNecropolisCompassBoundUserInterface.cs
@@ -0,0 +1,41 @@
+using Content.Client.ADT.UI;
+using Content.Shared.ADT.AshWalker;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.ADT.AshWalker.UI;
+
+public sealed class ADTNecropolisCompassBoundUserInterface : BoundUserInterface
+{
+    private ADTEntityPickerWindow? _window;
+
+    public ADTNecropolisCompassBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<ADTEntityPickerWindow>();
+        _window.SetText(
+            Loc.GetString("adt-necropolis-compass-window-title"),
+            Loc.GetString("adt-necropolis-compass-window-hint"));
+        _window.OnEntrySelected += OnPointSelected;
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not ADTNecropolisCompassBuiState compassState)
+            return;
+
+        _window.SetEntries(compassState.Points);
+    }
+
+    private void OnPointSelected(NetEntity point)
+    {
+        SendMessage(new ADTNecropolisCompassSelectMessage(point));
+        Close();
+    }
+}
diff --git a/Content.Client/ADT/Rituals/ADTAshRuneMarkSystem.cs b/Content.Client/ADT/Rituals/ADTAshRuneMarkSystem.cs
new file mode 100644
index 00000000000..76ea33a4e8e
--- /dev/null
+++ b/Content.Client/ADT/Rituals/ADTAshRuneMarkSystem.cs
@@ -0,0 +1,35 @@
+using Content.Shared.ADT.Rituals;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.ADT.Rituals;
+
+public sealed class ADTAshRuneMarkSystem : EntitySystem
+{
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTAshRuneMarkComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<ADTAshRuneMarkComponent, AfterAutoHandleStateEvent>(OnState);
+    }
+
+    private void OnStartup(Entity<ADTAshRuneMarkComponent> ent, ref ComponentStartup args)
+    {
+        UpdateVisible(ent);
+    }
+
+    private void OnState(Entity<ADTAshRuneMarkComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        UpdateVisible(ent);
+    }
+
+    private void UpdateVisible(Entity<ADTAshRuneMarkComponent> ent)
+    {
+        if (!TryComp<SpriteComponent>(ent.Owner, out var sprite))
+            return;
+
+        _sprite.SetVisible((ent.Owner, sprite), ent.Comp.Lit);
+    }
+}
diff --git a/Content.Client/ADT/Rituals/UI/ADTRitualBoundUserInterface.cs b/Content.Client/ADT/Rituals/UI/ADTRitualBoundUserInterface.cs
new file mode 100644
index 00000000000..168164f8cd8
--- /dev/null
+++ b/Content.Client/ADT/Rituals/UI/ADTRitualBoundUserInterface.cs
@@ -0,0 +1,31 @@
+using Content.Shared.ADT.Rituals;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.ADT.Rituals.UI;
+
+public sealed class ADTRitualBoundUserInterface : BoundUserInterface
+{
+    private ADTRitualMenuWindow? _window;
+
+    public ADTRitualBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<ADTRitualMenuWindow>();
+        _window.OnStartPressed += ritual => SendMessage(new ADTRitualStartMessage(ritual));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not ADTRitualBuiState ritualState)
+            return;
+
+        _window.SetState(ritualState);
+    }
+}
diff --git a/Content.Client/ADT/Rituals/UI/ADTRitualMenuWindow.xaml b/Content.Client/ADT/Rituals/UI/ADTRitualMenuWindow.xaml
new file mode 100644
index 00000000000..6730163c274
--- /dev/null
+++ b/Content.Client/ADT/Rituals/UI/ADTRitualMenuWindow.xaml
@@ -0,0 +1,57 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      Title="{Loc 'adt-ritual-window-title'}"
+                      MinSize="780 520"
+                      SetSize="840 620">
+    <BoxContainer Orientation="Horizontal" Margin="8 8 8 8" HorizontalExpand="True" SeparationOverride="8">
+        <BoxContainer Orientation="Vertical" MinWidth="230" SeparationOverride="4">
+            <Label Text="{Loc 'adt-ritual-window-list'}" StyleClasses="LabelKeyText" />
+            <PanelContainer StyleClasses="PanelDark" VerticalExpand="True">
+                <ScrollContainer VerticalExpand="True" HScrollEnabled="False" Margin="4 4 4 4">
+                    <BoxContainer Name="RitualList" Orientation="Vertical" HorizontalExpand="True" />
+                </ScrollContainer>
+            </PanelContainer>
+        </BoxContainer>
+        <BoxContainer Orientation="Vertical" HorizontalExpand="True" SeparationOverride="4">
+            <Label Name="RitualName" StyleClasses="LabelHeadingBigger" />
+            <PanelContainer StyleClasses="LowDivider" HorizontalExpand="True" SetHeight="2" Margin="0 0 0 4" />
+
+            <ScrollContainer VerticalExpand="True" HScrollEnabled="False">
+                <BoxContainer Orientation="Vertical" HorizontalExpand="True" SeparationOverride="8">
+
+                    <PanelContainer Name="DescriptionPanel" StyleClasses="BackgroundPanelDark">
+                        <RichTextLabel Name="RitualDescription" Margin="8 8 8 8" />
+                    </PanelContainer>
+
+                    <BoxContainer Name="RequirementsBlock" Orientation="Vertical" HorizontalExpand="True">
+                        <Label Text="{Loc 'adt-ritual-window-requirements'}" StyleClasses="LabelKeyText" />
+                        <PanelContainer StyleClasses="PanelDark" HorizontalExpand="True">
+                            <BoxContainer Name="RequirementList" Orientation="Vertical" HorizontalExpand="True" Margin="8 6 8 6" />
+                        </PanelContainer>
+                    </BoxContainer>
+
+                    <BoxContainer Name="PriceBlock" Orientation="Vertical" HorizontalExpand="True">
+                        <Label Text="{Loc 'adt-ritual-window-price'}" StyleClasses="LabelKeyText" />
+                        <PanelContainer StyleClasses="PanelDark" HorizontalExpand="True">
+                            <BoxContainer Name="PriceList" Orientation="Vertical" HorizontalExpand="True" Margin="8 6 8 6" />
+                        </PanelContainer>
+                    </BoxContainer>
+
+                    <BoxContainer Name="RiskBlock" Orientation="Vertical" HorizontalExpand="True">
+                        <Label Text="{Loc 'adt-ritual-window-risk'}" StyleClasses="LabelKeyText" />
+                        <PanelContainer StyleClasses="PanelDark" HorizontalExpand="True">
+                            <BoxContainer Name="RiskList" Orientation="Vertical" HorizontalExpand="True" Margin="8 6 8 6" />
+                        </PanelContainer>
+                    </BoxContainer>
+
+                </BoxContainer>
+            </ScrollContainer>
+
+            <PanelContainer StyleClasses="LowDivider" HorizontalExpand="True" SetHeight="2" Margin="0 6 0 6" />
+            <Button Name="StartButton"
+                    Text="{Loc 'adt-ritual-window-start'}"
+                    StyleClasses="ButtonBig"
+                    Disabled="True" />
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/ADT/Rituals/UI/ADTRitualMenuWindow.xaml.cs b/Content.Client/ADT/Rituals/UI/ADTRitualMenuWindow.xaml.cs
new file mode 100644
index 00000000000..0afd965e624
--- /dev/null
+++ b/Content.Client/ADT/Rituals/UI/ADTRitualMenuWindow.xaml.cs
@@ -0,0 +1,286 @@
+using System.Linq;
+using Content.Client.UserInterface.Controls;
+using Content.Client.Stylesheets.Palette;
+using Content.Shared.ADT.Rituals;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Client.ADT.Rituals.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ADTRitualMenuWindow : FancyWindow
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+
+    public event Action<ProtoId<ADTRitualPrototype>>? OnStartPressed;
+
+    private List<ADTRitualEntry> _entries = new();
+    private ProtoId<ADTRitualPrototype>? _selected;
+    private bool _busy;
+
+    private readonly Dictionary<ProtoId<ADTRitualPrototype>, Button> _cooldownButtons = new();
+
+    private int _lastShownSecond = -1;
+
+    public ADTRitualMenuWindow()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        StartButton.OnPressed += _ =>
+        {
+            if (_selected is { } selected)
+                OnStartPressed?.Invoke(selected);
+        };
+    }
+
+    public void SetState(ADTRitualBuiState state)
+    {
+        _entries = state.Rituals;
+        _busy = state.Busy;
+
+        if (_selected != null && _entries.All(e => e.Ritual != _selected))
+            _selected = null;
+
+        BuildList();
+        BuildDetails();
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        var second = (int)_timing.CurTime.TotalSeconds;
+        if (second == _lastShownSecond)
+            return;
+
+        _lastShownSecond = second;
+        RefreshCountdowns();
+    }
+
+    private void RefreshCountdowns()
+    {
+        var now = _timing.CurTime;
+
+        foreach (var (ritual, button) in _cooldownButtons)
+        {
+            var entry = _entries.FirstOrDefault(e => e.Ritual == ritual);
+            button.Text = EntryLabel(entry, now);
+            button.Modulate = entry.Available(now) ? Color.White : Color.FromHex("#8a8a8a");
+        }
+
+        if (_selected is { } selected && _entries.Any(e => e.Ritual == selected))
+        {
+            var entry = _entries.First(e => e.Ritual == selected);
+            StartButton.Disabled = _busy || !entry.Available(now);
+            StartButton.Text = StartLabel(entry, now);
+        }
+    }
+
+    private string EntryLabel(ADTRitualEntry entry, TimeSpan now)
+    {
+        if (!_proto.TryIndex(entry.Ritual, out var proto))
+            return string.Empty;
+
+        var name = Loc.GetString(proto.Name);
+        var left = entry.CooldownLeft(now);
+
+        if (left > 0)
+            return Loc.GetString("adt-ritual-window-entry-cooldown", ("name", name), ("seconds", left));
+
+        if (entry.Charges == 0)
+            return Loc.GetString("adt-ritual-window-entry-spent", ("name", name));
+
+        if (entry.Charges > 0)
+            return Loc.GetString("adt-ritual-window-entry-charges", ("name", name), ("charges", entry.Charges));
+
+        return name;
+    }
+
+    private string StartLabel(ADTRitualEntry entry, TimeSpan now)
+    {
+        var left = entry.CooldownLeft(now);
+
+        if (left > 0)
+            return Loc.GetString("adt-ritual-window-wait", ("seconds", left));
+
+        if (entry.Charges == 0)
+            return Loc.GetString("adt-ritual-window-spent");
+
+        return Loc.GetString("adt-ritual-window-start");
+    }
+
+    private void BuildList()
+    {
+        RitualList.RemoveAllChildren();
+        _cooldownButtons.Clear();
+
+        var now = _timing.CurTime;
+
+        foreach (var entry in _entries)
+        {
+            if (!_proto.TryIndex(entry.Ritual, out _))
+                continue;
+
+            var button = new Button
+            {
+                Text = EntryLabel(entry, now),
+                HorizontalExpand = true,
+                Margin = new Thickness(0, 0, 0, 2),
+                MinHeight = 28,
+                ToggleMode = true,
+                Pressed = _selected == entry.Ritual,
+            };
+
+            button.Modulate = entry.Available(now) ? Color.White : Color.FromHex("#8a8a8a");
+
+            var ritual = entry.Ritual;
+            button.OnPressed += _ =>
+            {
+                _selected = ritual;
+                BuildList();
+                BuildDetails();
+            };
+
+            RitualList.AddChild(button);
+            _cooldownButtons[ritual] = button;
+        }
+    }
+
+    private void BuildDetails()
+    {
+        RequirementList.RemoveAllChildren();
+        PriceList.RemoveAllChildren();
+        RiskList.RemoveAllChildren();
+
+        if (_selected is not { } selected || !_proto.TryIndex(selected, out var proto))
+        {
+            RitualName.Text = Loc.GetString("adt-ritual-window-none");
+            RitualDescription.SetMessage(string.Empty);
+            SetDetailsVisible(false);
+            StartButton.Disabled = true;
+            StartButton.Text = Loc.GetString("adt-ritual-window-start");
+            return;
+        }
+
+        SetDetailsVisible(true);
+
+        var now = _timing.CurTime;
+        var entry = _entries.FirstOrDefault(e => e.Ritual == selected, new ADTRitualEntry(selected, proto.Charges, TimeSpan.Zero));
+
+        RitualName.Text = Loc.GetString(proto.Name);
+        RitualDescription.SetMessage(proto.Description == null ? string.Empty : Loc.GetString(proto.Description));
+
+        BuildRequirements(proto);
+        BuildPrice(proto, entry);
+        BuildRisk(proto);
+
+        StartButton.Disabled = _busy || !entry.Available(now);
+        StartButton.Text = StartLabel(entry, now);
+    }
+
+    private void SetDetailsVisible(bool visible)
+    {
+        DescriptionPanel.Visible = visible;
+        RequirementsBlock.Visible = visible;
+        PriceBlock.Visible = visible;
+        RiskBlock.Visible = visible;
+    }
+
+    private void BuildRequirements(ADTRitualPrototype proto)
+    {
+        AddLine(RequirementList, Loc.GetString("adt-ritual-req-invokers", ("total", proto.ExtraInvokers + 1)));
+
+        if (proto.ShamanOnly)
+            AddLine(RequirementList, Loc.GetString("adt-ritual-req-shaman"));
+
+        if (proto.NeededDye != null && proto.DyeFluff != null)
+            AddLine(RequirementList, Loc.GetString("adt-ritual-req-dye", ("dye", Loc.GetString(proto.DyeFluff))));
+
+        if (proto.RequiredThings.Count > 0)
+            AddLine(RequirementList, Loc.GetString("adt-ritual-req-things", ("things", ThingList(proto))));
+
+        if (proto.RequiredThings.Count == 0 && proto.NeededDye == null)
+            AddLine(RequirementList, Loc.GetString("adt-ritual-req-nothing"));
+    }
+
+    private static string ThingList(ADTRitualPrototype proto)
+    {
+        var names = proto.RequiredThings.Select(thing => thing.Amount > 1
+            ? Loc.GetString("adt-ritual-req-thing-amount", ("name", Loc.GetString(thing.Name)), ("amount", thing.Amount))
+            : Loc.GetString(thing.Name));
+
+        return string.Join(", ", names);
+    }
+
+    private void BuildPrice(ADTRitualPrototype proto, ADTRitualEntry entry)
+    {
+        if (proto.CastTime > TimeSpan.Zero)
+        {
+            var total = (int)proto.CastTime.TotalSeconds * (proto.ExtraInvokers + 1);
+
+            AddLine(PriceList, Loc.GetString("adt-ritual-price-cast", ("seconds", total)));
+        }
+
+        AddLine(PriceList, Loc.GetString("adt-ritual-price-cooldown", ("seconds", (int)proto.Cooldown.TotalSeconds)));
+
+        if (proto.Charges != -1)
+            AddLine(PriceList, Loc.GetString("adt-ritual-price-charges", ("left", entry.Charges)));
+
+        var eaten = proto.RequiredThings.Where(t => t.Consume).ToList();
+
+        if (eaten.Count > 0 && proto.DeleteThingsOnSuccess)
+        {
+            AddLine(PriceList, Loc.GetString("adt-ritual-price-consumes",
+                ("things", string.Join(", ", eaten.Select(t => Loc.GetString(t.Name))))));
+        }
+        else if (proto.RequiredThings.Count > 0)
+        {
+            AddLine(PriceList, Loc.GetString("adt-ritual-price-consumes-nothing"));
+        }
+    }
+
+    private void BuildRisk(ADTRitualPrototype proto)
+    {
+        var fail = (int)MathF.Round(proto.FailChance * 100);
+        var disaster = (int)MathF.Round(proto.DisasterChance * 100);
+
+        AddLine(
+            RiskList,
+            Loc.GetString("adt-ritual-risk", ("fail", fail), ("disaster", disaster)),
+            RiskColor(fail));
+
+        if (proto.DeleteThingsOnFail)
+            AddLine(RiskList, Loc.GetString("adt-ritual-risk-loses-things"), Palettes.Status.Bad);
+
+        if (proto.Modifiers.Count > 0)
+            AddLine(RiskList, Loc.GetString("adt-ritual-risk-conditional"), Palettes.Status.Okay);
+    }
+
+    private static Color RiskColor(int percent)
+    {
+        return percent switch
+        {
+            <= 15 => Palettes.Status.Good,
+            <= 40 => Palettes.Status.Warning,
+            _ => Palettes.Status.Bad,
+        };
+    }
+
+    private static void AddLine(BoxContainer container, string text, Color? color = null)
+    {
+        var label = new RichTextLabel
+        {
+            HorizontalExpand = true,
+            Margin = new Thickness(0, 0, 0, 2),
+        };
+
+        label.SetMessage(text, defaultColor: color);
+        container.AddChild(label);
+    }
+}
diff --git a/Content.Client/ADT/Rituals/UI/ADTRitualSummonBoundUserInterface.cs b/Content.Client/ADT/Rituals/UI/ADTRitualSummonBoundUserInterface.cs
new file mode 100644
index 00000000000..b2bce8e87d4
--- /dev/null
+++ b/Content.Client/ADT/Rituals/UI/ADTRitualSummonBoundUserInterface.cs
@@ -0,0 +1,41 @@
+using Content.Client.ADT.UI;
+using Content.Shared.ADT.Rituals;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.ADT.Rituals.UI;
+
+public sealed class ADTRitualSummonBoundUserInterface : BoundUserInterface
+{
+    private ADTEntityPickerWindow? _window;
+
+    public ADTRitualSummonBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<ADTEntityPickerWindow>();
+        _window.SetText(
+            Loc.GetString("adt-ritual-summon-window-title"),
+            Loc.GetString("adt-ritual-summon-window-hint"));
+        _window.OnEntrySelected += OnSelected;
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_window == null || state is not ADTRitualSummonBuiState summonState)
+            return;
+
+        _window.SetEntries(summonState.Candidates);
+    }
+
+    private void OnSelected(NetEntity target)
+    {
+        SendMessage(new ADTRitualSummonSelectMessage(target));
+        Close();
+    }
+}
diff --git a/Content.Client/ADT/UI/ADTEntityPickerWindow.xaml b/Content.Client/ADT/UI/ADTEntityPickerWindow.xaml
new file mode 100644
index 00000000000..9a43ca86573
--- /dev/null
+++ b/Content.Client/ADT/UI/ADTEntityPickerWindow.xaml
@@ -0,0 +1,11 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      MinSize="280 200"
+                      SetSize="280 320">
+    <BoxContainer Orientation="Vertical" Margin="6 6 6 6">
+        <Label Name="Hint" />
+        <ScrollContainer VerticalExpand="True" HScrollEnabled="False">
+            <BoxContainer Name="EntryList" Orientation="Vertical" HorizontalExpand="True" />
+        </ScrollContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/ADT/UI/ADTEntityPickerWindow.xaml.cs b/Content.Client/ADT/UI/ADTEntityPickerWindow.xaml.cs
new file mode 100644
index 00000000000..e189e443b73
--- /dev/null
+++ b/Content.Client/ADT/UI/ADTEntityPickerWindow.xaml.cs
@@ -0,0 +1,81 @@
+using System.Numerics;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.ADT.UI;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.ADT.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ADTEntityPickerWindow : FancyWindow
+{
+    public event Action<NetEntity>? OnEntrySelected;
+
+    public ADTEntityPickerWindow()
+    {
+        RobustXamlLoader.Load(this);
+    }
+
+    public void SetText(string title, string hint)
+    {
+        Title = title;
+        Hint.Text = hint;
+    }
+
+    public void SetEntries(List<ADTEntityPickerEntry> entries)
+    {
+        EntryList.RemoveAllChildren();
+
+        foreach (var entry in entries)
+        {
+            EntryList.AddChild(BuildRow(entry));
+        }
+    }
+
+    private Control BuildRow(ADTEntityPickerEntry entry)
+    {
+        var button = new Button
+        {
+            HorizontalExpand = true,
+            Margin = new Thickness(0, 0, 0, 4),
+            MinHeight = 40,
+        };
+
+        var row = new BoxContainer
+        {
+            Orientation = BoxContainer.LayoutOrientation.Horizontal,
+            HorizontalExpand = true,
+            VerticalAlignment = VAlignment.Center,
+            // Let the click through to the button underneath.
+            MouseFilter = MouseFilterMode.Ignore,
+        };
+
+        if (entry.Proto is { } proto)
+        {
+            var view = new EntityPrototypeView
+            {
+                SetSize = new Vector2(32, 32),
+                Stretch = SpriteView.StretchMode.Fill,
+                VerticalAlignment = VAlignment.Center,
+                Margin = new Thickness(0, 0, 6, 0),
+            };
+            view.SetPrototype(proto);
+            row.AddChild(view);
+        }
+
+        row.AddChild(new Label
+        {
+            Text = entry.Name,
+            VerticalAlignment = VAlignment.Center,
+        });
+
+        button.AddChild(row);
+
+        var target = entry.Entity;
+        button.OnPressed += _ => OnEntrySelected?.Invoke(target);
+
+        return button;
+    }
+}
diff --git a/Content.Server/ADT/AshWalker/ADTAshWalkerNestSystem.cs b/Content.Server/ADT/AshWalker/ADTAshWalkerNestSystem.cs
new file mode 100644
index 00000000000..c5654c3aa3e
--- /dev/null
+++ b/Content.Server/ADT/AshWalker/ADTAshWalkerNestSystem.cs
@@ -0,0 +1,149 @@
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.ADT.Salvage.Components;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Components;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Gibbing;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.ADT.AshWalker;
+
+public sealed class ADTAshWalkerNestSystem : EntitySystem
+{
+    [Dependency] private readonly DamageableSystem _damageable = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly GibbingSystem _gibbing = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly MobStateSystem _mobState = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    private static readonly SoundSpecifier ConsumeSound = new SoundPathSpecifier("/Audio/Effects/demon_consume.ogg");
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTAshWalkerNestComponent, MapInitEvent>(OnMapInit);
+    }
+
+    private void OnMapInit(Entity<ADTAshWalkerNestComponent> ent, ref MapInitEvent args)
+    {
+        ent.Comp.NextUpdate = _timing.CurTime + ent.Comp.Interval;
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var now = _timing.CurTime;
+        var query = EntityQueryEnumerator<ADTAshWalkerNestComponent>();
+
+        while (query.MoveNext(out var uid, out var nest))
+        {
+            if (now < nest.NextUpdate)
+                continue;
+
+            nest.NextUpdate = now + nest.Interval;
+
+            Consume((uid, nest));
+            SpawnEgg((uid, nest));
+            Heal((uid, nest));
+        }
+    }
+
+    private void Consume(Entity<ADTAshWalkerNestComponent> ent)
+    {
+        var bodies = new HashSet<Entity<MobStateComponent>>();
+        _lookup.GetEntitiesInRange(Transform(ent.Owner).Coordinates, ent.Comp.ConsumeRange, bodies);
+
+        foreach (var body in bodies)
+        {
+            if (!_mobState.IsIncapacitated(body.Owner, body.Comp))
+                continue;
+
+            _popup.PopupEntity(
+                Loc.GetString("adt-ash-walker-nest-consume", ("target", body.Owner)),
+                ent.Owner,
+                PopupType.MediumCaution);
+            _audio.PlayPvs(ConsumeSound, ent.Owner);
+
+            ent.Comp.MeatCounter += HasComp<MegafaunaComponent>(body.Owner)
+                ? ent.Comp.MeatPerMegafauna
+                : ent.Comp.MeatPerBody;
+
+            _gibbing.Gib(body.Owner);
+
+            Repair(ent);
+        }
+    }
+
+    private void SpawnEgg(Entity<ADTAshWalkerNestComponent> ent)
+    {
+        if (ent.Comp.MeatCounter < ent.Comp.MeatPerEgg)
+            return;
+
+        var proto = NeedsShaman() ? ent.Comp.ShamanEgg : ent.Comp.Egg;
+        var dir = (Direction)_random.Next(8);
+        var coords = Transform(ent.Owner).Coordinates.Offset(dir.ToIntVec());
+
+        Spawn(proto, coords);
+
+        _popup.PopupEntity(Loc.GetString("adt-ash-walker-nest-egg"), ent.Owner, PopupType.LargeCaution);
+        ent.Comp.MeatCounter -= ent.Comp.MeatPerEgg;
+    }
+
+    private bool NeedsShaman()
+    {
+        var shamans = EntityQueryEnumerator<ADTAshWalkerComponent, MobStateComponent>();
+        while (shamans.MoveNext(out var uid, out var walker, out var state))
+        {
+            if (walker.Shaman && !_mobState.IsDead(uid, state))
+                return false;
+        }
+
+        var eggs = EntityQueryEnumerator<ADTAshWalkerEggComponent>();
+        while (eggs.MoveNext(out _, out var egg))
+        {
+            if (egg.Shaman)
+                return false;
+        }
+
+        return true;
+    }
+
+    private void Heal(Entity<ADTAshWalkerNestComponent> ent)
+    {
+        if (ent.Comp.AuraHealing.Empty)
+            return;
+
+        var tribe = new HashSet<Entity<ADTAshWalkerComponent>>();
+        _lookup.GetEntitiesInRange(Transform(ent.Owner).Coordinates, ent.Comp.HealRange, tribe);
+
+        foreach (var walker in tribe)
+        {
+            if (_mobState.IsDead(walker.Owner))
+                continue;
+
+            _damageable.TryChangeDamage(walker.Owner, ent.Comp.AuraHealing, true, origin: ent.Owner);
+        }
+    }
+
+    private void Repair(Entity<ADTAshWalkerNestComponent> ent)
+    {
+        if (!TryComp<DamageableComponent>(ent.Owner, out var damageable) || _damageable.GetTotalDamage((ent.Owner, damageable)) <= 0)
+            return;
+
+        var scale = Math.Min(1f, ent.Comp.SelfRepair.Float() / _damageable.GetTotalDamage((ent.Owner, damageable)).Float());
+        var heal = damageable.Damage * -scale;
+
+        _damageable.TryChangeDamage(ent.Owner, heal, true);
+    }
+}
diff --git a/Content.Server/ADT/AshWalker/ADTHealTouchSystem.cs b/Content.Server/ADT/AshWalker/ADTHealTouchSystem.cs
new file mode 100644
index 00000000000..8e2bfb927af
--- /dev/null
+++ b/Content.Server/ADT/AshWalker/ADTHealTouchSystem.cs
@@ -0,0 +1,76 @@
+using Content.Shared.ADT.AshWalker;
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.Actions;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Components;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+
+namespace Content.Server.ADT.AshWalker;
+
+public sealed class ADTHealTouchSystem : EntitySystem
+{
+    [Dependency] private readonly DamageableSystem _damageable = default!;
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    private static readonly SoundSpecifier TouchSound = new SoundPathSpecifier("/Audio/Magic/staff_healing.ogg");
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTHealTouchComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ADTHealTouchComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ADTHealTouchComponent, ADTHealTouchActionEvent>(OnHealTouch);
+    }
+
+    private void OnMapInit(Entity<ADTHealTouchComponent> ent, ref MapInitEvent args)
+    {
+        _actions.AddAction(ent.Owner, ref ent.Comp.ActionEntity, ent.Comp.ActionId);
+    }
+
+    private void OnShutdown(Entity<ADTHealTouchComponent> ent, ref ComponentShutdown args)
+    {
+        _actions.RemoveAction(ent.Comp.ActionEntity);
+    }
+
+    private void OnHealTouch(Entity<ADTHealTouchComponent> ent, ref ADTHealTouchActionEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        var target = args.Target;
+
+        if (target == ent.Owner && !ent.Comp.CanHealSelf)
+        {
+            _popup.PopupEntity(Loc.GetString("adt-heal-touch-not-self"), ent.Owner, ent.Owner);
+            return;
+        }
+
+        var used = new ADTHealTouchUsedEvent(ent.Owner);
+        RaiseLocalEvent(target, ref used);
+
+        if (used.Handled)
+        {
+            _audio.PlayPvs(TouchSound, target);
+            args.Handled = true;
+            return;
+        }
+
+        if (!HasComp<MobStateComponent>(target) || !HasComp<DamageableComponent>(target))
+        {
+            _popup.PopupEntity(Loc.GetString("adt-heal-touch-no-target"), ent.Owner, ent.Owner);
+            return;
+        }
+
+        _damageable.TryChangeDamage(target, ent.Comp.Healing, true, origin: ent.Owner);
+        _audio.PlayPvs(TouchSound, target);
+        _popup.PopupEntity(Loc.GetString("adt-heal-touch-success", ("target", target)), ent.Owner, ent.Owner);
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/ADT/AshWalker/ADTIgniteSystem.cs b/Content.Server/ADT/AshWalker/ADTIgniteSystem.cs
new file mode 100644
index 00000000000..ebe5cb3c649
--- /dev/null
+++ b/Content.Server/ADT/AshWalker/ADTIgniteSystem.cs
@@ -0,0 +1,77 @@
+using Content.Shared.ADT.AshWalker;
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.Actions;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.IgnitionSource.Components;
+using Content.Shared.IgnitionSource.EntitySystems;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Inventory;
+using Content.Shared.Nutrition;
+using Content.Shared.Popups;
+
+namespace Content.Server.ADT.AshWalker;
+
+public sealed class ADTIgniteSystem : EntitySystem
+{
+    [Dependency] private readonly MatchstickSystem _matchstick = default!;
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
+    [Dependency] private readonly SharedHandsSystem _hands = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    private const SlotFlags MouthSlots = SlotFlags.HEAD | SlotFlags.MASK;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTIgniteComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ADTIgniteComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ADTIgniteComponent, ADTIgniteActionEvent>(OnIgnite);
+        SubscribeLocalEvent<ADTSmallBlazeComponent, DroppedEvent>(OnBlazeDropped);
+    }
+
+    private void OnBlazeDropped(Entity<ADTSmallBlazeComponent> ent, ref DroppedEvent args)
+    {
+        QueueDel(ent.Owner);
+    }
+
+    private void OnMapInit(Entity<ADTIgniteComponent> ent, ref MapInitEvent args)
+    {
+        _actions.AddAction(ent.Owner, ref ent.Comp.ActionEntity, ent.Comp.ActionId);
+    }
+
+    private void OnShutdown(Entity<ADTIgniteComponent> ent, ref ComponentShutdown args)
+    {
+        _actions.RemoveAction(ent.Comp.ActionEntity);
+    }
+
+    private void OnIgnite(Entity<ADTIgniteComponent> ent, ref ADTIgniteActionEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        var attempt = new IngestionAttemptEvent(MouthSlots);
+        RaiseLocalEvent(ent.Owner, ref attempt);
+
+        if (attempt.Cancelled)
+        {
+            _popup.PopupEntity(Loc.GetString("adt-ash-walker-ignite-maw-covered"), ent.Owner, ent.Owner);
+            return;
+        }
+
+        var blaze = SpawnAtPosition(ent.Comp.Blaze, Transform(ent.Owner).Coordinates);
+
+        if (TryComp<MatchstickComponent>(blaze, out var matchstick))
+            _matchstick.TryIgnite((blaze, matchstick), ent.Owner);
+
+        if (!_hands.TryPickupAnyHand(ent.Owner, blaze))
+        {
+            QueueDel(blaze);
+            _popup.PopupEntity(Loc.GetString("adt-ash-walker-ignite-hands-full"), ent.Owner, ent.Owner);
+            return;
+        }
+
+        _popup.PopupEntity(Loc.GetString("adt-ash-walker-ignite-success"), ent.Owner, ent.Owner);
+        args.Handled = true;
+    }
+}
diff --git a/Content.Server/ADT/AshWalker/ADTNecropolisCompassSystem.cs b/Content.Server/ADT/AshWalker/ADTNecropolisCompassSystem.cs
new file mode 100644
index 00000000000..9418d67b6b6
--- /dev/null
+++ b/Content.Server/ADT/AshWalker/ADTNecropolisCompassSystem.cs
@@ -0,0 +1,145 @@
+using System.Numerics;
+using Content.Server.Chat.Managers;
+using Content.Shared.ADT.AshWalker;
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.ADT.UI;
+using Content.Shared.Actions;
+using Content.Shared.Chat;
+using Content.Shared.Popups;
+using Robust.Server.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Timing;
+
+namespace Content.Server.ADT.AshWalker;
+
+public sealed class ADTNecropolisCompassSystem : EntitySystem
+{
+    [Dependency] private readonly IChatManager _chat = default!;
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTNecropolisCompassComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ADTNecropolisCompassComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ADTNecropolisCompassComponent, ADTNecropolisCompassActionEvent>(OnUse);
+        SubscribeLocalEvent<ADTNecropolisCompassComponent, ADTNecropolisCompassSelectMessage>(OnPointSelected);
+    }
+
+    private void OnMapInit(Entity<ADTNecropolisCompassComponent> ent, ref MapInitEvent args)
+    {
+        _actions.AddAction(ent.Owner, ref ent.Comp.ActionEntity, ent.Comp.ActionId);
+    }
+
+    private void OnShutdown(Entity<ADTNecropolisCompassComponent> ent, ref ComponentShutdown args)
+    {
+        _actions.RemoveAction(ent.Comp.ActionEntity);
+    }
+
+    private void OnUse(Entity<ADTNecropolisCompassComponent> ent, ref ADTNecropolisCompassActionEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!TryComp<ActorComponent>(ent.Owner, out var actor))
+            return;
+
+        var points = CollectPoints(ent.Owner);
+
+        if (points.Count == 0)
+        {
+            _popup.PopupEntity(Loc.GetString("adt-necropolis-compass-nothing"), ent.Owner, ent.Owner);
+            return;
+        }
+
+        _ui.SetUiState(ent.Owner, ADTNecropolisCompassUiKey.Key, new ADTNecropolisCompassBuiState(points));
+        _ui.OpenUi(ent.Owner, ADTNecropolisCompassUiKey.Key, actor.PlayerSession);
+
+        args.Handled = true;
+    }
+
+    private void OnPointSelected(Entity<ADTNecropolisCompassComponent> ent, ref ADTNecropolisCompassSelectMessage args)
+    {
+        var point = GetEntity(args.Point);
+
+        if (!HasComp<ADTPointOfInterestComponent>(point))
+            return;
+
+        _popup.PopupEntity(Loc.GetString("adt-necropolis-compass-listen"), ent.Owner, ent.Owner);
+
+        var owner = ent.Owner;
+        Timer.Spawn(ent.Comp.Delay, () => Answer(owner, point)); // todo rm shitass Timer.Spawn
+    }
+
+    private List<ADTEntityPickerEntry> CollectPoints(EntityUid user)
+    {
+        var points = new List<ADTEntityPickerEntry>();
+        var userMap = _transform.GetMapId(user);
+
+        var query = EntityQueryEnumerator<ADTPointOfInterestComponent>();
+        while (query.MoveNext(out var poi, out var poiComp))
+        {
+            if (_transform.GetMapId(poi) != userMap)
+                continue;
+
+            var proto = MetaData(poi).EntityPrototype?.ID;
+
+            points.Add(new ADTEntityPickerEntry(GetNetEntity(poi), Loc.GetString(poiComp.Title), proto));
+        }
+
+        return points;
+    }
+
+    private void Answer(EntityUid user, EntityUid point)
+    {
+        if (Deleted(user) || !TryComp<ActorComponent>(user, out var actor))
+            return;
+
+        if (Deleted(point) || !TryComp<ADTPointOfInterestComponent>(point, out var poiComp))
+        {
+            SendMessage(actor, Loc.GetString("adt-necropolis-compass-destroyed"));
+            return;
+        }
+
+        var from = _transform.GetMapCoordinates(user);
+        var to = _transform.GetMapCoordinates(point);
+
+        var direction = to.MapId != from.MapId
+            ? Loc.GetString("adt-direction-far-away")
+            : Loc.GetString(DirectionKey(to.Position - from.Position));
+
+        SendMessage(actor, Loc.GetString(
+            "adt-necropolis-compass-answer",
+            ("place", Loc.GetString(poiComp.Title)),
+            ("direction", direction)));
+    }
+
+    private void SendMessage(ActorComponent actor, string message)
+    {
+        var wrapped = Loc.GetString("chat-manager-server-wrap-message", ("message", message));
+        _chat.ChatMessageToOne(ChatChannel.Server, message, wrapped, EntityUid.Invalid, false, actor.PlayerSession.Channel);
+    }
+
+    private static string DirectionKey(Vector2 delta)
+    {
+        if (delta.LengthSquared() < 0.5f)
+            return "adt-direction-here";
+
+        return delta.ToWorldAngle().GetDir() switch
+        {
+            Direction.North => "adt-direction-north",
+            Direction.NorthEast => "adt-direction-north-east",
+            Direction.East => "adt-direction-east",
+            Direction.SouthEast => "adt-direction-south-east",
+            Direction.South => "adt-direction-south",
+            Direction.SouthWest => "adt-direction-south-west",
+            Direction.West => "adt-direction-west",
+            Direction.NorthWest => "adt-direction-north-west",
+            _ => "adt-direction-here",
+        };
+    }
+}
diff --git a/Content.Server/ADT/Rituals/ADTActiveRitualComponent.cs b/Content.Server/ADT/Rituals/ADTActiveRitualComponent.cs
new file mode 100644
index 00000000000..c65ec7a6324
--- /dev/null
+++ b/Content.Server/ADT/Rituals/ADTActiveRitualComponent.cs
@@ -0,0 +1,30 @@
+using Content.Shared.ADT.Rituals;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.ADT.Rituals;
+
+[RegisterComponent]
+public sealed partial class ADTActiveRitualComponent : Component
+{
+    public ProtoId<ADTRitualPrototype> Ritual;
+
+    public EntityUid Invoker;
+
+    public List<EntityUid> Invokers = new();
+
+    public List<EntityUid> UsedThings = new();
+
+    public List<EntityUid> Consumable = new();
+
+    public float DisasterChance;
+
+    public Dictionary<EntityUid, EntityCoordinates> ThingPositions = new();
+
+    public List<EntityUid> Queue = new();
+
+    public int Index;
+
+    public TimeSpan? ResolveAt;
+}
+// todo add vv or datafields
\ No newline at end of file
diff --git a/Content.Server/ADT/Rituals/ADTAshSigilSystem.cs b/Content.Server/ADT/Rituals/ADTAshSigilSystem.cs
new file mode 100644
index 00000000000..f5525002c32
--- /dev/null
+++ b/Content.Server/ADT/Rituals/ADTAshSigilSystem.cs
@@ -0,0 +1,73 @@
+using Content.Shared.ADT.AshWalker;
+using Content.Shared.ADT.Rituals;
+using Content.Shared.Popups;
+using Robust.Shared.Timing;
+
+namespace Content.Server.ADT.Rituals;
+
+public sealed class ADTAshSigilSystem : EntitySystem
+{
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTAshSigilComponent, ADTHealTouchUsedEvent>(OnHealTouch);
+    }
+
+    private void OnHealTouch(Entity<ADTAshSigilComponent> ent, ref ADTHealTouchUsedEvent args)
+    {
+        if (args.Handled || ent.Comp.Transforming)
+            return;
+
+        ent.Comp.Transforming = true;
+        ent.Comp.ActivateAt = _timing.CurTime + ent.Comp.ActivationDelay;
+        Dirty(ent);
+        args.Handled = true;
+
+        _popup.PopupEntity(
+            Loc.GetString("adt-ash-sigil-touched", ("user", args.User)),
+            ent.Owner,
+            PopupType.Medium);
+
+        LightMarks(ent);
+
+        if (ent.Comp.ActivationEffect is { } effect)
+            Spawn(effect, Transform(ent.Owner).Coordinates);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var now = _timing.CurTime;
+        var query = EntityQueryEnumerator<ADTAshSigilComponent>();
+
+        while (query.MoveNext(out var uid, out var sigil))
+        {
+            if (sigil.ActivateAt is not { } at || now < at)
+                continue;
+
+            Spawn(sigil.Rune, Transform(uid).Coordinates);
+            QueueDel(uid);
+        }
+    }
+
+    private void LightMarks(Entity<ADTAshSigilComponent> ent)
+    {
+        var marks = new HashSet<Entity<ADTAshRuneMarkComponent>>();
+        _lookup.GetEntitiesInRange(Transform(ent.Owner).Coordinates, ent.Comp.MarkRange, marks);
+
+        foreach (var mark in marks)
+        {
+            if (mark.Comp.Lit)
+                continue;
+
+            mark.Comp.Lit = true;
+            Dirty(mark);
+        }
+    }
+}
diff --git a/Content.Server/ADT/Rituals/ADTRitualModifiers.cs b/Content.Server/ADT/Rituals/ADTRitualModifiers.cs
new file mode 100644
index 00000000000..e470210230b
--- /dev/null
+++ b/Content.Server/ADT/Rituals/ADTRitualModifiers.cs
@@ -0,0 +1,110 @@
+using System.Linq;
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.ADT.Rituals;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Components;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Prototypes;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.ADT.Rituals;
+
+public sealed partial class ADTRitualShamanModifier : ADTRitualModifier
+{
+    [DataField]
+    public float? FailChance;
+
+    [DataField]
+    public float? DisasterChance;
+
+    public override void Apply(IEntityManager entMan, ADTRitualArgs args, ref float fail, ref float disaster)
+    {
+        if (entMan.TryGetComponent<ADTAshWalkerComponent>(args.Invoker, out var walker) && walker.Shaman)
+            return;
+
+        if (FailChance is { } newFail)
+            fail = newFail;
+
+        if (DisasterChance is { } newDisaster)
+            disaster = newDisaster;
+    }
+}
+
+public sealed partial class ADTRitualHealthyInvokerModifier : ADTRitualModifier
+{
+    [DataField]
+    public float Threshold = 90f;
+
+    [DataField]
+    public float? FailChance;
+
+    [DataField]
+    public float? DisasterChance;
+
+    public override void Apply(IEntityManager entMan, ADTRitualArgs args, ref float fail, ref float disaster)
+    {
+        if (!entMan.TryGetComponent<DamageableComponent>(args.Invoker, out var damageable))
+            return;
+
+        if (damageable.TotalDamage >= Threshold)
+            return;
+
+        if (FailChance is { } newFail)
+            fail = newFail;
+
+        if (DisasterChance is { } newDisaster)
+            disaster = newDisaster;
+    }
+}
+
+public sealed partial class ADTRitualThingSpeciesModifier : ADTRitualModifier
+{
+    [DataField(required: true)]
+    public List<ProtoId<SpeciesPrototype>> Species = new();
+
+    [DataField]
+    public float? FailChance;
+
+    [DataField]
+    public float? DisasterChance;
+
+    public override void Apply(IEntityManager entMan, ADTRitualArgs args, ref float fail, ref float disaster)
+    {
+        foreach (var thing in args.UsedThings)
+        {
+            if (!entMan.HasComponent<MobStateComponent>(thing))
+                continue;
+
+            if (entMan.TryGetComponent<HumanoidProfileComponent>(thing, out var profile)
+                && Species.Contains(profile.Species))
+                return;
+        }
+
+        if (FailChance is { } newFail)
+            fail = newFail;
+
+        if (DisasterChance is { } newDisaster)
+            disaster = newDisaster;
+    }
+}
+
+public sealed partial class ADTRitualConsciousInvokersModifier : ADTRitualModifier
+{
+    [DataField]
+    public float FailChance = 0.2f;
+
+    [DataField]
+    public float DisasterChance = 0.2f;
+
+    public override void Apply(IEntityManager entMan, ADTRitualArgs args, ref float fail, ref float disaster)
+    {
+        var mobState = entMan.System<MobStateSystem>();
+        var conscious = args.Invokers.Count(uid =>
+            entMan.HasComponent<MobStateComponent>(uid) && !mobState.IsIncapacitated(uid));
+
+        fail += FailChance * conscious;
+        disaster += DisasterChance * conscious;
+    }
+}
diff --git a/Content.Server/ADT/Rituals/ADTRitualSummonSystem.cs b/Content.Server/ADT/Rituals/ADTRitualSummonSystem.cs
new file mode 100644
index 00000000000..7da40774b73
--- /dev/null
+++ b/Content.Server/ADT/Rituals/ADTRitualSummonSystem.cs
@@ -0,0 +1,42 @@
+using Content.Shared.ADT.Rituals;
+using Content.Shared.ADT.UI;
+using Robust.Server.GameObjects;
+
+namespace Content.Server.ADT.Rituals;
+
+public sealed class ADTRitualSummonSystem : EntitySystem
+{
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTRitualObjectComponent, ADTRitualSummonSelectMessage>(OnSelected);
+    }
+
+    public void OpenPicker(EntityUid ritualObject, EntityUid shaman, List<EntityUid> candidates)
+    {
+        var entries = new List<ADTEntityPickerEntry>();
+
+        foreach (var candidate in candidates)
+        {
+            var proto = MetaData(candidate).EntityPrototype?.ID;
+            entries.Add(new ADTEntityPickerEntry(GetNetEntity(candidate), Name(candidate), proto));
+        }
+
+        _ui.SetUiState(ritualObject, ADTRitualSummonUiKey.Key, new ADTRitualSummonBuiState(entries));
+        _ui.TryOpenUi(ritualObject, ADTRitualSummonUiKey.Key, shaman);
+    }
+
+    private void OnSelected(Entity<ADTRitualObjectComponent> ent, ref ADTRitualSummonSelectMessage args)
+    {
+        var target = GetEntity(args.Target);
+
+        if (Deleted(target))
+            return;
+
+        _transform.SetCoordinates(target, Transform(ent.Owner).Coordinates);
+    }
+}
diff --git a/Content.Server/ADT/Rituals/ADTRitualSystem.Targets.cs b/Content.Server/ADT/Rituals/ADTRitualSystem.Targets.cs
new file mode 100644
index 00000000000..26da3263633
--- /dev/null
+++ b/Content.Server/ADT/Rituals/ADTRitualSystem.Targets.cs
@@ -0,0 +1,91 @@
+using System.Linq;
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.ADT.Rituals;
+using Content.Shared.Humanoid;
+using Robust.Shared.Random;
+
+namespace Content.Server.ADT.Rituals;
+
+public sealed partial class ADTRitualSystem
+{
+    public List<EntityUid> GetTargets(ADTRitualArgs args, ADTRitualTarget target)
+    {
+        switch (target)
+        {
+            case ADTRitualTarget.Invoker:
+                return new List<EntityUid> { args.Invoker };
+
+            case ADTRitualTarget.Invokers:
+                return args.Invokers.ToList();
+
+            case ADTRitualTarget.UsedThings:
+                return args.UsedThings.ToList();
+
+            case ADTRitualTarget.Tribe:
+                return GetOnMap(args.Object, tribe: true);
+
+            case ADTRitualTarget.RandomTribesman:
+                return PickOne(GetOnMap(args.Object, tribe: true));
+
+            case ADTRitualTarget.Outsiders:
+                return GetOnMap(args.Object, tribe: false);
+
+            case ADTRitualTarget.RandomOutsider:
+                return PickOne(GetOnMap(args.Object, tribe: false));
+
+            case ADTRitualTarget.InRange:
+                return GetInRange(args);
+
+            default:
+                return new List<EntityUid>();
+        }
+    }
+
+    private List<EntityUid> GetOnMap(EntityUid ritualObject, bool tribe)
+    {
+        var result = new List<EntityUid>();
+        var map = Transform(ritualObject).MapID;
+
+        var query = EntityQueryEnumerator<HumanoidProfileComponent>();
+        while (query.MoveNext(out var uid, out _))
+        {
+            if (Transform(uid).MapID != map)
+                continue;
+
+            if (_mobState.IsDead(uid))
+                continue;
+
+            if (HasComp<ADTAshWalkerComponent>(uid) != tribe)
+                continue;
+
+            result.Add(uid);
+        }
+
+        return result;
+    }
+
+    private List<EntityUid> GetInRange(ADTRitualArgs args)
+    {
+        var result = new List<EntityUid>();
+
+        if (!_proto.TryIndex<ADTRitualPrototype>(args.Ritual.ID, out var ritual))
+            return result;
+
+        var nearby = new HashSet<Entity<HumanoidProfileComponent>>();
+        _lookup.GetEntitiesInRange(Transform(args.Object).Coordinates, ritual.FindingRange, nearby);
+
+        foreach (var found in nearby)
+        {
+            result.Add(found.Owner);
+        }
+
+        return result;
+    }
+
+    private List<EntityUid> PickOne(List<EntityUid> from)
+    {
+        return from.Count == 0
+            ? from
+            : new List<EntityUid> { _random.Pick(from) };
+    }
+}
diff --git a/Content.Server/ADT/Rituals/ADTRitualSystem.cs b/Content.Server/ADT/Rituals/ADTRitualSystem.cs
new file mode 100644
index 00000000000..30034a22a6d
--- /dev/null
+++ b/Content.Server/ADT/Rituals/ADTRitualSystem.cs
@@ -0,0 +1,579 @@
+using System.Linq;
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.ADT.Rituals;
+using Content.Shared.DoAfter;
+using Content.Shared.Gibbing;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Prototypes;
+using Content.Shared.Interaction;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Popups;
+using Content.Shared.Stacks;
+using Content.Shared.Whitelist;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.ADT.Rituals;
+
+public sealed partial class ADTRitualSystem : EntitySystem
+{
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly EntityWhitelistSystem _whitelist = default!;
+    [Dependency] private readonly GibbingSystem _gibbing = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly MobStateSystem _mobState = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTRitualObjectComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ADTRitualObjectComponent, InteractHandEvent>(OnInteractHand);
+        SubscribeLocalEvent<ADTRitualObjectComponent, ADTRitualStartMessage>(OnStartMessage);
+        SubscribeLocalEvent<ADTActiveRitualComponent, ADTRitualDoAfterEvent>(OnDoAfter);
+    }
+
+    private void OnMapInit(Entity<ADTRitualObjectComponent> ent, ref MapInitEvent args)
+    {
+        foreach (var ritual in GetRituals(ent))
+        {
+            ent.Comp.Charges.TryAdd(ritual.ID, ritual.Charges);
+        }
+    }
+
+    private void OnInteractHand(Entity<ADTRitualObjectComponent> ent, ref InteractHandEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!CanUse(ent, args.User))
+            return;
+
+        if (!_ui.TryOpenUi(ent.Owner, ADTRitualUiKey.Key, args.User))
+            return;
+
+        UpdateUi(ent);
+        args.Handled = true;
+    }
+
+    private void UpdateUi(Entity<ADTRitualObjectComponent> ent)
+    {
+        var entries = new List<ADTRitualEntry>();
+
+        foreach (var ritual in GetRituals(ent))
+        {
+            var charges = ent.Comp.Charges.GetValueOrDefault(ritual.ID, ritual.Charges);
+            var until = ent.Comp.Cooldowns.GetValueOrDefault(ritual.ID, TimeSpan.Zero);
+
+            entries.Add(new ADTRitualEntry(ritual.ID, charges, until));
+        }
+
+        _ui.SetUiState(ent.Owner, ADTRitualUiKey.Key, new ADTRitualBuiState(entries, ent.Comp.Busy));
+    }
+
+    private void OnStartMessage(Entity<ADTRitualObjectComponent> ent, ref ADTRitualStartMessage args)
+    {
+        var user = args.Actor;
+
+        if (!CanUse(ent, user))
+            return;
+
+        if (!_proto.TryIndex(args.Ritual, out var ritual) || !ent.Comp.Categories.Any(ritual.Categories.Contains))
+            return;
+
+        TryStart(ent, ritual, user);
+        UpdateUi(ent);
+    }
+
+    private bool CanUse(Entity<ADTRitualObjectComponent> ent, EntityUid user)
+    {
+        return ent.Comp.AllowedSpecies.Count == 0 || IsAllowedSpecies(user, ent.Comp.AllowedSpecies);
+    }
+
+    private bool IsAllowedSpecies(EntityUid uid, List<ProtoId<SpeciesPrototype>> allowed)
+    {
+        return TryComp<HumanoidProfileComponent>(uid, out var profile) && allowed.Contains(profile.Species);
+    }
+
+    private IEnumerable<ADTRitualPrototype> GetRituals(Entity<ADTRitualObjectComponent> ent)
+    {
+        foreach (var ritual in _proto.EnumeratePrototypes<ADTRitualPrototype>())
+        {
+            if (ent.Comp.Categories.Any(ritual.Categories.Contains))
+                yield return ritual;
+        }
+    }
+
+    private void TryStart(Entity<ADTRitualObjectComponent> ent, ADTRitualPrototype ritual, EntityUid user)
+    {
+        if (ent.Comp.Busy)
+        {
+            Popup(ent, user, "adt-ritual-busy");
+            return;
+        }
+
+        if (ent.Comp.Charges.GetValueOrDefault(ritual.ID, ritual.Charges) == 0)
+            return;
+
+        if (ent.Comp.Cooldowns.TryGetValue(ritual.ID, out var until) && until > _timing.CurTime)
+            return;
+
+        _audio.PlayPvs(ritual.StartSound, ent.Owner);
+
+        if (!TryGatherInvokers(ent, ritual, user, out var invokers))
+            return;
+
+        if (!CheckInvokers(ent, ritual, user, invokers))
+            return;
+
+        var consumable = new List<EntityUid>();
+        var things = GatherThings(ent, ritual, invokers, consumable);
+
+        if (things == null)
+        {
+            Popup(ent, user, "adt-ritual-need-things");
+            return;
+        }
+
+        var args = new ADTRitualArgs(ent.Owner, ritual, user, invokers, things);
+
+        foreach (var check in ritual.Checks)
+        {
+            if (check.Check(EntityManager, args, out var reason))
+                continue;
+
+            if (reason != null)
+                _popup.PopupEntity(Loc.GetString(reason), ent.Owner, user);
+
+            return;
+        }
+
+        var fail = ritual.FailChance;
+        var disaster = ritual.DisasterChance;
+
+        foreach (var modifier in ritual.Modifiers)
+        {
+            modifier.Apply(EntityManager, args, ref fail, ref disaster);
+        }
+
+        if (_random.Prob(fail))
+        {
+            Collapse(ent, ritual, user, invokers, things, consumable, disaster);
+            return;
+        }
+
+        if (ritual.CastTime <= TimeSpan.Zero)
+        {
+            Succeed(ent, ritual, user, invokers, things, consumable);
+            return;
+        }
+
+        BeginCast(ent, ritual, user, invokers, things, consumable, disaster);
+    }
+
+    private bool TryGatherInvokers(
+        Entity<ADTRitualObjectComponent> ent,
+        ADTRitualPrototype ritual,
+        EntityUid user,
+        out List<EntityUid> invokers)
+    {
+        invokers = new List<EntityUid> { user };
+
+        if (ritual.ExtraInvokers <= 0)
+            return true;
+
+        invokers.Clear();
+
+        var nearby = new HashSet<EntityUid>();
+        _lookup.GetEntitiesInRange(Transform(ent.Owner).Coordinates, ritual.FindingRange, nearby);
+
+        foreach (var candidate in nearby)
+        {
+            if (IsValidInvoker(candidate, ritual))
+                invokers.Add(candidate);
+        }
+
+        if (invokers.Count >= ritual.ExtraInvokers + 1)
+            return true;
+
+        Popup(ent, user, "adt-ritual-need-invokers");
+        return false;
+    }
+
+    private bool IsValidInvoker(EntityUid uid, ADTRitualPrototype ritual)
+    {
+        if (HasComp<ADTRitualTotemComponent>(uid))
+            return true;
+
+        if (!HasComp<HumanoidProfileComponent>(uid) || _mobState.IsDead(uid))
+            return false;
+
+        return ritual.AllowedSpecies.Count == 0 || IsAllowedSpecies(uid, ritual.AllowedSpecies);
+    }
+
+    private bool CheckInvokers(
+        Entity<ADTRitualObjectComponent> ent,
+        ADTRitualPrototype ritual,
+        EntityUid user,
+        List<EntityUid> invokers)
+    {
+        if (ritual.ShamanOnly && !IsShaman(user))
+        {
+            Popup(ent, user, "adt-ritual-shaman-only");
+            return false;
+        }
+
+        if (ritual.NeededDye != null)
+        {
+            foreach (var invoker in invokers)
+            {
+                var wanted = HasComp<ADTRitualTotemComponent>(invoker) ? ritual.TotemDye : ritual.NeededDye;
+
+                if (wanted == null)
+                    continue;
+
+                if (!TryComp<ADTDyedComponent>(invoker, out var dyed) || dyed.Dye != wanted)
+                {
+                    Popup(ent, user, "adt-ritual-no-dye");
+                    return false;
+                }
+            }
+        }
+
+        if (ritual.ExtraShamanInvokers > 0)
+        {
+            var shamans = invokers.Count(IsShaman);
+
+            if (shamans < ritual.ExtraShamanInvokers + 1)
+            {
+                Popup(ent, user, "adt-ritual-need-shamans");
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private bool IsShaman(EntityUid uid)
+    {
+        return TryComp<ADTAshWalkerComponent>(uid, out var walker) && walker.Shaman;
+    }
+
+    private List<EntityUid>? GatherThings(
+        Entity<ADTRitualObjectComponent> ent,
+        ADTRitualPrototype ritual,
+        List<EntityUid> invokers,
+        List<EntityUid> consumable)
+    {
+        var used = new List<EntityUid>();
+
+        if (ritual.RequiredThings.Count == 0)
+            return used;
+
+        var nearby = new HashSet<EntityUid>();
+        _lookup.GetEntitiesInRange(Transform(ent.Owner).Coordinates, ritual.FindingRange, nearby);
+
+        foreach (var required in ritual.RequiredThings)
+        {
+            var left = required.Amount;
+
+            foreach (var candidate in nearby)
+            {
+                if (left <= 0)
+                    break;
+
+                if (candidate == ent.Owner || invokers.Contains(candidate) || used.Contains(candidate))
+                    continue;
+
+                if (!_whitelist.IsValid(required.Whitelist, candidate))
+                    continue;
+
+                used.Add(candidate);
+
+                if (required.Consume)
+                    consumable.Add(candidate);
+
+                left -= TryComp<StackComponent>(candidate, out var stack) ? stack.Count : 1;
+            }
+
+            if (left > 0)
+                return null;
+        }
+
+        return used;
+    }
+
+    private void BeginCast(
+        Entity<ADTRitualObjectComponent> ent,
+        ADTRitualPrototype ritual,
+        EntityUid user,
+        List<EntityUid> invokers,
+        List<EntityUid> things,
+        List<EntityUid> consumable,
+        float disaster)
+    {
+        var active = EnsureComp<ADTActiveRitualComponent>(ent.Owner);
+        active.Ritual = ritual.ID;
+        active.Invoker = user;
+        active.Invokers = invokers;
+        active.UsedThings = things;
+        active.Consumable = consumable;
+        active.DisasterChance = disaster;
+        active.ThingPositions.Clear();
+        active.Queue.Clear();
+        active.Index = 0;
+
+        foreach (var thing in things)
+        {
+            active.ThingPositions[thing] = Transform(thing).Coordinates;
+        }
+
+        foreach (var invoker in invokers)
+        {
+            if (!HasComp<ADTRitualTotemComponent>(invoker))
+                active.Queue.Add(invoker);
+        }
+
+        ent.Comp.Busy = true;
+
+        if (!TryCastNext((ent.Owner, active)))
+        {
+            Cancel(ent.Owner);
+            Collapse(ent, ritual, user, invokers, things, consumable, disaster);
+        }
+    }
+
+    private bool TryCastNext(Entity<ADTActiveRitualComponent> ent)
+    {
+        if (!_proto.TryIndex(ent.Comp.Ritual, out var ritual))
+            return false;
+
+        if (ent.Comp.Index >= ent.Comp.Queue.Count)
+            return false;
+
+        var invoker = ent.Comp.Queue[ent.Comp.Index];
+
+        var doAfter = new DoAfterArgs(EntityManager, invoker, ritual.CastTime, new ADTRitualDoAfterEvent(), ent.Owner, ent.Owner)
+        {
+            BreakOnMove = true,
+            BreakOnDamage = true,
+            NeedHand = false,
+            BlockDuplicate = true,
+            CancelDuplicate = true,
+        };
+
+        return _doAfter.TryStartDoAfter(doAfter);
+    }
+
+    private void OnDoAfter(Entity<ADTActiveRitualComponent> ent, ref ADTRitualDoAfterEvent args)
+    {
+        if (!TryComp<ADTRitualObjectComponent>(ent.Owner, out var obj))
+            return;
+
+        if (!_proto.TryIndex(ent.Comp.Ritual, out var ritual))
+            return;
+
+        var invoker = ent.Comp.Invoker;
+        var invokers = ent.Comp.Invokers;
+        var things = ent.Comp.UsedThings;
+        var consumable = ent.Comp.Consumable;
+        var disaster = ent.Comp.DisasterChance;
+
+        if (args.Cancelled)
+        {
+            Cancel(ent.Owner);
+            Collapse((ent.Owner, obj), ritual, invoker, invokers, things, consumable, disaster);
+            return;
+        }
+
+        ent.Comp.Index++;
+
+        if (ent.Comp.Index < ent.Comp.Queue.Count)
+        {
+            if (TryCastNext(ent))
+                return;
+
+            Cancel(ent.Owner);
+            Collapse((ent.Owner, obj), ritual, invoker, invokers, things, consumable, disaster);
+            return;
+        }
+
+        foreach (var (thing, where) in ent.Comp.ThingPositions)
+        {
+            if (Deleted(thing) || Transform(thing).Coordinates != where)
+            {
+                Cancel(ent.Owner);
+                Collapse((ent.Owner, obj), ritual, invoker, invokers, things, consumable, disaster);
+                return;
+            }
+        }
+
+        if (obj.FinaleEffect is { } finale)
+            Spawn(finale, Transform(ent.Owner).Coordinates);
+
+        if (obj.FinaleDelay <= TimeSpan.Zero)
+        {
+            Cancel(ent.Owner);
+            Succeed((ent.Owner, obj), ritual, invoker, invokers, things, consumable);
+            return;
+        }
+
+        ent.Comp.ResolveAt = _timing.CurTime + obj.FinaleDelay;
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var now = _timing.CurTime;
+        var query = EntityQueryEnumerator<ADTActiveRitualComponent, ADTRitualObjectComponent>();
+
+        while (query.MoveNext(out var uid, out var active, out var obj))
+        {
+            if (active.ResolveAt is not { } at || now < at)
+                continue;
+
+            if (!_proto.TryIndex(active.Ritual, out var ritual))
+            {
+                Cancel(uid);
+                continue;
+            }
+
+            var invoker = active.Invoker;
+            var invokers = active.Invokers;
+            var things = active.UsedThings;
+            var consumable = active.Consumable;
+
+            Cancel(uid);
+            Succeed((uid, obj), ritual, invoker, invokers, things, consumable);
+        }
+    }
+
+    private void Cancel(EntityUid uid)
+    {
+        RemCompDeferred<ADTActiveRitualComponent>(uid);
+    }
+
+    private void Succeed(
+        Entity<ADTRitualObjectComponent> ent,
+        ADTRitualPrototype ritual,
+        EntityUid user,
+        List<EntityUid> invokers,
+        List<EntityUid> things,
+        List<EntityUid> consumable)
+    {
+        var args = new ADTRitualArgs(ent.Owner, ritual, user, invokers, things);
+
+        foreach (var effect in ritual.Effects)
+        {
+            effect.Effect(EntityManager, args);
+        }
+
+        _audio.PlayPvs(ritual.SuccessSound, ent.Owner);
+        Popup(ent, user, "adt-ritual-success");
+
+        StartCooldown(ent, ritual);
+
+        if (ritual.Charges != -1 && ent.Comp.Charges.TryGetValue(ritual.ID, out var charges) && charges > 0)
+            ent.Comp.Charges[ritual.ID] = charges - 1;
+
+        if (ritual.DeleteThingsOnSuccess)
+            DeleteThings(consumable);
+
+        WashDyes(ritual, invokers);
+
+        ent.Comp.Busy = false;
+        UpdateUi(ent);
+    }
+
+    private void Collapse(
+        Entity<ADTRitualObjectComponent> ent,
+        ADTRitualPrototype ritual,
+        EntityUid user,
+        List<EntityUid> invokers,
+        List<EntityUid> things,
+        List<EntityUid> consumable,
+        float disaster)
+    {
+        _audio.PlayPvs(ritual.FailSound, ent.Owner);
+        Popup(ent, user, "adt-ritual-failed");
+
+        StartCooldown(ent, ritual);
+
+        if (_random.Prob(disaster))
+        {
+            var args = new ADTRitualArgs(ent.Owner, ritual, user, invokers, things);
+
+            foreach (var effect in ritual.DisasterEffects)
+            {
+                effect.Effect(EntityManager, args);
+            }
+        }
+
+        if (ritual.DeleteThingsOnFail)
+            DeleteThings(consumable);
+
+        ent.Comp.Busy = false;
+        UpdateUi(ent);
+    }
+
+    private void StartCooldown(Entity<ADTRitualObjectComponent> ent, ADTRitualPrototype ritual)
+    {
+        ent.Comp.Cooldowns[ritual.ID] = _timing.CurTime + ritual.Cooldown;
+    }
+
+    private void DeleteThings(List<EntityUid> things)
+    {
+        foreach (var thing in things)
+        {
+            if (Deleted(thing))
+                continue;
+
+            if (HasComp<MobStateComponent>(thing))
+                _gibbing.Gib(thing);
+            else
+                QueueDel(thing);
+        }
+    }
+
+    private void WashDyes(ADTRitualPrototype ritual, List<EntityUid> invokers)
+    {
+        if (ritual.NeededDye == null)
+            return;
+
+        foreach (var invoker in invokers)
+        {
+            if (!TryComp<ADTDyedComponent>(invoker, out var dyed) || dyed.Dye == null)
+                continue;
+
+            dyed.Dye = null;
+            Dirty(invoker, dyed);
+            _popup.PopupEntity(Loc.GetString("adt-ritual-dye-washed"), invoker, invoker);
+        }
+    }
+
+    public void AddCharge(Entity<ADTRitualObjectComponent?> ent, ADTRitualPrototype ritual, int amount = 1)
+    {
+        if (!Resolve(ent, ref ent.Comp, false) || ritual.Charges == -1)
+            return;
+
+        ent.Comp.Charges[ritual.ID] = ent.Comp.Charges.GetValueOrDefault(ritual.ID, ritual.Charges) + amount;
+    }
+
+    public IEnumerable<ADTRitualPrototype> GetRitualsOf(Entity<ADTRitualObjectComponent> ent) => GetRituals(ent);
+
+    private void Popup(Entity<ADTRitualObjectComponent> ent, EntityUid user, string message)
+    {
+        _popup.PopupEntity(Loc.GetString(message), ent.Owner, user);
+    }
+}
diff --git a/Content.Server/ADT/Rituals/Checks/ADTRitualThingsCheck.cs b/Content.Server/ADT/Rituals/Checks/ADTRitualThingsCheck.cs
new file mode 100644
index 00000000000..4e3fc9ae15f
--- /dev/null
+++ b/Content.Server/ADT/Rituals/Checks/ADTRitualThingsCheck.cs
@@ -0,0 +1,61 @@
+using Content.Shared.ADT.Rituals;
+using Content.Shared.ADT.Salvage.Components;
+using Content.Shared.Mind.Components;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+
+namespace Content.Server.ADT.Rituals.Checks;
+
+public sealed partial class ADTRitualThingsCheck : ADTRitualCheck
+{
+    [DataField]
+    public bool MustBeDead;
+
+    [DataField]
+    public bool MustBeAlive;
+
+    [DataField]
+    public bool MustHaveMind;
+
+    [DataField]
+    public bool MustLackMind;
+
+    [DataField]
+    public bool NoMegafauna;
+
+    [DataField(required: true)]
+    public LocId Reason = default!;
+
+    public override bool Check(IEntityManager entMan, ADTRitualArgs args, out string? reason)
+    {
+        reason = Reason;
+
+        var mobState = entMan.System<MobStateSystem>();
+
+        foreach (var thing in args.UsedThings)
+        {
+            if (!entMan.HasComponent<MobStateComponent>(thing))
+                continue;
+
+            if (MustBeDead && !mobState.IsDead(thing))
+                return false;
+
+            if (MustBeAlive && mobState.IsDead(thing))
+                return false;
+
+            var hasMind = entMan.TryGetComponent<MindContainerComponent>(thing, out var mind) && mind.HasMind;
+
+            if (MustHaveMind && !hasMind)
+                return false;
+
+            if (MustLackMind && hasMind)
+                return false;
+
+            if (NoMegafauna && entMan.HasComponent<MegafaunaComponent>(thing))
+                return false;
+        }
+
+        reason = null;
+        return true;
+    }
+}
diff --git a/Content.Server/ADT/Rituals/Effects/ADTRitualBasicEffects.cs b/Content.Server/ADT/Rituals/Effects/ADTRitualBasicEffects.cs
new file mode 100644
index 00000000000..f9a9cb1fbcc
--- /dev/null
+++ b/Content.Server/ADT/Rituals/Effects/ADTRitualBasicEffects.cs
@@ -0,0 +1,253 @@
+using System.Linq;
+using Content.Server.Atmos.EntitySystems;
+using Content.Shared.ADT.Rituals;
+using Content.Shared.Body.Components;
+using Content.Shared.Body.Systems;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Popups;
+using Content.Shared.Stacks;
+using Content.Shared.StatusEffectNew;
+using Content.Shared.Stunnable;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Server.ADT.Rituals.Effects;
+
+public sealed partial class ADTRitualSpawnEffect : ADTRitualEffect
+{
+    [DataField(required: true)]
+    public List<EntProtoId> Entities = new();
+
+    [DataField]
+    public bool Pick;
+
+    [DataField]
+    public int Amount = 1;
+
+    [DataField]
+    public float Prob = 1f;
+
+    [DataField]
+    public int? StackCount;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        if (Entities.Count == 0)
+            return;
+
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var stacks = entMan.System<SharedStackSystem>();
+        var coords = entMan.GetComponent<TransformComponent>(args.Object).Coordinates;
+
+        for (var i = 0; i < Amount; i++)
+        {
+            var batch = Pick ? new List<EntProtoId> { random.Pick(Entities) } : Entities;
+
+            foreach (var proto in batch)
+            {
+                if (!random.Prob(Prob))
+                    continue;
+
+                var spawned = entMan.SpawnEntity(proto, coords);
+
+                if (StackCount is { } count && entMan.HasComponent<StackComponent>(spawned))
+                    stacks.SetCount(spawned, count);
+            }
+        }
+    }
+}
+
+public sealed partial class ADTRitualDamageEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Invoker;
+
+    [DataField]
+    public DamageSpecifier? Damage;
+
+    [DataField]
+    public float BloodLoss;
+
+    [DataField]
+    public float Prob = 1f;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var damageable = entMan.System<DamageableSystem>();
+        var blood = entMan.System<SharedBloodstreamSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!random.Prob(Prob))
+                continue;
+
+            if (Damage != null)
+                damageable.TryChangeDamage(target, Damage, origin: args.Invoker);
+
+            if (BloodLoss > 0f && entMan.HasComponent<BloodstreamComponent>(target))
+                blood.TryModifyBloodLevel(target, -BloodLoss);
+        }
+    }
+}
+
+public sealed partial class ADTRitualIgniteEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Tribe;
+
+    [DataField]
+    public float FireStacks = 6f;
+
+    [DataField]
+    public TimeSpan Knockdown = TimeSpan.FromSeconds(10);
+
+    [DataField]
+    public float Prob = 1f;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var flammable = entMan.System<FlammableSystem>();
+        var stun = entMan.System<SharedStunSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!random.Prob(Prob))
+                continue;
+
+            flammable.AdjustFireStacks(target, FireStacks, ignite: true);
+
+            if (Knockdown > TimeSpan.Zero)
+                stun.TryKnockdown(target, Knockdown);
+        }
+    }
+}
+
+public sealed partial class ADTRitualComponentsEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Invokers;
+
+    [DataField]
+    public ComponentRegistry Components = new();
+
+    [DataField]
+    public List<string> RemoveComponents = new();
+
+    [DataField]
+    public float Prob = 1f;
+
+    [DataField]
+    public bool Overwrite;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var factory = IoCManager.Resolve<IComponentFactory>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!random.Prob(Prob))
+                continue;
+
+            foreach (var name in RemoveComponents)
+            {
+                if (factory.TryGetRegistration(name, out var registration))
+                    entMan.RemoveComponent(target, registration.Type);
+            }
+
+            if (Components.Count > 0)
+                entMan.AddComponents(target, Components, Overwrite);
+        }
+    }
+}
+
+public sealed partial class ADTRitualDropItemsEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Tribe;
+
+    [DataField]
+    public float Prob = 1f;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var hands = entMan.System<SharedHandsSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!random.Prob(Prob))
+                continue;
+
+            foreach (var held in hands.EnumerateHeld(target).ToArray())
+            {
+                hands.TryDrop(target, held, checkActionBlocker: false);
+            }
+        }
+    }
+}
+
+public sealed partial class ADTRitualMessageEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Tribe;
+
+    [DataField]
+    public LocId? Message;
+
+    [DataField]
+    public SoundSpecifier? Sound;
+
+    [DataField]
+    public PopupType PopupType = PopupType.Large;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var popup = entMan.System<SharedPopupSystem>();
+        var audio = entMan.System<SharedAudioSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (Message != null)
+                popup.PopupEntity(Loc.GetString(Message), target, target, PopupType);
+
+            if (Sound != null)
+                audio.PlayEntity(Sound, target, target);
+        }
+    }
+}
+
+public sealed partial class ADTRitualStatusEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Tribe;
+
+    [DataField(required: true)]
+    public EntProtoId StatusEffect = default!;
+
+    [DataField]
+    public TimeSpan Duration = TimeSpan.FromSeconds(5);
+
+    [DataField]
+    public float Prob = 1f;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var status = entMan.System<StatusEffectsSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!random.Prob(Prob))
+                continue;
+
+            status.TryAddStatusEffect(target, StatusEffect, out _, Duration);
+        }
+    }
+}
diff --git a/Content.Server/ADT/Rituals/Effects/ADTRitualSpecialEffects.cs b/Content.Server/ADT/Rituals/Effects/ADTRitualSpecialEffects.cs
new file mode 100644
index 00000000000..bce80de4669
--- /dev/null
+++ b/Content.Server/ADT/Rituals/Effects/ADTRitualSpecialEffects.cs
@@ -0,0 +1,270 @@
+using System.Linq;
+using Content.Server.Ghost.Roles.Components;
+using Content.Server.Polymorph.Systems;
+using Content.Shared.ADT.Rituals;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Components;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Mind.Components;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.NPC.Prototypes;
+using Content.Shared.NPC.Systems;
+using Content.Shared.Polymorph;
+using Content.Shared.Popups;
+using Content.Shared.Weather;
+using Content.Shared.Whitelist;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Server.ADT.Rituals.Effects;
+
+public sealed partial class ADTRitualPolymorphEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.Invoker;
+
+    [DataField(required: true)]
+    public ProtoId<PolymorphPrototype> Polymorph = default!;
+
+    [DataField]
+    public bool RequireMind = true;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var polymorph = entMan.System<PolymorphSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (RequireMind
+                && (!entMan.TryGetComponent<MindContainerComponent>(target, out var mind) || !mind.HasMind))
+                continue;
+
+            polymorph.PolymorphEntity(target, Polymorph);
+        }
+    }
+}
+
+public sealed partial class ADTRitualTeleportEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.UsedThings;
+
+    [DataField]
+    public EntityWhitelist? Destination;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var random = IoCManager.Resolve<IRobustRandom>();
+        var transform = entMan.System<SharedTransformSystem>();
+        var runeCoords = entMan.GetComponent<TransformComponent>(args.Object).Coordinates;
+        var beacons = Destination == null ? null : FindBeacons(entMan, Destination);
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (beacons == null)
+            {
+                transform.SetCoordinates(target, runeCoords);
+                continue;
+            }
+
+            if (beacons.Count == 0)
+                continue;
+
+            var beacon = random.Pick(beacons);
+            transform.SetCoordinates(target, entMan.GetComponent<TransformComponent>(beacon).Coordinates);
+        }
+    }
+
+    private static List<EntityUid> FindBeacons(IEntityManager entMan, EntityWhitelist whitelist)
+    {
+        var whitelistSystem = entMan.System<EntityWhitelistSystem>();
+        var found = new List<EntityUid>();
+        var query = entMan.EntityQueryEnumerator<TransformComponent>();
+
+        while (query.MoveNext(out var uid, out var xform))
+        {
+            if (xform.MapUid != null && whitelistSystem.IsValid(whitelist, uid))
+                found.Add(uid);
+        }
+
+        return found;
+    }
+}
+
+public sealed partial class ADTRitualReviveEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.UsedThings;
+
+    [DataField]
+    public DamageSpecifier? Aftermath;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var damageable = entMan.System<DamageableSystem>();
+        var mobState = entMan.System<MobStateSystem>();
+        var mobThreshold = entMan.System<MobThresholdSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!entMan.HasComponent<MobStateComponent>(target))
+                continue;
+
+            damageable.SetAllDamage(target, 0);
+            mobThreshold.SetAllowRevives(target, true);
+            mobState.ChangeMobState(target, MobState.Alive);
+            mobThreshold.SetAllowRevives(target, false);
+
+            if (Aftermath != null)
+                damageable.TryChangeDamage(target, Aftermath, true);
+        }
+    }
+}
+
+public sealed partial class ADTRitualWeatherEffect : ADTRitualEffect
+{
+    [DataField(required: true)]
+    public EntProtoId Weather = default!;
+
+    [DataField]
+    public TimeSpan Duration = TimeSpan.FromMinutes(3);
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var weather = entMan.System<SharedWeatherSystem>();
+        var map = entMan.GetComponent<TransformComponent>(args.Object).MapID;
+
+        weather.TryAddWeather(map, Weather, out _, Duration);
+    }
+}
+
+public sealed partial class ADTRitualRechargeEffect : ADTRitualEffect
+{
+    [DataField]
+    public int Amount = 1;
+
+    [DataField]
+    public List<ProtoId<ADTRitualPrototype>> Blacklist = new();
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var rituals = entMan.System<ADTRitualSystem>();
+
+        if (!entMan.TryGetComponent<ADTRitualObjectComponent>(args.Object, out var obj))
+            return;
+
+        foreach (var ritual in rituals.GetRitualsOf((args.Object, obj)))
+        {
+            if (Blacklist.Contains(ritual.ID))
+                continue;
+
+            rituals.AddCharge((args.Object, obj), ritual, Amount);
+        }
+    }
+}
+
+public sealed partial class ADTRitualEmpathEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.UsedThings;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var popup = entMan.System<SharedPopupSystem>();
+        var mobState = entMan.System<MobStateSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!entMan.HasComponent<MobStateComponent>(target))
+                continue;
+
+            var damage = entMan.TryGetComponent<DamageableComponent>(target, out var damageable)
+                ? (int)damageable.TotalDamage
+                : 0;
+
+            var feeling = mobState.IsDead(target)
+                ? "adt-ritual-empath-dead"
+                : mobState.IsCritical(target)
+                    ? "adt-ritual-empath-dying"
+                    : damage > 50
+                        ? "adt-ritual-empath-hurt"
+                        : "adt-ritual-empath-well";
+
+            popup.PopupEntity(
+                Loc.GetString("adt-ritual-empath-report",
+                    ("target", target),
+                    ("feeling", Loc.GetString(feeling))),
+                args.Invoker,
+                args.Invoker,
+                PopupType.Medium);
+        }
+    }
+}
+
+public sealed partial class ADTRitualSentienceEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Target = ADTRitualTarget.UsedThings;
+
+    [DataField]
+    public LocId RoleName = "ghost-role-information-adt-ash-walker-slave-name";
+
+    [DataField]
+    public LocId RoleDescription = "ghost-role-information-adt-ash-walker-slave-description";
+
+    [DataField]
+    public ProtoId<NpcFactionPrototype> Faction = "ADTAshWalker";
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var damageable = entMan.System<DamageableSystem>();
+        var mobState = entMan.System<MobStateSystem>();
+        var mobThreshold = entMan.System<MobThresholdSystem>();
+        var factions = entMan.System<NpcFactionSystem>();
+
+        foreach (var target in entMan.System<ADTRitualSystem>().GetTargets(args, Target))
+        {
+            if (!entMan.HasComponent<MobStateComponent>(target))
+                continue;
+
+            if (entMan.TryGetComponent<MindContainerComponent>(target, out var mind) && mind.HasMind)
+                continue;
+
+            damageable.SetAllDamage(target, 0);
+            mobThreshold.SetAllowRevives(target, true);
+            mobState.ChangeMobState(target, MobState.Alive);
+            mobThreshold.SetAllowRevives(target, false);
+
+            factions.ClearFactions(target);
+            factions.AddFaction(target, Faction);
+
+            if (entMan.HasComponent<GhostRoleComponent>(target))
+                continue;
+
+            var role = entMan.AddComponent<GhostRoleComponent>(target);
+            entMan.EnsureComponent<GhostTakeoverAvailableComponent>(target);
+            role.RoleName = Loc.GetString(RoleName);
+            role.RoleDescription = Loc.GetString(RoleDescription);
+        }
+    }
+}
+
+public sealed partial class ADTRitualSummonPickerEffect : ADTRitualEffect
+{
+    [DataField]
+    public ADTRitualTarget Candidates = ADTRitualTarget.Tribe;
+
+    public override void Effect(IEntityManager entMan, ADTRitualArgs args)
+    {
+        var candidates = entMan.System<ADTRitualSystem>().GetTargets(args, Candidates);
+
+        candidates.RemoveAll(args.Invokers.Contains);
+
+        if (candidates.Count == 0)
+            return;
+
+        entMan.System<ADTRitualSummonSystem>().OpenPicker(args.Object, args.Invoker, candidates);
+    }
+}
diff --git a/Content.Shared/ADT/AshWalker/ADTAshWalkerEvents.cs b/Content.Shared/ADT/AshWalker/ADTAshWalkerEvents.cs
new file mode 100644
index 00000000000..902d414c848
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/ADTAshWalkerEvents.cs
@@ -0,0 +1,18 @@
+using Content.Shared.Actions;
+
+namespace Content.Shared.ADT.AshWalker;
+
+public sealed partial class ADTIgniteActionEvent : InstantActionEvent
+{
+}
+
+public sealed partial class ADTHealTouchActionEvent : EntityTargetActionEvent
+{
+}
+
+public sealed partial class ADTNecropolisCompassActionEvent : InstantActionEvent
+{
+}
+
+[ByRefEvent]
+public record struct ADTHealTouchUsedEvent(EntityUid User, bool Handled = false);
diff --git a/Content.Shared/ADT/AshWalker/ADTNecropolisCompassUi.cs b/Content.Shared/ADT/AshWalker/ADTNecropolisCompassUi.cs
new file mode 100644
index 00000000000..06ca0631ffc
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/ADTNecropolisCompassUi.cs
@@ -0,0 +1,32 @@
+using Content.Shared.ADT.UI;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.ADT.AshWalker;
+
+[Serializable, NetSerializable]
+public enum ADTNecropolisCompassUiKey : byte
+{
+    Key,
+}
+
+[Serializable, NetSerializable]
+public sealed class ADTNecropolisCompassBuiState : BoundUserInterfaceState
+{
+    public List<ADTEntityPickerEntry> Points;
+
+    public ADTNecropolisCompassBuiState(List<ADTEntityPickerEntry> points)
+    {
+        Points = points;
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed class ADTNecropolisCompassSelectMessage : BoundUserInterfaceMessage
+{
+    public NetEntity Point;
+
+    public ADTNecropolisCompassSelectMessage(NetEntity point)
+    {
+        Point = point;
+    }
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerComponent.cs
new file mode 100644
index 00000000000..29cfe2a6a41
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerComponent.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ADTAshWalkerComponent : Component
+{
+    [DataField]
+    public bool Shaman;
+
+    [DataField]
+    public bool BlockGuns = true;
+
+    [DataField]
+    public TimeSpan GunPopupCooldown = TimeSpan.FromSeconds(3);
+
+    [ViewVariables]
+    public TimeSpan NextGunPopup;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerEggComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerEggComponent.cs
new file mode 100644
index 00000000000..de58b681540
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerEggComponent.cs
@@ -0,0 +1,10 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ADTAshWalkerEggComponent : Component
+{
+    [DataField]
+    public bool Shaman;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerNestComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerNestComponent.cs
new file mode 100644
index 00000000000..98cd6a9a5f4
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTAshWalkerNestComponent.cs
@@ -0,0 +1,45 @@
+using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent]
+public sealed partial class ADTAshWalkerNestComponent : Component
+{
+    [DataField]
+    public int MeatCounter = 6;
+
+    [DataField]
+    public int MeatPerEgg = 2;
+
+    [DataField]
+    public int MeatPerBody = 1;
+
+    [DataField]
+    public int MeatPerMegafauna = 20;
+
+    [DataField]
+    public float ConsumeRange = 1.5f;
+
+    [DataField]
+    public float HealRange = 4f;
+
+    [DataField]
+    public FixedPoint2 SelfRepair = 10;
+
+    [DataField]
+    public DamageSpecifier AuraHealing = new();
+
+    [DataField]
+    public EntProtoId Egg = "ADTAshWalkerEgg";
+
+    [DataField]
+    public EntProtoId ShamanEgg = "ADTAshWalkerShamanEgg";
+
+    [DataField]
+    public TimeSpan Interval = TimeSpan.FromSeconds(1);
+
+    [ViewVariables]
+    public TimeSpan NextUpdate;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTHealTouchComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTHealTouchComponent.cs
new file mode 100644
index 00000000000..d6c2faf2994
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTHealTouchComponent.cs
@@ -0,0 +1,32 @@
+using Content.Shared.Damage;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTHealTouchComponent : Component
+{
+    [DataField]
+    public DamageSpecifier Healing = new()
+    {
+        DamageDict = new()
+        {
+            { "Blunt", -7 },
+            { "Slash", -7 },
+            { "Piercing", -6 },
+            { "Heat", -20 },
+            { "Poison", -10 },
+            { "Asphyxiation", -50 },
+        },
+    };
+
+    [DataField]
+    public bool CanHealSelf = true;
+
+    [DataField]
+    public EntProtoId ActionId = "ADTActionHealTouch";
+
+    [DataField, AutoNetworkedField]
+    public EntityUid? ActionEntity;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTIgniteComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTIgniteComponent.cs
new file mode 100644
index 00000000000..074c143ce39
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTIgniteComponent.cs
@@ -0,0 +1,17 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTIgniteComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public EntProtoId Blaze = "ADTAshWalkerSmallBlaze";
+
+    [DataField]
+    public EntProtoId ActionId = "ADTActionIgnite";
+
+    [DataField, AutoNetworkedField]
+    public EntityUid? ActionEntity;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTLavalandSpeedComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTLavalandSpeedComponent.cs
new file mode 100644
index 00000000000..ed15465bcf4
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTLavalandSpeedComponent.cs
@@ -0,0 +1,16 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTLavalandSpeedComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public float WalkModifier = 1.15f;
+
+    [DataField, AutoNetworkedField]
+    public float SprintModifier = 1.15f;
+
+    [DataField, AutoNetworkedField]
+    public bool Everywhere;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTNecropolisCompassComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTNecropolisCompassComponent.cs
new file mode 100644
index 00000000000..88f6692eb1b
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTNecropolisCompassComponent.cs
@@ -0,0 +1,17 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTNecropolisCompassComponent : Component
+{
+    [DataField]
+    public TimeSpan Delay = TimeSpan.FromSeconds(2);
+
+    [DataField]
+    public EntProtoId ActionId = "ADTActionNecropolisCompass";
+
+    [DataField, AutoNetworkedField]
+    public EntityUid? ActionEntity;
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTPointOfInterestComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTPointOfInterestComponent.cs
new file mode 100644
index 00000000000..3823cb975a5
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTPointOfInterestComponent.cs
@@ -0,0 +1,11 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Localization;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTPointOfInterestComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public LocId Title = "adt-point-of-interest-generic";
+}
diff --git a/Content.Shared/ADT/AshWalker/Components/ADTSmallBlazeComponent.cs b/Content.Shared/ADT/AshWalker/Components/ADTSmallBlazeComponent.cs
new file mode 100644
index 00000000000..ad70b2199b4
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Components/ADTSmallBlazeComponent.cs
@@ -0,0 +1,8 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.ADT.AshWalker.Components;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ADTSmallBlazeComponent : Component
+{
+}
diff --git a/Content.Shared/ADT/AshWalker/Systems/ADTAshWalkerSystem.cs b/Content.Shared/ADT/AshWalker/Systems/ADTAshWalkerSystem.cs
new file mode 100644
index 00000000000..dd775838820
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Systems/ADTAshWalkerSystem.cs
@@ -0,0 +1,39 @@
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.Popups;
+using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.ADT.AshWalker.Systems;
+
+public sealed class ADTAshWalkerSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTAshWalkerComponent, ShotAttemptedEvent>(OnShotAttempted);
+    }
+
+    private void OnShotAttempted(Entity<ADTAshWalkerComponent> ent, ref ShotAttemptedEvent args)
+    {
+        if (!ent.Comp.BlockGuns)
+            return;
+
+        if (args.Cancelled)
+            return;
+
+        args.Cancel();
+
+        if (!_timing.IsFirstTimePredicted)
+            return;
+
+        if (_timing.CurTime < ent.Comp.NextGunPopup)
+            return;
+
+        ent.Comp.NextGunPopup = _timing.CurTime + ent.Comp.GunPopupCooldown;
+        _popup.PopupClient(Loc.GetString("adt-ash-walker-no-guns"), ent.Owner, ent.Owner);
+    }
+}
diff --git a/Content.Shared/ADT/AshWalker/Systems/ADTLavalandSpeedSystem.cs b/Content.Shared/ADT/AshWalker/Systems/ADTLavalandSpeedSystem.cs
new file mode 100644
index 00000000000..7d35016dbc5
--- /dev/null
+++ b/Content.Shared/ADT/AshWalker/Systems/ADTLavalandSpeedSystem.cs
@@ -0,0 +1,51 @@
+using Content.Shared.ADT.AshWalker.Components;
+using Content.Shared.ADT.Lavaland;
+using Content.Shared.Movement.Systems;
+
+namespace Content.Shared.ADT.AshWalker.Systems;
+
+public sealed class ADTLavalandSpeedSystem : EntitySystem
+{
+    [Dependency] private readonly MovementSpeedModifierSystem _movement = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ADTLavalandSpeedComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshSpeed);
+        SubscribeLocalEvent<ADTLavalandSpeedComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ADTLavalandSpeedComponent, EntParentChangedMessage>(OnParentChanged);
+    }
+
+    private void OnRefreshSpeed(Entity<ADTLavalandSpeedComponent> ent, ref RefreshMovementSpeedModifiersEvent args)
+    {
+        if (!IsBonusActive(ent))
+            return;
+
+        args.ModifySpeed(ent.Comp.WalkModifier, ent.Comp.SprintModifier);
+    }
+
+    private void OnMapInit(Entity<ADTLavalandSpeedComponent> ent, ref MapInitEvent args)
+    {
+        _movement.RefreshMovementSpeedModifiers(ent.Owner);
+    }
+
+    private void OnParentChanged(Entity<ADTLavalandSpeedComponent> ent, ref EntParentChangedMessage args)
+    {
+        if (args.OldMapId == Transform(ent.Owner).MapUid)
+            return;
+
+        _movement.RefreshMovementSpeedModifiers(ent.Owner);
+    }
+
+    private bool IsBonusActive(Entity<ADTLavalandSpeedComponent> ent)
+    {
+        if (ent.Comp.Everywhere)
+            return true;
+
+        if (Transform(ent.Owner).MapUid is not { } map)
+            return false;
+
+        return HasComp<ADTLavalandMapComponent>(map);
+    }
+}
diff --git a/Content.Shared/ADT/Lavaland/ADTLavalandMapComponent.cs b/Content.Shared/ADT/Lavaland/ADTLavalandMapComponent.cs
new file mode 100644
index 00000000000..10c047c0bac
--- /dev/null
+++ b/Content.Shared/ADT/Lavaland/ADTLavalandMapComponent.cs
@@ -0,0 +1,8 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.ADT.Lavaland;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ADTLavalandMapComponent : Component
+{
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualDoAfterEvent.cs b/Content.Shared/ADT/Rituals/ADTRitualDoAfterEvent.cs
new file mode 100644
index 00000000000..ea7795fef72
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualDoAfterEvent.cs
@@ -0,0 +1,9 @@
+using Content.Shared.DoAfter;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.ADT.Rituals;
+
+[Serializable, NetSerializable]
+public sealed partial class ADTRitualDoAfterEvent : SimpleDoAfterEvent
+{
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualEffect.cs b/Content.Shared/ADT/Rituals/ADTRitualEffect.cs
new file mode 100644
index 00000000000..0dc62fe3946
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualEffect.cs
@@ -0,0 +1,20 @@
+namespace Content.Shared.ADT.Rituals;
+
+public readonly record struct ADTRitualArgs(
+    EntityUid Object,
+    ADTRitualPrototype Ritual,
+    EntityUid Invoker,
+    IReadOnlyList<EntityUid> Invokers,
+    IReadOnlyList<EntityUid> UsedThings);
+
+[ImplicitDataDefinitionForInheritors]
+public abstract partial class ADTRitualEffect
+{
+    public abstract void Effect(IEntityManager entMan, ADTRitualArgs args);
+}
+
+[ImplicitDataDefinitionForInheritors]
+public abstract partial class ADTRitualCheck
+{
+    public abstract bool Check(IEntityManager entMan, ADTRitualArgs args, out string? reason);
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualModifier.cs b/Content.Shared/ADT/Rituals/ADTRitualModifier.cs
new file mode 100644
index 00000000000..6e1c511efba
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualModifier.cs
@@ -0,0 +1,7 @@
+namespace Content.Shared.ADT.Rituals;
+
+[ImplicitDataDefinitionForInheritors]
+public abstract partial class ADTRitualModifier
+{
+    public abstract void Apply(IEntityManager entMan, ADTRitualArgs args, ref float fail, ref float disaster);
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualPrototype.cs b/Content.Shared/ADT/Rituals/ADTRitualPrototype.cs
new file mode 100644
index 00000000000..390af4717c9
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualPrototype.cs
@@ -0,0 +1,107 @@
+using Content.Shared.Humanoid.Prototypes;
+using Content.Shared.Whitelist;
+using Robust.Shared.Audio;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.Rituals;
+
+[Prototype("adtRitual")]
+public sealed partial class ADTRitualPrototype : IPrototype
+{
+    [IdDataField]
+    public string ID { get; private set; } = default!;
+
+    [DataField(required: true)]
+    public List<string> Categories = new();
+
+    [DataField(required: true)]
+    public LocId Name = default!;
+
+    [DataField]
+    public LocId? Description;
+
+    [DataField]
+    public LocId? DyeFluff;
+
+    [DataField]
+    public int ExtraInvokers;
+
+    [DataField]
+    public int ExtraShamanInvokers;
+
+    [DataField]
+    public bool ShamanOnly;
+
+    [DataField]
+    public List<ProtoId<SpeciesPrototype>> AllowedSpecies = new();
+
+    [DataField]
+    public List<ADTRitualThing> RequiredThings = new();
+
+    [DataField]
+    public float FindingRange = 2f;
+
+    [DataField]
+    public int Charges = -1;
+
+    [DataField]
+    public TimeSpan Cooldown = TimeSpan.FromSeconds(100);
+
+    [DataField]
+    public TimeSpan CastTime;
+
+    [DataField]
+    public float FailChance = 0.1f;
+
+    [DataField]
+    public float DisasterChance = 0.1f;
+
+    [DataField]
+    public string? NeededDye;
+
+    [DataField]
+    public string? TotemDye;
+
+    [DataField]
+    public bool DeleteThingsOnSuccess = true;
+
+    [DataField]
+    public bool DeleteThingsOnFail;
+
+    [DataField(serverOnly: true)]
+    public List<ADTRitualCheck> Checks = new();
+
+    [DataField(serverOnly: true)]
+    public List<ADTRitualModifier> Modifiers = new();
+
+    [DataField(serverOnly: true)]
+    public List<ADTRitualEffect> Effects = new();
+
+    [DataField(serverOnly: true)]
+    public List<ADTRitualEffect> DisasterEffects = new();
+
+    [DataField]
+    public SoundSpecifier StartSound = new SoundCollectionSpecifier("ADTRitualStart");
+
+    [DataField]
+    public SoundSpecifier SuccessSound = new SoundCollectionSpecifier("ADTRitualSuccess");
+
+    [DataField]
+    public SoundSpecifier FailSound = new SoundCollectionSpecifier("ADTRitualFail");
+}
+
+[DataDefinition]
+public sealed partial class ADTRitualThing
+{
+    [DataField(required: true)]
+    public EntityWhitelist Whitelist = default!;
+
+    [DataField]
+    public int Amount = 1;
+
+    [DataField]
+    public bool Consume = true;
+
+    [DataField(required: true)]
+    public LocId Name = default!;
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualSummonUi.cs b/Content.Shared/ADT/Rituals/ADTRitualSummonUi.cs
new file mode 100644
index 00000000000..b5fedd89549
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualSummonUi.cs
@@ -0,0 +1,32 @@
+using Content.Shared.ADT.UI;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.ADT.Rituals;
+
+[Serializable, NetSerializable]
+public enum ADTRitualSummonUiKey : byte
+{
+    Key,
+}
+
+[Serializable, NetSerializable]
+public sealed class ADTRitualSummonBuiState : BoundUserInterfaceState
+{
+    public List<ADTEntityPickerEntry> Candidates;
+
+    public ADTRitualSummonBuiState(List<ADTEntityPickerEntry> candidates)
+    {
+        Candidates = candidates;
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed class ADTRitualSummonSelectMessage : BoundUserInterfaceMessage
+{
+    public NetEntity Target;
+
+    public ADTRitualSummonSelectMessage(NetEntity target)
+    {
+        Target = target;
+    }
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualTarget.cs b/Content.Shared/ADT/Rituals/ADTRitualTarget.cs
new file mode 100644
index 00000000000..9eac7849762
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualTarget.cs
@@ -0,0 +1,13 @@
+namespace Content.Shared.ADT.Rituals;
+
+public enum ADTRitualTarget : byte
+{
+    Invoker,
+    Invokers,
+    UsedThings,
+    Tribe,
+    RandomTribesman,
+    Outsiders,
+    RandomOutsider,
+    InRange,
+}
diff --git a/Content.Shared/ADT/Rituals/ADTRitualUi.cs b/Content.Shared/ADT/Rituals/ADTRitualUi.cs
new file mode 100644
index 00000000000..59f3d5abcb8
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/ADTRitualUi.cs
@@ -0,0 +1,60 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.ADT.Rituals;
+
+[Serializable, NetSerializable]
+public enum ADTRitualUiKey : byte
+{
+    Key,
+}
+
+[Serializable, NetSerializable]
+public struct ADTRitualEntry
+{
+    public ProtoId<ADTRitualPrototype> Ritual;
+
+    public int Charges;
+
+    public TimeSpan CooldownEnd;
+
+    public ADTRitualEntry(ProtoId<ADTRitualPrototype> ritual, int charges, TimeSpan cooldownEnd)
+    {
+        Ritual = ritual;
+        Charges = charges;
+        CooldownEnd = cooldownEnd;
+    }
+
+    public readonly int CooldownLeft(TimeSpan now)
+    {
+        var left = CooldownEnd - now;
+        return left <= TimeSpan.Zero ? 0 : (int)Math.Ceiling(left.TotalSeconds);
+    }
+
+    public readonly bool Available(TimeSpan now) => Charges != 0 && CooldownLeft(now) <= 0;
+}
+
+[Serializable, NetSerializable]
+public sealed class ADTRitualBuiState : BoundUserInterfaceState
+{
+    public List<ADTRitualEntry> Rituals;
+
+    public bool Busy;
+
+    public ADTRitualBuiState(List<ADTRitualEntry> rituals, bool busy)
+    {
+        Rituals = rituals;
+        Busy = busy;
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed class ADTRitualStartMessage : BoundUserInterfaceMessage
+{
+    public ProtoId<ADTRitualPrototype> Ritual;
+
+    public ADTRitualStartMessage(ProtoId<ADTRitualPrototype> ritual)
+    {
+        Ritual = ritual;
+    }
+}
diff --git a/Content.Shared/ADT/Rituals/Components/ADTAshSigilComponent.cs b/Content.Shared/ADT/Rituals/Components/ADTAshSigilComponent.cs
new file mode 100644
index 00000000000..577406560e2
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/Components/ADTAshSigilComponent.cs
@@ -0,0 +1,33 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.Rituals;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTAshSigilComponent : Component
+{
+    [DataField]
+    public EntProtoId Rune = "ADTAshRune";
+
+    [DataField]
+    public EntProtoId? ActivationEffect = "ADTAshRuneActivation";
+
+    [DataField]
+    public TimeSpan ActivationDelay = TimeSpan.FromSeconds(3);
+
+    [DataField]
+    public TimeSpan? ActivateAt;
+
+    [DataField]
+    public float MarkRange = 3f;
+
+    [DataField, AutoNetworkedField]
+    public bool Transforming;
+}
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(raiseAfterAutoHandleState: true)]
+public sealed partial class ADTAshRuneMarkComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public bool Lit;
+}
diff --git a/Content.Shared/ADT/Rituals/Components/ADTDyedComponent.cs b/Content.Shared/ADT/Rituals/Components/ADTDyedComponent.cs
new file mode 100644
index 00000000000..33c98b3240a
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/Components/ADTDyedComponent.cs
@@ -0,0 +1,15 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.ADT.Rituals;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class ADTDyedComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public string? Dye;
+}
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ADTRitualTotemComponent : Component
+{
+}
diff --git a/Content.Shared/ADT/Rituals/Components/ADTRitualObjectComponent.cs b/Content.Shared/ADT/Rituals/Components/ADTRitualObjectComponent.cs
new file mode 100644
index 00000000000..77c8e8e2c34
--- /dev/null
+++ b/Content.Shared/ADT/Rituals/Components/ADTRitualObjectComponent.cs
@@ -0,0 +1,29 @@
+using Content.Shared.Humanoid.Prototypes;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.ADT.Rituals;
+
+[RegisterComponent]
+public sealed partial class ADTRitualObjectComponent : Component
+{
+    [DataField(required: true)]
+    public List<string> Categories = new();
+
+    [DataField]
+    public List<ProtoId<SpeciesPrototype>> AllowedSpecies = new();
+
+    [DataField]
+    public Dictionary<ProtoId<ADTRitualPrototype>, int> Charges = new();
+
+    [DataField]
+    public Dictionary<ProtoId<ADTRitualPrototype>, TimeSpan> Cooldowns = new();
+
+    [DataField]
+    public EntProtoId? FinaleEffect = "ADTAshRuneActivation";
+
+    [DataField]
+    public TimeSpan FinaleDelay = TimeSpan.FromSeconds(3);
+
+    [ViewVariables]
+    public bool Busy;
+}
diff --git a/Content.Shared/ADT/UI/ADTEntityPickerEntry.cs b/Content.Shared/ADT/UI/ADTEntityPickerEntry.cs
new file mode 100644
index 00000000000..406605df967
--- /dev/null
+++ b/Content.Shared/ADT/UI/ADTEntityPickerEntry.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.ADT.UI;
+
+[Serializable, NetSerializable]
+public struct ADTEntityPickerEntry
+{
+    public NetEntity Entity;
+    public string Name;
+    public EntProtoId? Proto;
+
+    public ADTEntityPickerEntry(NetEntity entity, string name, EntProtoId? proto)
+    {
+        Entity = entity;
+        Name = name;
+        Proto = proto;
+    }
+}
diff --git a/Resources/Audio/ADT/Rituals/attributions.yml b/Resources/Audio/ADT/Rituals/attributions.yml
new file mode 100644
index 00000000000..35d0f80ed2b
--- /dev/null
+++ b/Resources/Audio/ADT/Rituals/attributions.yml
@@ -0,0 +1,11 @@
+- files:
+  - ritual_start1.ogg
+  - ritual_start2.ogg
+  - ritual_start3.ogg
+  - ritual_success1.ogg
+  - ritual_success2.ogg
+  - ritual_fail1.ogg
+  - ritual_fail2.ogg
+  license: "CC-BY-SA-3.0"
+  copyright: "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/tree/master/sound/rituals"
+  source: "https://github.com/ParadiseSS13/Paradise"
diff --git a/Resources/Audio/ADT/Rituals/ritual_fail1.ogg b/Resources/Audio/ADT/Rituals/ritual_fail1.ogg
new file mode 100644
index 00000000000..317adce4d2d
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_fail1.ogg differ
diff --git a/Resources/Audio/ADT/Rituals/ritual_fail2.ogg b/Resources/Audio/ADT/Rituals/ritual_fail2.ogg
new file mode 100644
index 00000000000..b536a4c20fb
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_fail2.ogg differ
diff --git a/Resources/Audio/ADT/Rituals/ritual_start1.ogg b/Resources/Audio/ADT/Rituals/ritual_start1.ogg
new file mode 100644
index 00000000000..874d10a07bd
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_start1.ogg differ
diff --git a/Resources/Audio/ADT/Rituals/ritual_start2.ogg b/Resources/Audio/ADT/Rituals/ritual_start2.ogg
new file mode 100644
index 00000000000..46260e098d7
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_start2.ogg differ
diff --git a/Resources/Audio/ADT/Rituals/ritual_start3.ogg b/Resources/Audio/ADT/Rituals/ritual_start3.ogg
new file mode 100644
index 00000000000..fb3d9ed4dfc
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_start3.ogg differ
diff --git a/Resources/Audio/ADT/Rituals/ritual_success1.ogg b/Resources/Audio/ADT/Rituals/ritual_success1.ogg
new file mode 100644
index 00000000000..bb0c4d879a1
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_success1.ogg differ
diff --git a/Resources/Audio/ADT/Rituals/ritual_success2.ogg b/Resources/Audio/ADT/Rituals/ritual_success2.ogg
new file mode 100644
index 00000000000..2de27d3e1d5
Binary files /dev/null and b/Resources/Audio/ADT/Rituals/ritual_success2.ogg differ
diff --git a/Resources/Locale/ru-RU/ADT/prototypes/Entities/Structures/Specific/ash_flora.ftl b/Resources/Locale/ru-RU/ADT/prototypes/Entities/Structures/Specific/ash_flora.ftl
index 82947e47a1d..2ce348ce950 100644
--- a/Resources/Locale/ru-RU/ADT/prototypes/Entities/Structures/Specific/ash_flora.ftl
+++ b/Resources/Locale/ru-RU/ADT/prototypes/Entities/Structures/Specific/ash_flora.ftl
@@ -104,3 +104,24 @@ ent-ADTLavaCactusThreeEmpty = { ent-ADTLavaCactusOneEmpty }
     .desc = { ent-ADTLavaCactusOneEmpty.desc }
 ent-ADTLavaCactusFourEmpty = { ent-ADTLavaCactusOneEmpty }
     .desc = { ent-ADTLavaCactusOneEmpty.desc }
+
+adt-ash-flora-fireblossom-low = Вы срываете единственный уцелевший цветок.
+adt-ash-flora-fireblossom-medium = Вы срываете пару цветков, стараясь не обжечься.
+adt-ash-flora-fireblossom-high = Вы срываете целую горсть раскалённых цветков.
+
+ent-ADTAshFloraFireblossom1 = огнецвет
+    .desc = Ярко-красные цветы, от которых тянет сухим жаром.
+ent-ADTAshFloraFireblossom2 = { ent-ADTAshFloraFireblossom1 }
+    .desc = { ent-ADTAshFloraFireblossom1.desc }
+ent-ADTAshFloraFireblossom3 = { ent-ADTAshFloraFireblossom1 }
+    .desc = { ent-ADTAshFloraFireblossom1.desc }
+ent-ADTAshFloraFireblossom4 = { ent-ADTAshFloraFireblossom1 }
+    .desc = { ent-ADTAshFloraFireblossom1.desc }
+ent-ADTAshFloraFireblossomHarvested1 = огнецвет
+    .desc = Несколько ощипанных стеблей. На них уже набухают новые цветы.
+ent-ADTAshFloraFireblossomHarvested2 = { ent-ADTAshFloraFireblossomHarvested1 }
+    .desc = { ent-ADTAshFloraFireblossomHarvested1.desc }
+ent-ADTAshFloraFireblossomHarvested3 = { ent-ADTAshFloraFireblossomHarvested1 }
+    .desc = { ent-ADTAshFloraFireblossomHarvested1.desc }
+ent-ADTAshFloraFireblossomHarvested4 = { ent-ADTAshFloraFireblossomHarvested1 }
+    .desc = { ent-ADTAshFloraFireblossomHarvested1.desc }
diff --git a/Resources/Prototypes/ADT/Body/Species/ashwalker.yml b/Resources/Prototypes/ADT/Body/Species/ashwalker.yml
new file mode 100644
index 00000000000..67460f5a6cb
--- /dev/null
+++ b/Resources/Prototypes/ADT/Body/Species/ashwalker.yml
@@ -0,0 +1,345 @@
+- type: entity
+  abstract: true
+  save: false
+  parent: BaseSpeciesMobOrganic
+  id: ADTMobAshWalkerBase
+  components:
+  - type: BreathingImmunity
+  - type: ADTIgnite
+  - type: ADTLavalandSpeed
+  - type: NpcFactionMember
+    factions:
+    - ADTAshWalker
+  - type: TemperatureDamage
+    heatDamageThreshold: 420
+    coldDamageThreshold: 285
+    coldDamage:
+      types:
+        Cold: 0.1
+    heatDamage:
+      types:
+        Heat: 1.5
+  - type: LanguageSpeaker
+    languages:
+      Draconic: Speak
+  - type: LizardAccent
+  - type: Speech
+    speechSounds: Lizard
+    speechVerb: Reptilian
+    allowedEmotes: ['Thump']
+  - type: Vocal
+    sounds:
+      Male: MaleReptilian
+      Female: FemaleReptilian
+      Unsexed: MaleReptilian
+  - type: BodyEmotes
+    soundsId: ReptilianBodyEmotes
+  - type: TypingIndicator
+    proto: lizard
+  - type: CreamPied
+    sprite:
+      sprite: Effects/creampie.rsi
+      state: creampie_lizard
+  - type: Wagging
+  - type: InjectorsBlocker
+  - type: Butcherable
+    butcheringType: Spike
+    spawned:
+    - id: FoodMeatLizard
+      amount: 5
+  - type: MeleeWeapon
+    soundHit:
+      collection: AlienClaw
+    angle: 30
+    animation: WeaponArcClaw
+    damage:
+      types:
+        Slash: 5
+  - type: Puller
+    needsHands: false
+  - type: Injurable
+  - type: DamageVisuals
+    damageOverlayGroups:
+      Brute:
+        sprite: Mobs/Effects/brute_damage.rsi
+        color: "#800000"
+      Burn:
+        sprite: Mobs/Effects/burn_damage.rsi
+  - type: PassiveDamage
+    allowedStates:
+    - Alive
+    damage:
+      types:
+        Cold: -0.05
+        Blunt: -0.05
+        Piercing: -0.05
+        Slash: -0.05
+  - type: SlowOnDamage
+    speedModifierThresholds:
+      55: 0.8
+      75: 0.7
+  - type: Temperature
+    currentTemperature: 310.15
+    specificHeat: 42
+  - type: TemperatureSpeed
+    thresholds:
+      301: 0.9
+      295: 0.8
+      285: 0.7
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeCircle
+          radius: 0.35
+        density: 215
+        restitution: 0.0
+        mask:
+          - MobMask
+        layer:
+          - MobLayer
+  - type: Sprite
+    scale: 1.05, 1.05
+  - type: SizeAttributeWhitelist
+    tall: true
+    tallscale: 1.12
+    short: true
+    shortscale: 0.98
+
+- type: entity
+  parent: AppearanceReptilian
+  id: ADTAppearanceAshWalker
+  categories: [ HideSpawnMenu ]
+  name: ash walker appearance
+  components:
+  - type: HumanoidProfile
+    species: ADTAshWalkerSpecies
+
+- type: entity
+  save: false
+  name: ash walker
+  parent:
+  - ADTMobAshWalkerBase
+  - ADTAppearanceAshWalker
+  id: ADTMobAshWalker
+  components:
+  - type: RandomHumanoidAppearance
+  - type: ADTAshWalker
+  - type: Damageable
+    damageModifierSet: ADTAshWalkerScale
+
+- type: entity
+  save: false
+  parent: ADTMobAshWalker
+  id: ADTMobAshWalkerHatched
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: Loadout
+    prototypes: [ ADTAshWalkerGear ]
+
+- type: entity
+  parent: AppearanceReptilian
+  id: ADTAppearanceAshWalkerShaman
+  categories: [ HideSpawnMenu ]
+  name: ash walker shaman appearance
+  components:
+  - type: HumanoidProfile
+    species: ADTAshWalkerShamanSpecies
+
+- type: entity
+  save: false
+  name: ash walker shaman
+  parent:
+  - ADTMobAshWalkerBase
+  - ADTAppearanceAshWalkerShaman
+  id: ADTMobAshWalkerShaman
+  components:
+  - type: RandomHumanoidAppearance
+  - type: ADTAshWalker
+    shaman: true
+  - type: ADTLavalandSpeed
+    walkModifier: 1.11
+    sprintModifier: 1.11
+  - type: ADTHealTouch
+  - type: ADTNecropolisCompass
+  - type: UserInterface
+    interfaces:
+      enum.ADTNecropolisCompassUiKey.Key:
+        type: ADTNecropolisCompassBoundUserInterface
+  - type: Damageable
+    damageModifierSet: ADTAshWalkerShamanScale
+
+- type: entity
+  save: false
+  parent: ADTMobAshWalkerShaman
+  id: ADTMobAshWalkerShamanHatched
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: Loadout
+    prototypes: [ ADTAshWalkerShamanGear ]
+
+- type: entity
+  parent: OrganReptilianTorso
+  id: ADTOrganDraconidTorso
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianHead
+  id: ADTOrganDraconidHead
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+  - type: VisualOrganMarkings
+    markings:
+      HeadTop:
+      - markingId: LizardHornsDemonic
+        markingColor:
+        - "#110101"
+
+- type: entity
+  parent: OrganReptilianArmLeft
+  id: ADTOrganDraconidArmLeft
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianArmRight
+  id: ADTOrganDraconidArmRight
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianHandLeft
+  id: ADTOrganDraconidHandLeft
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianHandRight
+  id: ADTOrganDraconidHandRight
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianLegLeft
+  id: ADTOrganDraconidLegLeft
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianLegRight
+  id: ADTOrganDraconidLegRight
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianFootLeft
+  id: ADTOrganDraconidFootLeft
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianFootRight
+  id: ADTOrganDraconidFootRight
+  components:
+  - type: VisualOrgan
+    profile:
+      skinColor: "#110101"
+
+- type: entity
+  parent: OrganReptilianEyes
+  id: ADTOrganDraconidEyes
+  components:
+  - type: VisualOrgan
+    profile:
+      eyeColor: "#A02720"
+      skinColor: "#110101"
+
+- type: entity
+  parent: AppearanceReptilian
+  id: ADTAppearanceDraconid
+  categories: [ HideSpawnMenu ]
+  name: draconid appearance
+  components:
+  - type: HumanoidProfile
+    species: ADTDraconidSpecies
+  - type: InitialBody
+    organs:
+      Torso: ADTOrganDraconidTorso
+      Head: ADTOrganDraconidHead
+      ArmLeft: ADTOrganDraconidArmLeft
+      ArmRight: ADTOrganDraconidArmRight
+      HandLeft: ADTOrganDraconidHandLeft
+      HandRight: ADTOrganDraconidHandRight
+      LegLeft: ADTOrganDraconidLegLeft
+      LegRight: ADTOrganDraconidLegRight
+      FootLeft: ADTOrganDraconidFootLeft
+      FootRight: ADTOrganDraconidFootRight
+      Eyes: ADTOrganDraconidEyes
+      Brain: OrganReptilianBrain
+      Tongue: OrganReptilianTongue
+      Appendix: OrganReptilianAppendix
+      Ears: OrganReptilianEars
+      Lungs: OrganReptilianLungs
+      Heart: OrganReptilianHeart
+      Stomach: OrganReptilianStomach
+      Liver: OrganReptilianLiver
+      Kidneys: OrganReptilianKidneys
+
+- type: entity
+  save: false
+  name: Urist Mc'Drake
+  parent:
+  - MobReptilian
+  - ADTAppearanceDraconid
+  id: ADTMobDraconid
+  components:
+  - type: ADTLavalandSpeed
+    everywhere: true
+    walkModifier: 1.08
+    sprintModifier: 1.08
+  - type: ADTIgnite
+  - type: BreathingImmunity
+  - type: AshStormImmune
+  - type: Inventory
+    templateId: ADTDraconid
+  - type: NpcFactionMember
+    factions:
+    - ADTAshWalker
+  - type: Damageable
+    damageModifierSet: ADTDraconidScale
+  - type: MeleeWeapon
+    soundHit:
+      collection: AlienClaw
+    angle: 30
+    animation: WeaponArcClaw
+    damage:
+      types:
+        Slash: 12
+  - type: TemperatureDamage
+    heatDamageThreshold: 1000
+    coldDamageThreshold: 285
+    coldDamage:
+      types:
+        Cold: 0.1
+    heatDamage:
+      types:
+        Heat: 1.5
diff --git a/Resources/Prototypes/ADT/Damage/modifier_sets.yml b/Resources/Prototypes/ADT/Damage/modifier_sets.yml
index 964ff91d553..98c8e56cfe5 100644
--- a/Resources/Prototypes/ADT/Damage/modifier_sets.yml
+++ b/Resources/Prototypes/ADT/Damage/modifier_sets.yml
@@ -338,6 +338,39 @@
     Heat: 5
     Structural: 15
 
+- type: damageModifierSet
+  id: ADTAshWalkerScale
+  coefficients:
+    Blunt: 0.9
+    Slash: 0.9
+    Piercing: 0.9
+    Cold: 1.3
+
+- type: damageModifierSet
+  id: ADTAshWalkerShamanScale
+  coefficients:
+    Blunt: 1.15
+    Slash: 1.15
+    Piercing: 1.15
+    Heat: 1.15
+    Cold: 1.3
+
+- type: damageModifierSet
+  id: ADTNecropolisFlesh
+  coefficients:
+    Heat: 0
+    Cold: 0
+    Caustic: 0.5
+
+- type: damageModifierSet
+  id: ADTDraconidScale
+  coefficients:
+    Blunt: 0.8
+    Slash: 0.8
+    Piercing: 0.8
+    Heat: 0.9
+    Cold: 1.3
+
 - type: damageModifierSet
   id: DiceOfFateMod
   coefficients:
@@ -351,4 +384,4 @@
     Asphyxiation: 0.5
     Bloodloss: 0.5
     Cellular: 0.5
-    Caustic: 0.5
\ No newline at end of file
+    Caustic: 0.5
diff --git a/Resources/Prototypes/ADT/Entities/Clothing/ashwalker.yml b/Resources/Prototypes/ADT/Entities/Clothing/ashwalker.yml
new file mode 100644
index 00000000000..75bb12f4cad
--- /dev/null
+++ b/Resources/Prototypes/ADT/Entities/Clothing/ashwalker.yml
@@ -0,0 +1,83 @@
+- type: entity
+  parent: UnsensoredClothingUniformBase
+  id: ADTClothingUniformAshWalker
+  name: ash-walker uniform
+  description: Simple but sturdy ash-soaked cloth. The seams carry tribal marks and the frayed edges look like they have seen more than one eruption.
+  components:
+  - type: Sprite
+    sprite: ADT/Clothing/Uniforms/ashwalker.rsi
+  - type: Clothing
+    sprite: ADT/Clothing/Uniforms/ashwalker.rsi
+
+- type: entity
+  parent: UnsensoredClothingUniformBase
+  id: ADTClothingUniformAshWalkerShaman
+  name: shaman tribal rags
+  description: Ash-soaked rags from Lazis, hung with bone trinkets and rough gemstones at the neck. This one is meant for the tribe's shaman.
+  components:
+  - type: Sprite
+    sprite: ADT/Clothing/Uniforms/ashwalker_shaman.rsi
+  - type: Clothing
+    sprite: ADT/Clothing/Uniforms/ashwalker_shaman.rsi
+
+- type: entity
+  parent: ClothingHeadBase
+  id: ADTClothingHeadRoach
+  name: roach
+  description: The mark of a tribe's shaman, telling them apart from their kin at a glance. Miners prize it as a trophy.
+  components:
+  - type: Sprite
+    sprite: ADT/Clothing/Head/roach.rsi
+  - type: Clothing
+    sprite: ADT/Clothing/Head/roach.rsi
+
+- type: entity
+  parent: ClothingNeckBase
+  id: ADTClothingNeckHideMantle
+  name: hide mantle
+  description: A rather grim assortment of cured hides sewn together into a ragged mantle.
+  components:
+  - type: Sprite
+    sprite: ADT/Clothing/Neck/hide_mantle.rsi
+  - type: Clothing
+    sprite: ADT/Clothing/Neck/hide_mantle.rsi
+
+- type: entity
+  parent: ClothingHandsBase
+  id: ADTClothingHandsGoliathGloves
+  name: goliath gloves
+  description: Primitive gloves that make carrying things easier.
+  components:
+  - type: Sprite
+    sprite: ADT/Clothing/Hands/goliath_gloves.rsi
+  - type: Clothing
+    sprite: ADT/Clothing/Hands/goliath_gloves.rsi
+  - type: Armor
+    modifiers:
+      coefficients:
+        Blunt: 0.8
+        Slash: 0.8
+        Piercing: 0.9
+        Heat: 0.5
+        Caustic: 0.5
+  - type: GroupExamine
+
+- type: entity
+  parent: ClothingBeltStorageBase
+  id: ADTMedPouch
+  name: medicinal pouch
+  description: A small pouch for herbs, poultices, bait and other odds and ends.
+  components:
+  - type: Sprite
+    sprite: ADT/Clothing/Belt/medpouch.rsi
+  - type: Storage
+    grid:
+    - 0,0,5,3
+    whitelist:
+      tags:
+      - Brutepack
+      - Ointment
+      - Gauze
+      - Bloodpack
+      - Fruit
+      - Vegetable
diff --git a/Resources/Prototypes/ADT/Entities/Effects/ash_rune.yml b/Resources/Prototypes/ADT/Entities/Effects/ash_rune.yml
new file mode 100644
index 00000000000..4e1a8e21580
--- /dev/null
+++ b/Resources/Prototypes/ADT/Entities/Effects/ash_rune.yml
@@ -0,0 +1,166 @@
+- type: entity
+  id: ADTAshSigil
+  name: ash sigil
+  description: An unfinished rune drawn in the ash.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+    noRot: true
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Sprite
+    sprite: ADT/Effects/ash_runes.rsi
+    drawdepth: FloorObjects
+    noRot: true
+    layers:
+    - map: [ "base" ]
+      state: runaash_1
+  - type: RandomSprite
+    available:
+    - base:
+        runaash_1: ""
+        runaash_2: ""
+        runaash_3: ""
+        runaash_4: ""
+        runaash_5: ""
+        runaash_6: ""
+        runaash_7: ""
+        runaash_8: ""
+        runaash_9: ""
+        runaash_10: ""
+        runaash_11: ""
+        runaash_12: ""
+        runaash_13: ""
+        runaash_14: ""
+        runaash_15: ""
+        runaash_16: ""
+        runaash_17: ""
+        runaash_18: ""
+        runaash_19: ""
+        runaash_20: ""
+        runaash_21: ""
+        runaash_22: ""
+        runaash_23: ""
+        runaash_24: ""
+        runaash_25: ""
+        runaash_26: ""
+        runaash_27: ""
+        runaash_28: ""
+        runaash_29: ""
+        runaash_30: ""
+        runaash_31: ""
+        runaash_32: ""
+        runaash_33: ""
+        runaash_34: ""
+        runaash_35: ""
+        runaash_36: ""
+  - type: ADTAshSigil
+
+- type: entity
+  id: ADTAshRuneMark
+  name: ash rune
+  description: A fully functioning rune, ready for ritual work.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+    noRot: true
+  - type: Sprite
+    sprite: ADT/Effects/ash_runes.rsi
+    drawdepth: FloorObjects
+    noRot: true
+    visible: false
+    layers:
+    - map: [ "base" ]
+      state: runaash_2
+  - type: RandomSprite
+    available:
+    - base:
+        runaash_1: ""
+        runaash_2: ""
+        runaash_3: ""
+        runaash_4: ""
+        runaash_5: ""
+        runaash_6: ""
+        runaash_7: ""
+        runaash_8: ""
+        runaash_9: ""
+        runaash_10: ""
+        runaash_11: ""
+        runaash_12: ""
+        runaash_13: ""
+        runaash_14: ""
+        runaash_15: ""
+        runaash_16: ""
+        runaash_17: ""
+        runaash_18: ""
+        runaash_19: ""
+        runaash_20: ""
+        runaash_21: ""
+        runaash_22: ""
+        runaash_23: ""
+        runaash_24: ""
+        runaash_25: ""
+        runaash_26: ""
+        runaash_27: ""
+        runaash_28: ""
+        runaash_29: ""
+        runaash_30: ""
+        runaash_31: ""
+        runaash_32: ""
+        runaash_33: ""
+        runaash_34: ""
+        runaash_35: ""
+        runaash_36: ""
+  - type: ADTAshRuneMark
+
+- type: entity
+  id: ADTAshRuneActivation
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: TimedDespawn
+    lifetime: 3
+  - type: Transform
+    noRot: true
+  - type: Sprite
+    sprite: ADT/Effects/ashwalker_rune.rsi
+    state: activate
+    drawdepth: Effects
+    noRot: true
+  - type: Tag
+    tags:
+    - HideContextMenu
+
+- type: entity
+  id: ADTAshRune
+  name: ash rune
+  description: A fully functioning rune, ready for ritual work.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+    noRot: true
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Sprite
+    sprite: ADT/Effects/ashwalker_rune.rsi
+    state: rune
+    drawdepth: FloorObjects
+    noRot: true
+  - type: ADTRitualObject
+    categories:
+    - ADTAshWalker
+    allowedSpecies:
+    - ADTAshWalkerSpecies
+    - ADTAshWalkerShamanSpecies
+    - ADTDraconidSpecies
+  - type: UserInterface
+    interfaces:
+      enum.ADTRitualUiKey.Key:
+        type: ADTRitualBoundUserInterface
+      enum.ADTRitualSummonUiKey.Key:
+        type: ADTRitualSummonBoundUserInterface
diff --git a/Resources/Prototypes/ADT/Entities/Mobs/NPCs/Megafauna/Drake.yml b/Resources/Prototypes/ADT/Entities/Mobs/NPCs/Megafauna/Drake.yml
index 6fd253f211d..34158cb12b4 100644
--- a/Resources/Prototypes/ADT/Entities/Mobs/NPCs/Megafauna/Drake.yml
+++ b/Resources/Prototypes/ADT/Entities/Mobs/NPCs/Megafauna/Drake.yml
@@ -291,6 +291,9 @@
     - id: ADTMaterialSinew1
       amount: 3
       maxAmount: 5
+    - id: ADTAshDrakeHide
+      amount: 1
+      maxAmount: 2
 
 - type: entity
   id: MobDrake
diff --git a/Resources/Prototypes/ADT/Entities/Mobs/NPCs/lavaland_fauna.yml b/Resources/Prototypes/ADT/Entities/Mobs/NPCs/lavaland_fauna.yml
index 1b8eca79e9c..e2b60994bf7 100644
--- a/Resources/Prototypes/ADT/Entities/Mobs/NPCs/lavaland_fauna.yml
+++ b/Resources/Prototypes/ADT/Entities/Mobs/NPCs/lavaland_fauna.yml
@@ -153,6 +153,9 @@
   parent: ADTSimpleMobBaselavaland
   description: A worm that grows fat from eating everything in its sight. Seems to enjoy precious metals and other shiny things, hence the name.
   components:
+  - type: Tag
+    tags:
+    - ADTGoldgrub
   - type: Sprite
     drawdepth: Mobs
     sprite: ADT/Mobs/Lavaland/goldgrub.rsi
diff --git a/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ash_flora_produce.yml b/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ash_flora_produce.yml
index 5fa8b4e51ef..447200f250c 100644
--- a/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ash_flora_produce.yml
+++ b/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ash_flora_produce.yml
@@ -56,6 +56,7 @@
   - type: Tag
     tags:
     - Mushroom
+    - ADTAshFloraLeaf
 
 - type: entity
   name: mushroom cap
@@ -138,3 +139,30 @@
   - type: Construction
     graph: ADTMushroomBowl
     node: bowl
+
+- type: entity
+  name: fire blossom
+  parent: FoodProduceBase
+  id: ADTFoodFireblossom
+  description: An ordinary fire blossom.
+  components:
+  - type: FlavorProfile
+    flavors:
+    - spicy
+  - type: SolutionContainerManager
+    solutions:
+      food:
+        maxVol: 12
+        reagents:
+        - ReagentId: Nutriment
+          Quantity: 4
+        - ReagentId: Capsaicin
+          Quantity: 5
+  - type: Sprite
+    sprite: ADT/Objects/Specific/Lavaland/fireblossom.rsi
+    state: icon
+  - type: Extractable
+    grindableSolutionName: food
+  - type: Tag
+    tags:
+    - ADTFireblossom
diff --git a/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ashwalker.yml b/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ashwalker.yml
new file mode 100644
index 00000000000..ba34da1f566
--- /dev/null
+++ b/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/ashwalker.yml
@@ -0,0 +1,28 @@
+- type: entity
+  name: small blaze
+  parent: Matchstick
+  id: ADTAshWalkerSmallBlaze
+  description: Your own little flame, currently sitting right in your maw.
+  components:
+  - type: Sprite
+    sprite: ADT/Objects/Specific/Lavaland/small_blaze.rsi
+    layers:
+    - state: icon
+  - type: BurnStateVisuals
+    unlitIcon: icon
+    litIcon: icon
+    burntIcon: icon
+  - type: Item
+    size: Normal
+  - type: ADTSmallBlaze
+  - type: Matchstick
+    duration: 10
+    igniteSound:
+      path: /Audio/Items/match_strike.ogg
+      params:
+        volume: -0.125
+        variation: 0.125
+  - type: PointLight
+    enabled: false
+    radius: 1.5
+    color: orangered
diff --git a/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/lavalandplants.yml b/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/lavalandplants.yml
index d33e8e784b7..e7930bf3ec3 100644
--- a/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/lavalandplants.yml
+++ b/Resources/Prototypes/ADT/Entities/Objects/Specific/Lavaland/lavalandplants.yml
@@ -36,6 +36,7 @@
   - type: Tag
     tags:
     - Fruit
+    - ADTCactusBerry
 
 - type: entity
   abstract: true
diff --git a/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/lavaland_loot.yml b/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/lavaland_loot.yml
index 7cc6290afb1..13947e4cd85 100644
--- a/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/lavaland_loot.yml
+++ b/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/lavaland_loot.yml
@@ -81,3 +81,45 @@
         Slash: -2
         Piercing: -2
         Blunt: -2
+
+- type: entity
+  id: ADTMagmaGem
+  parent: BaseItem
+  name: calcified auric
+  description: A hot, faintly glowing mineral taken from the guts of a magmawing watcher. It can be smelted down into pure gold.
+  components:
+  - type: Sprite
+    sprite: ADT/Objects/Specific/Lavaland/magma_gem.rsi
+    state: icon
+  - type: Item
+    size: Tiny
+  - type: Tag
+    tags:
+    - ADTMagmaGem
+  - type: PointLight
+    enabled: true
+    radius: 2
+    energy: 1.5
+    color: "#ff7a2b"
+  - type: PhysicalComposition
+    materialComposition:
+      Gold: 100
+  - type: StaticPrice
+    price: 700
+
+- type: entity
+  id: ADTAshDrakeHide
+  parent: BaseItem
+  name: ash drake hide
+  description: A plate of scales torn off an ash drake. Still warm.
+  components:
+  - type: Sprite
+    sprite: ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi
+    state: icon
+  - type: Item
+    size: Normal
+  - type: Tag
+    tags:
+    - ADTAshDrakeHide
+  - type: StaticPrice
+    price: 500
diff --git a/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/stabilizingserum.yml b/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/stabilizingserum.yml
index 84fe9bed744..24c4fa97791 100644
--- a/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/stabilizingserum.yml
+++ b/Resources/Prototypes/ADT/Entities/Objects/Specific/Salvage/stabilizingserum.yml
@@ -46,3 +46,6 @@
   - type: Construction
     graph: ADTLegionCoreStable
     node: stable
+  - type: Tag
+    tags:
+    - ADTLegionCore
diff --git a/Resources/Prototypes/ADT/Entities/Structures/Specific/ash_flora.yml b/Resources/Prototypes/ADT/Entities/Structures/Specific/ash_flora.yml
index a468bda35b4..a62aaf034e4 100644
--- a/Resources/Prototypes/ADT/Entities/Structures/Specific/ash_flora.yml
+++ b/Resources/Prototypes/ADT/Entities/Structures/Specific/ash_flora.yml
@@ -459,3 +459,106 @@
     prototype: ADTAshFloraStemShroom4
     minTime: 300
     maxTime: 600
+
+- type: entity
+  abstract: true
+  parent: ADTBaseAshFlora
+  id: ADTAshFloraFireblossom
+  name: fire blossoms
+  description: Bright red blossoms that give off a dry, scorching heat.
+  components:
+  - type: ADTAshFlora
+    product: ADTFoodFireblossom
+    minAmount: 1
+    maxAmount: 3
+    harvestTime: 2
+    popupLow: adt-ash-flora-fireblossom-low
+    popupMedium: adt-ash-flora-fireblossom-medium
+    popupHigh: adt-ash-flora-fireblossom-high
+
+- type: entity
+  abstract: true
+  parent: ADTBaseAshFlora
+  id: ADTAshFloraFireblossomHarvested
+  name: fire blossoms
+  description: A few picked stalks. New blossoms are already swelling on them.
+
+- type: entity
+  parent: ADTAshFloraFireblossom
+  id: ADTAshFloraFireblossom1
+  components:
+  - type: Sprite
+    state: fireblossom1
+  - type: ADTAshFlora
+    harvestedPrototype: ADTAshFloraFireblossomHarvested1
+
+- type: entity
+  parent: ADTAshFloraFireblossomHarvested
+  id: ADTAshFloraFireblossomHarvested1
+  components:
+  - type: Sprite
+    state: fireblossom1p
+  - type: ADTAshFloraRegrowth
+    prototype: ADTAshFloraFireblossom1
+    minTime: 420
+    maxTime: 960
+
+- type: entity
+  parent: ADTAshFloraFireblossom
+  id: ADTAshFloraFireblossom2
+  components:
+  - type: Sprite
+    state: fireblossom2
+  - type: ADTAshFlora
+    harvestedPrototype: ADTAshFloraFireblossomHarvested2
+
+- type: entity
+  parent: ADTAshFloraFireblossomHarvested
+  id: ADTAshFloraFireblossomHarvested2
+  components:
+  - type: Sprite
+    state: fireblossom2p
+  - type: ADTAshFloraRegrowth
+    prototype: ADTAshFloraFireblossom2
+    minTime: 420
+    maxTime: 960
+
+- type: entity
+  parent: ADTAshFloraFireblossom
+  id: ADTAshFloraFireblossom3
+  components:
+  - type: Sprite
+    state: fireblossom3
+  - type: ADTAshFlora
+    harvestedPrototype: ADTAshFloraFireblossomHarvested3
+
+- type: entity
+  parent: ADTAshFloraFireblossomHarvested
+  id: ADTAshFloraFireblossomHarvested3
+  components:
+  - type: Sprite
+    state: fireblossom3p
+  - type: ADTAshFloraRegrowth
+    prototype: ADTAshFloraFireblossom3
+    minTime: 420
+    maxTime: 960
+
+- type: entity
+  parent: ADTAshFloraFireblossom
+  id: ADTAshFloraFireblossom4
+  components:
+  - type: Sprite
+    state: fireblossom4
+  - type: ADTAshFlora
+    harvestedPrototype: ADTAshFloraFireblossomHarvested4
+
+- type: entity
+  parent: ADTAshFloraFireblossomHarvested
+  id: ADTAshFloraFireblossomHarvested4
+  components:
+  - type: Sprite
+    state: fireblossom4p
+  - type: ADTAshFloraRegrowth
+    prototype: ADTAshFloraFireblossom4
+    minTime: 420
+    maxTime: 960
diff --git a/Resources/Prototypes/ADT/Entities/Structures/Specific/ashwalker_nest.yml b/Resources/Prototypes/ADT/Entities/Structures/Specific/ashwalker_nest.yml
new file mode 100644
index 00000000000..c2d01aca776
--- /dev/null
+++ b/Resources/Prototypes/ADT/Entities/Structures/Specific/ashwalker_nest.yml
@@ -0,0 +1,140 @@
+- type: entity
+  id: ADTAshWalkerNest
+  parent: BaseStructure
+  name: necropolis tendril nest
+  description: A tendril of twisted malice. A nest full of fast-growing eggs is built around it.
+  components:
+  - type: Sprite
+    sprite: ADT/Structures/Specific/ashwalker_nest.rsi
+    state: nest
+    drawdepth: Mobs
+    noRot: true
+    offset: 0,0.5
+  - type: Transform
+    anchored: true
+    noRot: true
+  - type: ADTAshWalkerNest
+    auraHealing:
+      types:
+        Blunt: -0.4
+        Slash: -0.4
+        Piercing: -0.4
+        Heat: -0.4
+        Cold: -0.4
+        Poison: -0.4
+  - type: AshStormImmune
+  - type: Damageable
+    damageModifierSet: ADTNecropolisFlesh
+  - type: Injurable
+    damageContainer: Biological
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 200
+      behaviors:
+      - !type:DoActsBehavior
+        acts: [ "Destruction" ]
+      - !type:SpawnEntitiesBehavior
+        spawn:
+          ADTAshWalkerNestCoreSpawner:
+            min: 1
+            max: 1
+      - !type:PlaySoundBehavior
+        sound:
+          collection: MetalBreak
+  - type: Physics
+    bodyType: Static
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeAabb
+          bounds: "-0.45,-0.45,0.45,0.45"
+        density: 1000
+        mask:
+        - MachineMask
+        layer:
+        - MidImpassable
+        - LowImpassable
+        - BulletImpassable
+
+- type: entity
+  id: ADTAshWalkerNestCoreSpawner
+  parent: MarkerBase
+  name: necropolis core spawner
+  suffix: ash walker nest
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: RandomSpawner
+    rarePrototypes:
+    - AnomalyCoreBluespace
+    - AnomalyCoreTech
+    rareChance: 0.1
+    prototypes:
+    - AnomalyCorePyroclastic
+    - AnomalyCoreGravity
+    - AnomalyCoreIce
+    - AnomalyCoreFlesh
+    - AnomalyCoreRock
+    - AnomalyCoreLiquid
+    - AnomalyCoreElectricity
+    - AnomalyCoreFlora
+    - AnomalyCoreShadow
+
+- type: entity
+  id: ADTAshWalkerEggBase
+  parent: BaseStructureDynamic
+  abstract: true
+  components:
+  - type: Sprite
+    sprite: ADT/Structures/Specific/ashwalker_egg.rsi
+    drawdepth: Mobs
+    noRot: true
+  - type: GhostRole
+    rules: ghost-role-information-adt-ash-walker-rules
+    mindRoles:
+    - MindRoleGhostRoleTeamAntagonist
+  - type: GhostRoleMobSpawner
+  - type: Physics
+    bodyType: Dynamic
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeCircle
+          radius: 0.35
+        density: 60
+        mask:
+        - ItemMask
+
+- type: entity
+  id: ADTAshWalkerEgg
+  parent: ADTAshWalkerEggBase
+  name: ash walker egg
+  description: A man-sized yellow egg birthed by some inconceivable creature. A humanoid silhouette shows through it.
+  components:
+  - type: Sprite
+    state: egg
+  - type: ADTAshWalkerEgg
+  - type: GhostRole
+    name: ghost-role-information-adt-ash-walker-name
+    description: ghost-role-information-adt-ash-walker-description
+  - type: GhostRoleMobSpawner
+    prototype: ADTMobAshWalkerHatched
+
+- type: entity
+  id: ADTAshWalkerShamanEgg
+  parent: ADTAshWalkerEggBase
+  name: ash walker shaman egg
+  description: A man-sized amber egg birthed by some inconceivable creature. A humanoid silhouette shows through it.
+  components:
+  - type: Sprite
+    state: egg_shaman
+  - type: ADTAshWalkerEgg
+    shaman: true
+  - type: GhostRole
+    name: ghost-role-information-adt-ash-walker-shaman-name
+    description: ghost-role-information-adt-ash-walker-shaman-description
+  - type: GhostRoleMobSpawner
+    prototype: ADTMobAshWalkerShamanHatched
diff --git a/Resources/Prototypes/ADT/InventoryTemplates/draconid_inventory_template.yml b/Resources/Prototypes/ADT/InventoryTemplates/draconid_inventory_template.yml
new file mode 100644
index 00000000000..f90680f9fb5
--- /dev/null
+++ b/Resources/Prototypes/ADT/InventoryTemplates/draconid_inventory_template.yml
@@ -0,0 +1,153 @@
+- type: inventoryTemplate
+  id: ADTDraconid
+  slots:
+    - name: underwearb
+      slotTexture: underwearb
+      slotFlags: UNDERWEARB
+      stripTime: 6
+      uiWindowPos: 4,1
+      strippingWindowPos: 1,4
+      displayName: Panties
+      whitelist:
+        tags:
+          - ADTUnderwearB
+    - name: underweart
+      slotTexture: underweart
+      slotFlags: UNDERWEART
+      stripTime: 6
+      uiWindowPos: 4,2
+      strippingWindowPos: 0,4
+      displayName: Bra
+      whitelist:
+        tags:
+          - ADTUnderwearT
+    - name: jumpsuit
+      slotTexture: uniform
+      slotFlags: INNERCLOTHING
+      stripTime: 6
+      uiWindowPos: 0,1
+      strippingWindowPos: 0,2
+      displayName: Jumpsuit
+    - name: outerClothing
+      slotTexture: suit
+      slotFlags: OUTERCLOTHING
+      stripTime: 6
+      uiWindowPos: 1,1
+      strippingWindowPos: 1,2
+      displayName: Suit
+    - name: gloves
+      slotTexture: gloves
+      slotFlags: GLOVES
+      uiWindowPos: 2,1
+      strippingWindowPos: 2,2
+      displayName: Gloves
+    - name: finger
+      slotTexture: finger
+      slotFlags: FINGER
+      stripTime: 2
+      uiWindowPos: 3,1
+      strippingWindowPos: 3,2
+      displayName: Finger
+    - name: neck
+      slotTexture: neck
+      slotFlags: NECK
+      uiWindowPos: 0,2
+      strippingWindowPos: 0,1
+      displayName: Neck
+    - name: mask
+      slotTexture: mask
+      slotFlags: MASK
+      uiWindowPos: 1,2
+      strippingWindowPos: 1,1
+      displayName: Mask
+    - name: eyes
+      slotTexture: glasses
+      slotFlags: EYES
+      stripTime: 3
+      uiWindowPos: 0,3
+      strippingWindowPos: 0,0
+      displayName: Eyes
+    - name: ears
+      slotTexture: ears
+      slotFlags: EARS
+      stripTime: 3
+      uiWindowPos: 2,2
+      strippingWindowPos: 2,0
+      displayName: Ears
+    - name: ears2
+      slotTexture: ears2
+      slotFlags: EARS2
+      stripTime: 3
+      uiWindowPos: 2,3
+      strippingWindowPos: 2,1
+      displayName: EarsSecond
+    - name: head
+      slotTexture: head
+      slotFlags: HEAD
+      uiWindowPos: 1,3
+      strippingWindowPos: 1,0
+      displayName: Head
+    - name: pocket1
+      slotTexture: pocket
+      fullTextureName: template_small
+      slotFlags: POCKET
+      slotGroup: MainHotbar
+      stripTime: 3
+      uiWindowPos: 0,3
+      strippingWindowPos: 0,5
+      dependsOn: jumpsuit
+      displayName: Pocket 1
+      stripHidden: true
+    - name: pocket2
+      slotTexture: pocket
+      fullTextureName: template_small
+      slotFlags: POCKET
+      slotGroup: MainHotbar
+      stripTime: 3
+      uiWindowPos: 2,3
+      strippingWindowPos: 1,5
+      dependsOn: jumpsuit
+      displayName: Pocket 2
+      stripHidden: true
+    - name: suitstorage
+      slotTexture: suit_storage
+      slotFlags:   SUITSTORAGE
+      slotGroup: MainHotbar
+      stripTime: 3
+      uiWindowPos: 2,0
+      strippingWindowPos: 2,6
+      dependsOn: outerClothing
+      dependsOnComponents:
+      - type: AllowSuitStorage
+      displayName: Suit Storage
+    - name: id
+      slotTexture: id
+      fullTextureName: template_small
+      slotFlags: IDCARD
+      slotGroup: SecondHotbar
+      stripTime: 6
+      uiWindowPos: 2,1
+      strippingWindowPos: 2,5
+      dependsOn: jumpsuit
+      displayName: ID
+    - name: belt
+      slotTexture: belt
+      fullTextureName: template_small
+      slotFlags: BELT
+      slotGroup: SecondHotbar
+      stripTime: 6
+      uiWindowPos: 3,1
+      strippingWindowPos: 1,6
+      displayName: Belt
+    - name: back
+      slotTexture: back
+      fullTextureName: template_small
+      slotFlags: BACK
+      slotGroup: SecondHotbar
+      stripTime: 6
+      uiWindowPos: 3,0
+      strippingWindowPos: 0,6
+      displayName: Back
+      blacklist:
+        tags:
+        - PetOnly
diff --git a/Resources/Prototypes/ADT/Polymorphs/ashwalker.yml b/Resources/Prototypes/ADT/Polymorphs/ashwalker.yml
new file mode 100644
index 00000000000..db01491a11a
--- /dev/null
+++ b/Resources/Prototypes/ADT/Polymorphs/ashwalker.yml
@@ -0,0 +1,40 @@
+- type: polymorph
+  id: ADTRitualTransformation
+  configuration:
+    entity: ADTMobAshWalker
+    forced: true
+    transferName: true
+    transferDamage: true
+    transferLanguageSpeaker: false
+    inventory: Drop
+    revertOnCrit: false
+    revertOnDeath: false
+    revertOnDelete: false
+    ignoreAllowRepeatedMorphs: true
+
+- type: polymorph
+  id: ADTRitualSoul
+  configuration:
+    entity: ADTMobDraconid
+    forced: true
+    transferName: true
+    transferDamage: true
+    transferLanguageSpeaker: true
+    inventory: Transfer
+    revertOnCrit: false
+    revertOnDeath: false
+    revertOnDelete: false
+    ignoreAllowRepeatedMorphs: true
+
+- type: polymorph
+  id: ADTRitualMonkeyize
+  configuration:
+    entity: MobMonkey
+    forced: true
+    transferName: true
+    transferDamage: true
+    inventory: Drop
+    revertOnCrit: false
+    revertOnDeath: false
+    revertOnDelete: false
+    ignoreAllowRepeatedMorphs: true
diff --git a/Resources/Prototypes/ADT/Rituals/ashwalker.yml b/Resources/Prototypes/ADT/Rituals/ashwalker.yml
new file mode 100644
index 00000000000..ed3403db1ea
--- /dev/null
+++ b/Resources/Prototypes/ADT/Rituals/ashwalker.yml
@@ -0,0 +1,508 @@
+- type: adtRitual
+  id: ADTRitualAshstorm
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-ashstorm-name
+  description: adt-ritual-ashstorm-desc
+  shamanOnly: true
+  extraInvokers: 2
+  charges: 2
+  cooldown: 1200
+  castTime: 20
+  failChance: 0.2
+  disasterChance: 0.2
+  neededDye: Amber
+  totemDye: Amber
+  dyeFluff: adt-ritual-dye-amber
+  requiredThings:
+  - name: adt-ritual-thing-goldgrub
+    whitelist:
+      tags: [ ADTGoldgrub ]
+  checks:
+  - !type:ADTRitualThingsCheck
+    mustBeDead: true
+    reason: adt-ritual-things-must-be-dead
+  effects:
+  - !type:ADTRitualWeatherEffect
+    weather: ADTLavalandWeatherAshfall
+    duration: 300
+  disasterEffects:
+  - !type:ADTRitualDamageEffect
+    target: RandomTribesman
+    damage:
+      types:
+        Poison: 95
+  - !type:ADTRitualMessageEffect
+    target: RandomTribesman
+    message: adt-ritual-ashstorm-sick
+
+- type: adtRitual
+  id: ADTRitualTransformation
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-transformation-name
+  description: adt-ritual-transformation-desc
+  extraInvokers: 1
+  cooldown: 480
+  castTime: 30
+  failChance: 0.5
+  disasterChance: 0.3
+  deleteThingsOnSuccess: false
+  deleteThingsOnFail: true
+  neededDye: Cinnabar
+  totemDye: Cinnabar
+  dyeFluff: adt-ritual-dye-cinnabar
+  requiredThings:
+  - name: adt-ritual-thing-captive
+    consume: false
+    whitelist:
+      components: [ HumanoidProfile ]
+  checks:
+  - !type:ADTRitualThingsCheck
+    mustBeAlive: true
+    mustHaveMind: true
+    reason: adt-ritual-things-must-be-alive
+  effects:
+  - !type:ADTRitualPolymorphEffect
+    target: UsedThings
+    polymorph: ADTRitualTransformation
+  disasterEffects:
+  - !type:ADTRitualDamageEffect
+    target: Invoker
+    damage:
+      types:
+        Cellular: 15
+  - !type:ADTRitualTeleportEffect
+    target: UsedThings
+    destination:
+      components: [ NavMapBeacon ]
+
+- type: adtRitual
+  id: ADTRitualSummon
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-summon-name
+  description: adt-ritual-summon-desc
+  shamanOnly: true
+  extraInvokers: 1
+  cooldown: 900
+  castTime: 30
+  failChance: 0.3
+  disasterChance: 0.3
+  neededDye: Crimson
+  totemDye: Crimson
+  dyeFluff: adt-ritual-dye-crimson
+  effects:
+  - !type:ADTRitualDamageEffect
+    target: InRange
+    bloodLoss: 60
+    damage:
+      types:
+        Slash: 35
+  - !type:ADTRitualSummonPickerEffect
+  disasterEffects:
+  - !type:ADTRitualDamageEffect
+    target: Invoker
+    prob: 0.7
+    damage:
+      types:
+        Slash: 60
+        Bloodloss: 30
+
+- type: adtRitual
+  id: ADTRitualCurse
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-curse-name
+  description: adt-ritual-curse-desc
+  shamanOnly: true
+  extraInvokers: 2
+  charges: 3
+  cooldown: 600
+  castTime: 30
+  failChance: 0.3
+  disasterChance: 0.3
+  neededDye: Crimson
+  totemDye: Crimson
+  dyeFluff: adt-ritual-dye-crimson
+  effects:
+  - !type:ADTRitualDamageEffect
+    target: RandomOutsider
+    damage:
+      types:
+        Poison: 60
+        Bloodloss: 25
+  - !type:ADTRitualMessageEffect
+    target: RandomOutsider
+    message: adt-ritual-curse-struck
+  disasterEffects:
+  - !type:ADTRitualPolymorphEffect
+    target: RandomTribesman
+    polymorph: ADTRitualMonkeyize
+
+- type: adtRitual
+  id: ADTRitualPower
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-power-name
+  description: adt-ritual-power-desc
+  shamanOnly: true
+  extraInvokers: 2
+  charges: 2
+  cooldown: 800
+  castTime: 40
+  failChance: 0.4
+  disasterChance: 0.4
+  neededDye: Indigo
+  totemDye: Indigo
+  dyeFluff: adt-ritual-dye-indigo
+  requiredThings:
+  - name: adt-ritual-thing-legion-core
+    whitelist:
+      tags: [ ADTLegionCore ]
+  effects:
+  - !type:ADTRitualComponentsEffect
+    target: Invokers
+    overwrite: true
+    removeComponents: [ SlowOnDamage ] # todo too pulling
+    components:
+    - type: PassiveDamage
+      allowedStates: [ Alive ]
+      damage:
+        types:
+          Blunt: -0.3
+          Slash: -0.3
+          Piercing: -0.3
+          Heat: -0.3
+  disasterEffects:
+  - !type:ADTRitualComponentsEffect
+    target: Invokers
+    overwrite: true
+    components:
+    - type: PassiveDamage
+      allowedStates: [ Alive ]
+      damage:
+        types:
+          Poison: 0.2
+
+- type: adtRitual
+  id: ADTRitualResurrection
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-resurrection-name
+  description: adt-ritual-resurrection-desc
+  shamanOnly: true
+  extraInvokers: 2
+  charges: 3
+  cooldown: 180
+  castTime: 30
+  failChance: 0.35
+  disasterChance: 0.25
+  neededDye: Mint
+  totemDye: Mint
+  dyeFluff: adt-ritual-dye-mint
+  requiredThings:
+  - name: adt-ritual-thing-legion-core
+    whitelist:
+      tags: [ ADTLegionCore ]
+  - name: adt-ritual-thing-corpse
+    consume: false
+    whitelist:
+      components: [ HumanoidProfile ]
+  checks:
+  - !type:ADTRitualThingsCheck
+    mustBeDead: true
+    mustHaveMind: true
+    reason: adt-ritual-things-must-be-dead
+  modifiers:
+  - !type:ADTRitualThingSpeciesModifier
+    species:
+    - ADTAshWalkerSpecies
+    - ADTAshWalkerShamanSpecies
+    - ADTDraconidSpecies
+    failChance: 0.15
+  effects:
+  - !type:ADTRitualReviveEffect
+    target: UsedThings
+    aftermath:
+      types:
+        Cellular: 20
+  disasterEffects:
+  - !type:ADTRitualDamageEffect
+    target: Tribe
+    damage:
+      types:
+        Cellular: 15
+
+- type: adtRitual
+  id: ADTRitualRestoration
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-restoration-name
+  description: adt-ritual-restoration-desc
+  shamanOnly: true
+  extraInvokers: 3
+  cooldown: 360
+  castTime: 30
+  failChance: 0.5
+  disasterChance: 0.3
+  neededDye: Amber
+  totemDye: Amber
+  dyeFluff: adt-ritual-dye-amber
+  requiredThings:
+  - name: adt-ritual-thing-legion-core
+    whitelist:
+      tags: [ ADTLegionCore ]
+  effects:
+  - !type:ADTRitualRechargeEffect
+    amount: 1
+    blacklist: [ ADTRitualPower ]
+  # TODO remake to legion infect
+  disasterEffects:
+  - !type:ADTRitualComponentsEffect
+    target: RandomTribesman
+    overwrite: true
+    components:
+    - type: PassiveDamage
+      allowedStates: [ Alive ]
+      damage:
+        types:
+          Poison: 0.3
+  - !type:ADTRitualMessageEffect
+    target: RandomTribesman
+    message: adt-ritual-restoration-tumour
+
+- type: adtRitual
+  id: ADTRitualPopulation
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-population-name
+  description: adt-ritual-population-desc
+  extraInvokers: 2
+  charges: 1
+  cooldown: 120
+  castTime: 30
+  failChance: 0.1
+  disasterChance: 0.1
+  deleteThingsOnFail: true
+  neededDye: Cinnabar
+  totemDye: Cinnabar
+  dyeFluff: adt-ritual-dye-cinnabar
+  requiredThings:
+  - name: adt-ritual-thing-cactus-fruit
+    whitelist:
+      tags: [ ADTCactusBerry ]
+  - name: adt-ritual-thing-fireblossom
+    whitelist:
+      tags: [ ADTFireblossom ]
+  - name: adt-ritual-thing-mushroom-leaf
+    whitelist:
+      tags: [ ADTAshFloraLeaf ]
+  modifiers:
+  - !type:ADTRitualShamanModifier
+    failChance: 0.4
+    disasterChance: 0.4
+  effects:
+  - !type:ADTRitualSpawnEffect
+    entities: [ ADTAshWalkerShamanEgg ]
+  disasterEffects:
+  - !type:ADTRitualDropItemsEffect
+    target: Tribe
+    prob: 0.4
+
+- type: adtRitual
+  id: ADTRitualSoul
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-soul-name
+  description: adt-ritual-soul-desc
+  extraInvokers: 3
+  cooldown: 1200
+  castTime: 30
+  failChance: 0.1
+  disasterChance: 0.1
+  neededDye: Crimson
+  totemDye: Crimson
+  dyeFluff: adt-ritual-dye-crimson
+  requiredThings:
+  - name: adt-ritual-thing-drake-hide
+    whitelist:
+      tags: [ ADTAshDrakeHide ]
+  modifiers:
+  - !type:ADTRitualShamanModifier
+    failChance: 0.7
+    disasterChance: 0.4
+  effects:
+  - !type:ADTRitualPolymorphEffect
+    target: Invoker
+    polymorph: ADTRitualSoul
+  disasterEffects:
+  - !type:ADTRitualIgniteEffect
+    target: Tribe
+    prob: 0.4
+
+- type: adtRitual
+  id: ADTRitualTransmutation
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-transmutation-name
+  description: adt-ritual-transmutation-desc
+  cooldown: 20
+  castTime: 10
+  failChance: 0.1
+  disasterChance: 0.1
+  requiredThings:
+  - name: adt-ritual-thing-ore
+    amount: 10
+    whitelist:
+      tags: [ Ore ]
+  modifiers:
+  - !type:ADTRitualShamanModifier
+    failChance: 0.5
+    disasterChance: 0.3
+  effects:
+  - !type:ADTRitualSpawnEffect
+    pick: true
+    stackCount: 10
+    entities:
+    - GoldOre1
+    - SilverOre1
+    - SteelOre1
+    - PlasmaOre1
+    - UraniumOre1
+    - DiamondOre1
+    - BananiumOre1
+  disasterEffects:
+  - !type:ADTRitualIgniteEffect
+    target: Tribe
+    prob: 0.3
+
+- type: adtRitual
+  id: ADTRitualInterrogation
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-interrogation-name
+  description: adt-ritual-interrogation-desc
+  shamanOnly: true
+  cooldown: 50
+  castTime: 10
+  failChance: 0.1
+  disasterChance: 0.1
+  requiredThings:
+  - name: adt-ritual-thing-captive
+    consume: false
+    whitelist:
+      components: [ HumanoidProfile ]
+  checks:
+  - !type:ADTRitualThingsCheck
+    mustBeAlive: true
+    mustHaveMind: true
+    reason: adt-ritual-things-must-be-alive
+  modifiers:
+  - !type:ADTRitualHealthyInvokerModifier
+    threshold: 90
+    failChance: 0.3
+    disasterChance: 0.3
+  effects:
+  - !type:ADTRitualEmpathEffect
+    target: UsedThings
+  disasterEffects:
+  - !type:ADTRitualMessageEffect
+    target: Tribe
+    message: adt-ritual-interrogation-honk
+    sound:
+      path: /Audio/Items/airhorn.ogg
+  - !type:ADTRitualStatusEffect
+    target: Tribe
+    statusEffect: StatusEffectBlindness
+    duration: 5
+
+- type: adtRitual
+  id: ADTRitualCreation
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-creation-name
+  description: adt-ritual-creation-desc
+  shamanOnly: true
+  extraInvokers: 2
+  cooldown: 150
+  castTime: 30
+  failChance: 0.1
+  disasterChance: 0.1
+  neededDye: Indigo
+  totemDye: Indigo
+  dyeFluff: adt-ritual-dye-indigo
+  modifiers:
+  # Обряд творят лёжа. Каждый участник на ногах должен делать его опаснее.
+  - !type:ADTRitualConsciousInvokersModifier
+    failChance: 0.2
+    disasterChance: 0.2
+  effects:
+  - !type:ADTRitualSpawnEffect
+    pick: true
+    amount: 2
+    entities:
+    - MobGoliath
+    - MobHivelord
+    - MobBasilisk
+    - ADTMobLegion
+  disasterEffects:
+  - !type:ADTRitualIgniteEffect
+    target: Tribe
+    prob: 0.4
+
+- type: adtRitual
+  id: ADTRitualCommand
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-command-name
+  description: adt-ritual-command-desc
+  shamanOnly: true
+  extraInvokers: 1
+  cooldown: 150
+  castTime: 30
+  failChance: 0.1
+  disasterChance: 0.35
+  neededDye: Mint
+  totemDye: Mint
+  dyeFluff: adt-ritual-dye-mint
+  requiredThings:
+  - name: adt-ritual-thing-beast
+    consume: false
+    whitelist:
+      components: [ MobState ]
+  checks:
+  - !type:ADTRitualThingsCheck
+    mustBeDead: true
+    mustLackMind: true
+    noMegafauna: true
+    reason: adt-ritual-things-must-be-soulless
+  effects:
+  - !type:ADTRitualSentienceEffect
+    target: UsedThings
+  disasterEffects:
+  - !type:ADTRitualSpawnEffect
+    entities: [ MobAncientGoliath ]
+
+- type: adtRitual
+  id: ADTRitualWarming
+  categories: [ ADTAshWalker ]
+  name: adt-ritual-warming-name
+  description: adt-ritual-warming-desc
+  extraInvokers: 1
+  charges: 3
+  cooldown: 180
+  castTime: 25
+  failChance: 0.25
+  disasterChance: 1.0
+  neededDye: Cinnabar
+  totemDye: Cinnabar
+  dyeFluff: adt-ritual-dye-cinnabar
+  requiredThings:
+  - name: adt-ritual-thing-magma-gem
+    whitelist:
+      tags: [ ADTMagmaGem ]
+  effects:
+  - !type:ADTRitualComponentsEffect
+    target: Invokers
+    overwrite: true
+    components:
+    - type: TemperatureDamage
+      heatDamageThreshold: 420
+      coldDamageThreshold: 0
+      coldDamage:
+        types:
+          Cold: 0
+      heatDamage:
+        types:
+          Heat: 1.5
+  disasterEffects:
+  - !type:ADTRitualIgniteEffect
+    target: Invokers
diff --git a/Resources/Prototypes/ADT/Roles/ashwalker_startinggear.yml b/Resources/Prototypes/ADT/Roles/ashwalker_startinggear.yml
new file mode 100644
index 00000000000..2e2aad1fca0
--- /dev/null
+++ b/Resources/Prototypes/ADT/Roles/ashwalker_startinggear.yml
@@ -0,0 +1,13 @@
+- type: startingGear
+  id: ADTAshWalkerGear
+  equipment:
+    jumpsuit: ADTClothingUniformAshWalker
+
+- type: startingGear
+  id: ADTAshWalkerShamanGear
+  equipment:
+    jumpsuit: ADTClothingUniformAshWalkerShaman
+    head: ADTClothingHeadRoach
+    neck: ADTClothingNeckHideMantle
+    belt: ADTMedPouch
+    gloves: ADTClothingHandsGoliathGloves
diff --git a/Resources/Prototypes/ADT/SoundCollections/rituals.yml b/Resources/Prototypes/ADT/SoundCollections/rituals.yml
new file mode 100644
index 00000000000..a36725d121c
--- /dev/null
+++ b/Resources/Prototypes/ADT/SoundCollections/rituals.yml
@@ -0,0 +1,18 @@
+- type: soundCollection
+  id: ADTRitualStart
+  files:
+  - /Audio/ADT/Rituals/ritual_start1.ogg
+  - /Audio/ADT/Rituals/ritual_start2.ogg
+  - /Audio/ADT/Rituals/ritual_start3.ogg
+
+- type: soundCollection
+  id: ADTRitualSuccess
+  files:
+  - /Audio/ADT/Rituals/ritual_success1.ogg
+  - /Audio/ADT/Rituals/ritual_success2.ogg
+
+- type: soundCollection
+  id: ADTRitualFail
+  files:
+  - /Audio/ADT/Rituals/ritual_fail1.ogg
+  - /Audio/ADT/Rituals/ritual_fail2.ogg
diff --git a/Resources/Prototypes/ADT/ai_factions.yml b/Resources/Prototypes/ADT/ai_factions.yml
index 50a193109f0..4f067626716 100644
--- a/Resources/Prototypes/ADT/ai_factions.yml
+++ b/Resources/Prototypes/ADT/ai_factions.yml
@@ -46,3 +46,6 @@
   - Revolutionary
   - Heretic # goob edit - heretics
   - Ursus
+
+- type: npcFaction
+  id: ADTAshWalker
diff --git a/Resources/Prototypes/ADT/planets.yml b/Resources/Prototypes/ADT/planets.yml
index 6660f8d4ae4..3f8d502257f 100644
--- a/Resources/Prototypes/ADT/planets.yml
+++ b/Resources/Prototypes/ADT/planets.yml
@@ -5,6 +5,7 @@
   mapLight: "#6e2c2c"
   dayCycle: false
   addedComponents:
+  - type: ADTLavalandMap
   - type: RestrictedRange
     range: 250
     texturepath: "/Textures/ADT/Effects/weather.rsi/ashfal_lvery_light.png"
diff --git a/Resources/Prototypes/ADT/tags.yml b/Resources/Prototypes/ADT/tags.yml
index 1bbb001c53f..2742f3cbe74 100644
--- a/Resources/Prototypes/ADT/tags.yml
+++ b/Resources/Prototypes/ADT/tags.yml
@@ -923,4 +923,25 @@
   id: ADTAshFloraShavings
 
 - type: Tag
-  id: ConstantTemperatureThresholds # make entity ignore parent temperature thresholds from TemperatureContainerComponent
\ No newline at end of file
+  id: ConstantTemperatureThresholds # make entity ignore parent temperature thresholds from TemperatureContainerComponent
+
+- type: Tag
+  id: ADTMagmaGem
+
+- type: Tag
+  id: ADTAshDrakeHide
+
+- type: Tag
+  id: ADTFireblossom
+
+- type: Tag
+  id: ADTLegionCore
+
+- type: Tag
+  id: ADTGoldgrub
+
+- type: Tag
+  id: ADTCactusBerry
+
+- type: Tag
+  id: ADTAshFloraLeaf
diff --git a/Resources/Prototypes/Entities/Mobs/NPCs/lavaland.yml b/Resources/Prototypes/Entities/Mobs/NPCs/lavaland.yml
index 8a2913ce1b3..8f909b9c5f7 100644
--- a/Resources/Prototypes/Entities/Mobs/NPCs/lavaland.yml
+++ b/Resources/Prototypes/Entities/Mobs/NPCs/lavaland.yml
@@ -186,6 +186,8 @@
       maxAmount: 2 #ADT tweak
     - id: ADTMaterialSinew1 #ADT tweak
       maxAmount: 2 #ADT tweak
+    - id: ADTMagmaGem #ADT tweak
+      prob: 0.5 #ADT tweak
 
 - type: entity
   id: MobWatcherPride
diff --git a/Resources/Prototypes/Entities/Objects/Specific/Lavaland/MobLoot.yml b/Resources/Prototypes/Entities/Objects/Specific/Lavaland/MobLoot.yml
index e569beebaf8..bae7d2be34b 100644
--- a/Resources/Prototypes/Entities/Objects/Specific/Lavaland/MobLoot.yml
+++ b/Resources/Prototypes/Entities/Objects/Specific/Lavaland/MobLoot.yml
@@ -35,6 +35,9 @@
   - type: Construction #ADT-Tweak
     graph: ADTLegionCoreStable #ADT-Tweak
     node: start #ADT-Tweak
+  - type: Tag
+    tags:
+    - ADTLegionCore
 - type: entity
   name: legion core
   id: ADTLegionCoreDecayed
diff --git a/Resources/Prototypes/ai_factions.yml b/Resources/Prototypes/ai_factions.yml
index 56ef700af5d..67ae40bc658 100644
--- a/Resources/Prototypes/ai_factions.yml
+++ b/Resources/Prototypes/ai_factions.yml
@@ -67,6 +67,7 @@
   - Xeno
   - Xenoborg
   - ADTSpaceMobs # ADT-tweak
+  - ADTAshWalker # ADT-tweak
 
 - type: npcFaction
   id: SimpleNeutral
@@ -150,6 +151,7 @@
   - Heretic # ADT-tweak
   - Ursus # ADT-tweak
   - ADTSpaceMobs # ADT-tweak
+  - ADTAshWalker # ADT-tweak
   - Wizard
   - Xenoborg
 
diff --git a/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/equipped-BELT.png b/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/equipped-BELT.png
new file mode 100644
index 00000000000..09111e75163
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/equipped-BELT.png differ
diff --git a/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/icon.png b/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/icon.png
new file mode 100644
index 00000000000..09111e75163
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/meta.json b/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/meta.json
new file mode 100644
index 00000000000..e5687778e44
--- /dev/null
+++ b/Resources/Textures/ADT/Clothing/Belt/medpouch.rsi/meta.json
@@ -0,0 +1,17 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/storage.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        },
+        {
+            "name": "equipped-BELT"
+        }
+    ]
+}
diff --git a/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/equipped-HAND.png b/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/equipped-HAND.png
new file mode 100644
index 00000000000..108464034e1
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/equipped-HAND.png differ
diff --git a/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/icon.png b/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/icon.png
new file mode 100644
index 00000000000..459d252216b
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/meta.json b/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/meta.json
new file mode 100644
index 00000000000..775e193675e
--- /dev/null
+++ b/Resources/Textures/ADT/Clothing/Hands/goliath_gloves.rsi/meta.json
@@ -0,0 +1,18 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/clothing/gloves.dmi and icons/mob/clothing/hands.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        },
+        {
+            "name": "equipped-HAND",
+            "directions": 4
+        }
+    ]
+}
diff --git a/Resources/Textures/ADT/Clothing/Head/roach.rsi/equipped-HELMET.png b/Resources/Textures/ADT/Clothing/Head/roach.rsi/equipped-HELMET.png
new file mode 100644
index 00000000000..3c0e668892e
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Head/roach.rsi/equipped-HELMET.png differ
diff --git a/Resources/Textures/ADT/Clothing/Head/roach.rsi/icon.png b/Resources/Textures/ADT/Clothing/Head/roach.rsi/icon.png
new file mode 100644
index 00000000000..e5308a49b27
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Head/roach.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Clothing/Head/roach.rsi/meta.json b/Resources/Textures/ADT/Clothing/Head/roach.rsi/meta.json
new file mode 100644
index 00000000000..5ad7366d91d
--- /dev/null
+++ b/Resources/Textures/ADT/Clothing/Head/roach.rsi/meta.json
@@ -0,0 +1,18 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/clothing/hats.dmi and icons/mob/clothing/head.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        },
+        {
+            "name": "equipped-HELMET",
+            "directions": 4
+        }
+    ]
+}
diff --git a/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/equipped-NECK.png b/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/equipped-NECK.png
new file mode 100644
index 00000000000..5df12ac9933
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/equipped-NECK.png differ
diff --git a/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/icon.png b/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/icon.png
new file mode 100644
index 00000000000..d59144a0524
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/meta.json b/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/meta.json
new file mode 100644
index 00000000000..eb944c3a4d3
--- /dev/null
+++ b/Resources/Textures/ADT/Clothing/Neck/hide_mantle.rsi/meta.json
@@ -0,0 +1,18 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/clothing/neck.dmi and icons/mob/clothing/neck.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        },
+        {
+            "name": "equipped-NECK",
+            "directions": 4
+        }
+    ]
+}
diff --git a/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/equipped-INNERCLOTHING.png b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/equipped-INNERCLOTHING.png
new file mode 100644
index 00000000000..9b4d1d48722
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/equipped-INNERCLOTHING.png differ
diff --git a/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/icon.png b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/icon.png
new file mode 100644
index 00000000000..a6f50c3232b
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/meta.json b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/meta.json
new file mode 100644
index 00000000000..7cd7066dfc2
--- /dev/null
+++ b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker.rsi/meta.json
@@ -0,0 +1,18 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/clothing/uniforms.dmi and icons/mob/clothing/uniform.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        },
+        {
+            "name": "equipped-INNERCLOTHING",
+            "directions": 4
+        }
+    ]
+}
diff --git a/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/equipped-INNERCLOTHING.png b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/equipped-INNERCLOTHING.png
new file mode 100644
index 00000000000..04cddc985fa
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/equipped-INNERCLOTHING.png differ
diff --git a/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/icon.png b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/icon.png
new file mode 100644
index 00000000000..6b686826c37
Binary files /dev/null and b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/meta.json b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/meta.json
new file mode 100644
index 00000000000..7cd7066dfc2
--- /dev/null
+++ b/Resources/Textures/ADT/Clothing/Uniforms/ashwalker_shaman.rsi/meta.json
@@ -0,0 +1,18 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/clothing/uniforms.dmi and icons/mob/clothing/uniform.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        },
+        {
+            "name": "equipped-INNERCLOTHING",
+            "directions": 4
+        }
+    ]
+}
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/meta.json b/Resources/Textures/ADT/Effects/ash_runes.rsi/meta.json
new file mode 100644
index 00000000000..14133844e18
--- /dev/null
+++ b/Resources/Textures/ADT/Effects/ash_runes.rsi/meta.json
@@ -0,0 +1,121 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/effects/ash_runes.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "runaash_1"
+        },
+        {
+            "name": "runaash_2"
+        },
+        {
+            "name": "runaash_3"
+        },
+        {
+            "name": "runaash_4"
+        },
+        {
+            "name": "runaash_5"
+        },
+        {
+            "name": "runaash_6"
+        },
+        {
+            "name": "runaash_7"
+        },
+        {
+            "name": "runaash_8"
+        },
+        {
+            "name": "runaash_9"
+        },
+        {
+            "name": "runaash_10"
+        },
+        {
+            "name": "runaash_11"
+        },
+        {
+            "name": "runaash_12"
+        },
+        {
+            "name": "runaash_13",
+            "directions": 8
+        },
+        {
+            "name": "runaash_14",
+            "directions": 8
+        },
+        {
+            "name": "runaash_15"
+        },
+        {
+            "name": "runaash_16"
+        },
+        {
+            "name": "runaash_17"
+        },
+        {
+            "name": "runaash_18"
+        },
+        {
+            "name": "runaash_19"
+        },
+        {
+            "name": "runaash_20"
+        },
+        {
+            "name": "runaash_21"
+        },
+        {
+            "name": "runaash_22"
+        },
+        {
+            "name": "runaash_23"
+        },
+        {
+            "name": "runaash_24"
+        },
+        {
+            "name": "runaash_25"
+        },
+        {
+            "name": "runaash_26"
+        },
+        {
+            "name": "runaash_27"
+        },
+        {
+            "name": "runaash_28"
+        },
+        {
+            "name": "runaash_29"
+        },
+        {
+            "name": "runaash_30"
+        },
+        {
+            "name": "runaash_31"
+        },
+        {
+            "name": "runaash_32"
+        },
+        {
+            "name": "runaash_33"
+        },
+        {
+            "name": "runaash_34"
+        },
+        {
+            "name": "runaash_35"
+        },
+        {
+            "name": "runaash_36"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_1.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_1.png
new file mode 100644
index 00000000000..6cb553edb03
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_1.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_10.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_10.png
new file mode 100644
index 00000000000..2a4e2e3a22b
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_10.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_11.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_11.png
new file mode 100644
index 00000000000..608e6b9b184
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_11.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_12.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_12.png
new file mode 100644
index 00000000000..0a6eb0e8978
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_12.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_13.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_13.png
new file mode 100644
index 00000000000..73ae3c8dbe0
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_13.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_14.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_14.png
new file mode 100644
index 00000000000..2903f8b6e06
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_14.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_15.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_15.png
new file mode 100644
index 00000000000..454308c80bf
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_15.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_16.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_16.png
new file mode 100644
index 00000000000..4b8a41d1227
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_16.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_17.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_17.png
new file mode 100644
index 00000000000..c78e4c1f50d
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_17.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_18.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_18.png
new file mode 100644
index 00000000000..2d8910e92d3
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_18.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_19.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_19.png
new file mode 100644
index 00000000000..e7773df281e
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_19.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_2.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_2.png
new file mode 100644
index 00000000000..66ecf982db8
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_2.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_20.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_20.png
new file mode 100644
index 00000000000..ef4c5a5dce0
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_20.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_21.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_21.png
new file mode 100644
index 00000000000..45d368f4abd
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_21.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_22.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_22.png
new file mode 100644
index 00000000000..558869eca31
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_22.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_23.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_23.png
new file mode 100644
index 00000000000..32a90440c14
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_23.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_24.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_24.png
new file mode 100644
index 00000000000..d1d0f253208
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_24.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_25.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_25.png
new file mode 100644
index 00000000000..ea9c7c25212
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_25.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_26.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_26.png
new file mode 100644
index 00000000000..23d5bded33e
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_26.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_27.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_27.png
new file mode 100644
index 00000000000..bef0573f69c
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_27.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_28.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_28.png
new file mode 100644
index 00000000000..cbf9b104354
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_28.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_29.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_29.png
new file mode 100644
index 00000000000..e50f55ed70a
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_29.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_3.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_3.png
new file mode 100644
index 00000000000..f52467bfcc2
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_3.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_30.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_30.png
new file mode 100644
index 00000000000..4b222c4cb20
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_30.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_31.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_31.png
new file mode 100644
index 00000000000..bb953f18218
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_31.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_32.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_32.png
new file mode 100644
index 00000000000..5622feebea6
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_32.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_33.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_33.png
new file mode 100644
index 00000000000..4779a5c5a36
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_33.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_34.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_34.png
new file mode 100644
index 00000000000..defd1094b2f
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_34.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_35.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_35.png
new file mode 100644
index 00000000000..e3e03de157e
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_35.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_36.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_36.png
new file mode 100644
index 00000000000..a6519040bd8
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_36.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_4.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_4.png
new file mode 100644
index 00000000000..24a5a5e6f93
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_4.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_5.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_5.png
new file mode 100644
index 00000000000..203fcf715be
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_5.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_6.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_6.png
new file mode 100644
index 00000000000..6a4056f6662
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_6.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_7.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_7.png
new file mode 100644
index 00000000000..a563d4fa27d
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_7.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_8.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_8.png
new file mode 100644
index 00000000000..f62f10e242d
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_8.png differ
diff --git a/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_9.png b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_9.png
new file mode 100644
index 00000000000..67ba9aa4743
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ash_runes.rsi/runaash_9.png differ
diff --git a/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/activate.png b/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/activate.png
new file mode 100644
index 00000000000..0a3b56f7098
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/activate.png differ
diff --git a/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/meta.json b/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/meta.json
new file mode 100644
index 00000000000..4637b20556a
--- /dev/null
+++ b/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/meta.json
@@ -0,0 +1,59 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/effects/ashwalker_rune.dmi",
+    "size": {
+        "x": 96,
+        "y": 96
+    },
+    "states": [
+        {
+            "name": "rune",
+            "delays": [
+                [
+                    2.5,
+                    1.5,
+                    3,
+                    1.5
+                ]
+            ]
+        },
+        {
+            "name": "activate",
+            "delays": [
+                [
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1
+                ]
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/rune.png b/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/rune.png
new file mode 100644
index 00000000000..b54e8bb1db3
Binary files /dev/null and b/Resources/Textures/ADT/Effects/ashwalker_rune.rsi/rune.png differ
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi/icon.png b/Resources/Textures/ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi/icon.png
new file mode 100644
index 00000000000..4fa0380d619
Binary files /dev/null and b/Resources/Textures/ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi/meta.json b/Resources/Textures/ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi/meta.json
new file mode 100644
index 00000000000..da9e5dd0bea
--- /dev/null
+++ b/Resources/Textures/ADT/Objects/Specific/Lavaland/ashdrake_hide.rsi/meta.json
@@ -0,0 +1,14 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/mining.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/fireblossom.rsi/icon.png b/Resources/Textures/ADT/Objects/Specific/Lavaland/fireblossom.rsi/icon.png
new file mode 100644
index 00000000000..fb0a751dc30
Binary files /dev/null and b/Resources/Textures/ADT/Objects/Specific/Lavaland/fireblossom.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/fireblossom.rsi/meta.json b/Resources/Textures/ADT/Objects/Specific/Lavaland/fireblossom.rsi/meta.json
new file mode 100644
index 00000000000..049d843cdd6
--- /dev/null
+++ b/Resources/Textures/ADT/Objects/Specific/Lavaland/fireblossom.rsi/meta.json
@@ -0,0 +1,14 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/lavaland/ash_flora.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/magma_gem.rsi/icon.png b/Resources/Textures/ADT/Objects/Specific/Lavaland/magma_gem.rsi/icon.png
new file mode 100644
index 00000000000..cc9460f2e28
Binary files /dev/null and b/Resources/Textures/ADT/Objects/Specific/Lavaland/magma_gem.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/magma_gem.rsi/meta.json b/Resources/Textures/ADT/Objects/Specific/Lavaland/magma_gem.rsi/meta.json
new file mode 100644
index 00000000000..294935f4e57
--- /dev/null
+++ b/Resources/Textures/ADT/Objects/Specific/Lavaland/magma_gem.rsi/meta.json
@@ -0,0 +1,14 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/lavaland/gems.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/small_blaze.rsi/icon.png b/Resources/Textures/ADT/Objects/Specific/Lavaland/small_blaze.rsi/icon.png
new file mode 100644
index 00000000000..e53b7b32795
Binary files /dev/null and b/Resources/Textures/ADT/Objects/Specific/Lavaland/small_blaze.rsi/icon.png differ
diff --git a/Resources/Textures/ADT/Objects/Specific/Lavaland/small_blaze.rsi/meta.json b/Resources/Textures/ADT/Objects/Specific/Lavaland/small_blaze.rsi/meta.json
new file mode 100644
index 00000000000..2125538e925
--- /dev/null
+++ b/Resources/Textures/ADT/Objects/Specific/Lavaland/small_blaze.rsi/meta.json
@@ -0,0 +1,25 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/obj/cigarettes.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "icon",
+            "delays": [
+                [
+                    0.1,
+                    0.2,
+                    0.1,
+                    0.2,
+                    0.1,
+                    0.2,
+                    0.1
+                ]
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom1.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom1.png
new file mode 100644
index 00000000000..77e70aa4df2
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom1.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom1p.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom1p.png
new file mode 100644
index 00000000000..5dc72e6d4f2
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom1p.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom2.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom2.png
new file mode 100644
index 00000000000..649c2ebfb6e
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom2.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom2p.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom2p.png
new file mode 100644
index 00000000000..92604be889f
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom2p.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom3.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom3.png
new file mode 100644
index 00000000000..f65eb07d2f0
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom3.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom3p.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom3p.png
new file mode 100644
index 00000000000..358396a4b93
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom3p.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom4.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom4.png
new file mode 100644
index 00000000000..0d72319dda1
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom4.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom4p.png b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom4p.png
new file mode 100644
index 00000000000..430b32c1f70
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/fireblossom4p.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/meta.json b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/meta.json
index 1fdc551d952..ecd822dbeea 100644
--- a/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/meta.json
+++ b/Resources/Textures/ADT/Structures/Specific/ash_flora.rsi/meta.json
@@ -102,6 +102,30 @@
         },
         {
             "name": "t_mushroom4p"
+        },
+        {
+            "name": "fireblossom1"
+        },
+        {
+            "name": "fireblossom2"
+        },
+        {
+            "name": "fireblossom3"
+        },
+        {
+            "name": "fireblossom4"
+        },
+        {
+            "name": "fireblossom1p"
+        },
+        {
+            "name": "fireblossom2p"
+        },
+        {
+            "name": "fireblossom3p"
+        },
+        {
+            "name": "fireblossom4p"
         }
     ]
 }
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/egg.png b/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/egg.png
new file mode 100644
index 00000000000..67978b0fb41
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/egg.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/egg_shaman.png b/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/egg_shaman.png
new file mode 100644
index 00000000000..7077efa2b96
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/egg_shaman.png differ
diff --git a/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/meta.json b/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/meta.json
new file mode 100644
index 00000000000..0448ef3b151
--- /dev/null
+++ b/Resources/Textures/ADT/Structures/Specific/ashwalker_egg.rsi/meta.json
@@ -0,0 +1,17 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/mob/lavaland/lavaland_monsters.dmi",
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [
+        {
+            "name": "egg"
+        },
+        {
+            "name": "egg_shaman"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Structures/Specific/ashwalker_nest.rsi/meta.json b/Resources/Textures/ADT/Structures/Specific/ashwalker_nest.rsi/meta.json
new file mode 100644
index 00000000000..4919df9b8bf
--- /dev/null
+++ b/Resources/Textures/ADT/Structures/Specific/ashwalker_nest.rsi/meta.json
@@ -0,0 +1,14 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from Paradise at https://github.com/ParadiseSS13/Paradise/blob/master/icons/mob/nest.dmi",
+    "size": {
+        "x": 32,
+        "y": 64
+    },
+    "states": [
+        {
+            "name": "nest"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/ADT/Structures/Specific/ashwalker_nest.rsi/nest.png b/Resources/Textures/ADT/Structures/Specific/ashwalker_nest.rsi/nest.png
new file mode 100644
index 00000000000..56d1829ef8f
Binary files /dev/null and b/Resources/Textures/ADT/Structures/Specific/ashwalker_nest.rsi/nest.png differ