diff --git a/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs b/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs
new file mode 100644
index 0000000000..e6e18d994a
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/ExplosionDebugOverlay.cs
@@ -0,0 +1,185 @@
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using System.Linq;
+
+namespace Content.Client.Administration.UI.SpawnExplosion;
+
+[UsedImplicitly]
+public sealed class ExplosionDebugOverlay : Overlay
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+
+    public Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles = new();
+    public List<float> Intensity = new();
+    public float TotalIntensity;
+    public float Slope;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
+
+    public Matrix3 SpaceMatrix;
+    public MapId Map;
+
+    private readonly Font _font;
+
+    public ExplosionDebugOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+
+        var cache = IoCManager.Resolve<IResourceCache>();
+        _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 8);
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (Map != _eyeManager.CurrentMap)
+            return;
+
+        if (Tiles.Count == 0 && SpaceTiles == null)
+            return;
+
+        switch (args.Space)
+        {
+            case OverlaySpace.ScreenSpace:
+                DrawScreen(args);
+                break;
+            case OverlaySpace.WorldSpace:
+                DrawWorld(args);
+                break;
+        }
+    }
+
+    private void DrawScreen(OverlayDrawArgs args)
+    {
+        var handle = args.ScreenHandle;
+        Box2 gridBounds;
+
+        foreach (var (gridId, tileSets) in Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var gridXform = _entityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            gridBounds = gridXform.InvWorldMatrix.TransformBox(args.WorldBounds);
+
+            DrawText(handle, gridBounds, gridXform.WorldMatrix, tileSets);
+        }
+
+        if (SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+
+        DrawText(handle, gridBounds, SpaceMatrix, SpaceTiles);
+    }
+
+    private void DrawText(
+        DrawingHandleScreen handle,
+        Box2 gridBounds,
+        Matrix3 transform,
+        Dictionary<int, List<Vector2i>> tileSets)
+    {
+        for (var i = 1; i < Intensity.Count; i++)
+        {
+            if (!tileSets.TryGetValue(i, out var tiles))
+                continue;
+
+            foreach (var tile in tiles)
+            {
+                // is the center of this tile visible to the user?
+                if (!gridBounds.Contains((Vector2) tile + 0.5f))
+                    continue;
+
+                var worldCenter = transform.Transform((Vector2) tile + 0.5f);
+
+                var screenCenter = _eyeManager.WorldToScreen(worldCenter);
+
+                if (Intensity![i] > 9)
+                    screenCenter += (-12, -8);
+                else
+                    screenCenter += (-8, -8);
+
+                handle.DrawString(_font, screenCenter, Intensity![i].ToString("F2"));
+            }
+        }
+
+        if (tileSets.ContainsKey(0))
+        {
+            var epicenter = tileSets[0].First();
+            var worldCenter = transform.Transform((Vector2) epicenter + 0.5f);
+            var screenCenter = _eyeManager.WorldToScreen(worldCenter) + (-24, -24);
+            var text = $"{Intensity![0]:F2}\nΣ={TotalIntensity:F1}\nΔ={Slope:F1}";
+            handle.DrawString(_font, screenCenter, text);
+        }
+    }
+
+    private void DrawWorld(in OverlayDrawArgs args)
+    {
+        var handle = args.WorldHandle;
+        Box2 gridBounds;
+
+        foreach (var (gridId, tileSets) in Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            var gridXform = _entityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            handle.SetTransform(gridXform.WorldMatrix);
+            gridBounds = gridXform.InvWorldMatrix.TransformBox(args.WorldBounds);
+
+            DrawTiles(handle, gridBounds, tileSets);
+        }
+
+        if (SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+        handle.SetTransform(SpaceMatrix);
+
+        DrawTiles(handle, gridBounds, SpaceTiles);
+    }
+
+    private void DrawTiles(
+        DrawingHandleWorld handle,
+        Box2 gridBounds,
+        Dictionary<int, List<Vector2i>> tileSets)
+    {
+        for (var i = 0; i < Intensity.Count; i++)
+        {
+            var color = ColorMap(Intensity![i]);
+            var colorTransparent = color;
+            colorTransparent.A = 0.2f;
+
+
+            if (!tileSets.TryGetValue(i, out var tiles))
+                continue;
+
+            foreach (var tile in tiles)
+            {
+                // is the center of this tile visible to the user?
+                if (!gridBounds.Contains((Vector2) tile + 0.5f))
+                    continue;
+
+                var box = Box2.UnitCentered.Translated((Vector2) tile + 0.5f);
+                handle.DrawRect(box, color, false);
+                handle.DrawRect(box, colorTransparent);
+            }
+        }
+    }
+
+    private Color ColorMap(float intensity)
+    {
+        var frac = 1 - intensity / Intensity![0];
+        Color result;
+        if (frac < 0.5f)
+            result = Color.InterpolateBetween(Color.Red, Color.Orange, frac * 2);
+        else
+            result = Color.InterpolateBetween(Color.Orange, Color.Yellow, (frac - 0.5f) * 2);
+        return result;
+    }
+}
diff --git a/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs
new file mode 100644
index 0000000000..7bcfb3b069
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionEui.cs
@@ -0,0 +1,75 @@
+using Content.Client.Eui;
+using Content.Shared.Administration;
+using Content.Shared.Eui;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Map;
+
+namespace Content.Client.Administration.UI.SpawnExplosion;
+
+[UsedImplicitly]
+public sealed class SpawnExplosionEui : BaseEui
+{
+    [Dependency] private readonly IOverlayManager _overlayManager = default!;
+
+    private readonly SpawnExplosionWindow _window;
+    private ExplosionDebugOverlay? _debugOverlay;
+
+    public SpawnExplosionEui()
+    {
+        IoCManager.InjectDependencies(this);
+        _window = new SpawnExplosionWindow(this);
+        _window.OnClose += () => SendMessage(new SpawnExplosionEuiMsg.Close());
+    }
+
+    public override void Opened()
+    {
+        base.Opened();
+        _window.OpenCentered();
+    }
+
+    public override void Closed()
+    {
+        base.Closed();
+        _window.OnClose -= () => SendMessage(new SpawnExplosionEuiMsg.Close());
+        _window.Close();
+        ClearOverlay();
+    }
+
+    public void ClearOverlay()
+    {
+        if (_overlayManager.HasOverlay<ExplosionDebugOverlay>())
+            _overlayManager.RemoveOverlay<ExplosionDebugOverlay>();
+        _debugOverlay = null;
+    }
+
+    public void RequestPreviewData(MapCoordinates epicenter, string typeId, float totalIntensity, float intensitySlope, float maxIntensity)
+    {
+        var msg = new SpawnExplosionEuiMsg.PreviewRequest(epicenter, typeId, totalIntensity, intensitySlope, maxIntensity);
+        SendMessage(msg);
+    }
+
+    /// <summary>
+    ///     Receive explosion preview data and add a client-side explosion preview overlay
+    /// </summary>
+    /// <param name="msg"></param>
+    public override void HandleMessage(EuiMessageBase msg)
+    {
+        if (msg is not SpawnExplosionEuiMsg.PreviewData data)
+            return;
+
+        if (_debugOverlay == null)
+        {
+            _debugOverlay = new();
+            _overlayManager.AddOverlay(_debugOverlay);
+        }
+
+        _debugOverlay.Tiles = data.Explosion.Tiles;
+        _debugOverlay.SpaceTiles = data.Explosion.SpaceTiles;
+        _debugOverlay.Intensity = data.Explosion.Intensity;
+        _debugOverlay.Slope = data.Slope;
+        _debugOverlay.TotalIntensity = data.TotalIntensity;
+        _debugOverlay.Map = data.Explosion.Epicenter.MapId;
+        _debugOverlay.SpaceMatrix = data.Explosion.SpaceMatrix;
+    }
+}
diff --git a/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml
new file mode 100644
index 0000000000..f1dcd35cb8
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml
@@ -0,0 +1,46 @@
+<DefaultWindow
+    xmlns="https://spacestation14.io"
+    Title="{Loc 'admin-explosion-eui-title'}"
+    SetHeight="380">
+    <BoxContainer Name="MainContainer" Orientation="Vertical">
+
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-type'}" MinSize="120 0" />
+            <OptionButton Name="ExplosionOption" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-mapid'}" MinSize="120 0" />
+            <OptionButton Name="MapOptions" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-xmap'}" MinSize="120 0" />
+            <FloatSpinBox Name="MapX" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-ymap'}" MinSize="120 0" />
+            <FloatSpinBox Name="MapY" MinSize="70 0" HorizontalExpand="True" />
+        </BoxContainer>
+        <Button Name="Recentre" Text="{Loc 'admin-explosion-eui-label-current'}" />
+
+        <Control MinSize="0 20"/>
+
+        <CheckBox Name="Preview" Text="{Loc 'admin-explosion-eui-label-preview'}"/>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-total'}" MinSize="120 0"/>
+            <FloatSpinBox Name="Intensity" MinSize="130 0" HorizontalExpand="True" Value="200"/>
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-slope'}" MinSize="120 0" />
+            <FloatSpinBox Name="Slope" MinSize="130 0" HorizontalExpand="True" Value="5"/>
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'admin-explosion-eui-label-max'}" MinSize="120 0" />
+            <FloatSpinBox Name="MaxIntensity" MinSize="130 0" HorizontalExpand="True" Value="100"/>
+        </BoxContainer>
+
+        <Control MinSize="0 20"/>
+
+        <Button Name="Spawn" Text="{Loc 'admin-explosion-eui-label-spawn'}" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs
new file mode 100644
index 0000000000..6399c1e03c
--- /dev/null
+++ b/Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs
@@ -0,0 +1,142 @@
+using Content.Shared.Explosion;
+using JetBrains.Annotations;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Console;
+using Robust.Client.Player;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using static Robust.Client.UserInterface.Controls.BaseButton;
+using static Robust.Client.UserInterface.Controls.OptionButton;
+
+namespace Content.Client.Administration.UI.SpawnExplosion;
+
+[GenerateTypedNameReferences]
+[UsedImplicitly]
+public sealed partial class SpawnExplosionWindow : DefaultWindow
+{
+    [Dependency] private readonly IClientConsoleHost _conHost = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IEntityManager _entMan = default!;
+
+
+    private readonly SpawnExplosionEui _eui;
+    private List<MapId> _mapData = new();
+    private List<string> _explosionTypes = new();
+
+    /// <summary>
+    ///     Used to prevent unnecessary preview updates when setting fields (e.g., updating position)..
+    /// </summary>
+    private bool _pausePreview;
+
+    public SpawnExplosionWindow(SpawnExplosionEui eui)
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+        _eui = eui;
+
+        ExplosionOption.OnItemSelected += ExplosionSelected;
+        MapOptions.OnItemSelected += MapSelected;
+        Recentre.OnPressed += (_) => SetLocation();
+        Spawn.OnPressed += SubmitButtonOnOnPressed;
+
+        Preview.OnToggled += (_) => UpdatePreview();
+        MapX.OnValueChanged += (_) => UpdatePreview();
+        MapY.OnValueChanged += (_) => UpdatePreview();
+        Intensity.OnValueChanged += (_) => UpdatePreview();
+        Slope.OnValueChanged += (_) => UpdatePreview();
+        MaxIntensity.OnValueChanged += (_) => UpdatePreview();
+    }
+
+    private void ExplosionSelected(ItemSelectedEventArgs args)
+    {
+        ExplosionOption.SelectId(args.Id);
+        UpdatePreview();
+    }
+
+    private void MapSelected(ItemSelectedEventArgs args)
+    {
+        MapOptions.SelectId(args.Id);
+        UpdatePreview();
+    }
+
+    protected override void EnteredTree()
+    {
+        SetLocation();
+        UpdateExplosionTypeOptions();
+    }
+
+    private void UpdateExplosionTypeOptions()
+    {
+        _explosionTypes.Clear();
+        ExplosionOption.Clear();
+        foreach (var type in _prototypeManager.EnumeratePrototypes<ExplosionPrototype>())
+        {
+            _explosionTypes.Add(type.ID);
+            ExplosionOption.AddItem(type.ID);
+        }
+    }
+
+    private void UpdateMapOptions()
+    {
+        _mapData.Clear();
+        MapOptions.Clear();
+        foreach (var map in _mapManager.GetAllMapIds())
+        {
+            _mapData.Add(map);
+            MapOptions.AddItem(map.ToString());
+        }
+    }
+
+    /// <summary>
+    ///     Set the current grid & indices based on the attached entities current location.
+    /// </summary>
+    private void SetLocation()
+    {
+        UpdateMapOptions();
+
+        if (!_entMan.TryGetComponent(_playerManager.LocalPlayer?.ControlledEntity, out TransformComponent? transform))
+            return;
+
+        _pausePreview = true;
+        MapOptions.Select(_mapData.IndexOf(transform.MapID));
+        (MapX.Value, MapY.Value) = transform.MapPosition.Position;
+        _pausePreview = false;
+
+        UpdatePreview();
+    }
+
+    private void UpdatePreview()
+    {
+        if (_pausePreview)
+            return;
+
+        if (!Preview.Pressed)
+        {
+            _eui.ClearOverlay();
+            return;
+        }
+
+        MapCoordinates coords = new((MapX.Value, MapY.Value), _mapData[MapOptions.SelectedId]);
+        var explosionType = _explosionTypes[ExplosionOption.SelectedId];
+        _eui.RequestPreviewData(coords, explosionType, Intensity.Value, Slope.Value, MaxIntensity.Value);
+    }
+
+    private void SubmitButtonOnOnPressed(ButtonEventArgs args)
+    {
+        // need to make room to view the fireworks
+        Preview.Pressed = false;
+        _eui.ClearOverlay();
+
+        // for the actual explosion, we will just re-use the explosion command.
+        // so assemble command arguments:
+        var mapId = _mapData[MapOptions.SelectedId];
+        var explosionType = _explosionTypes[ExplosionOption.SelectedId];
+        var cmd = $"explosion {Intensity.Value} {Slope.Value} {MaxIntensity.Value} {MapX.Value} {MapY.Value} {mapId} {explosionType}";
+
+        _conHost.ExecuteCommand(cmd);
+    }
+}
diff --git a/Content.Client/Entry/IgnoredComponents.cs b/Content.Client/Entry/IgnoredComponents.cs
index fa31384c4a..dc6accbbab 100644
--- a/Content.Client/Entry/IgnoredComponents.cs
+++ b/Content.Client/Entry/IgnoredComponents.cs
@@ -16,6 +16,7 @@ namespace Content.Client.Entry
             "Temperature",
             "AtmosExposed",
             "Explosive",
+            "ExplosionResistance",
             "Vocal",
             "OnUseTimerTrigger",
             "WarpPoint",
diff --git a/Content.Client/Explosion/ExplosionOverlay.cs b/Content.Client/Explosion/ExplosionOverlay.cs
new file mode 100644
index 0000000000..8e71c0e5d0
--- /dev/null
+++ b/Content.Client/Explosion/ExplosionOverlay.cs
@@ -0,0 +1,120 @@
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Client.Explosion;
+
+[UsedImplicitly]
+public sealed class ExplosionOverlay : Overlay
+{
+    /// <summary>
+    ///     The explosion that needs to be drawn. This explosion is currently being processed by the server and
+    ///     expanding outwards.
+    /// </summary>
+    internal Explosion? ActiveExplosion;
+
+    /// <summary>
+    ///     This index specifies what parts of the currently expanding explosion should be drawn.
+    /// </summary>
+    public int Index;
+
+    /// <summary>
+    ///     These explosions have finished expanding, but we will draw for a few more frames. This is important for
+    ///     small explosions, as otherwise they disappear far too quickly.
+    /// </summary>
+    internal List<Explosion> CompletedExplosions = new ();
+
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IRobustRandom _robustRandom = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
+
+    /// <summary>
+    ///     How intense does the explosion have to be at a tile to advance to the next fire texture state?
+    /// </summary>
+    public const int IntensityPerState = 12;
+
+    private ShaderInstance _shader;
+
+    public ExplosionOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _shader = IoCManager.Resolve<IPrototypeManager>().Index<ShaderPrototype>("unshaded").Instance();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var drawHandle = args.WorldHandle;
+        drawHandle.UseShader(_shader);
+
+        if (ActiveExplosion != null)
+        {
+            DrawExplosion(drawHandle, args.WorldBounds, ActiveExplosion, Index);
+        }
+
+        foreach (var exp in CompletedExplosions)
+        {
+            DrawExplosion(drawHandle, args.WorldBounds, exp, exp.Intensity.Count);
+        }
+
+        drawHandle.SetTransform(Matrix3.Identity);
+    }
+
+    private void DrawExplosion(DrawingHandleWorld drawHandle, Box2Rotated worldBounds, Explosion exp, int index)
+    {
+        if (exp.Map != _eyeManager.CurrentMap)
+            return;
+
+        Box2 gridBounds;
+        foreach (var (gridId, tiles) in exp.Tiles)
+        {
+            if (!_mapManager.TryGetGrid(gridId, out var grid))
+                continue;
+
+            gridBounds = grid.InvWorldMatrix.TransformBox(worldBounds);
+            drawHandle.SetTransform(grid.WorldMatrix);
+
+            DrawTiles(drawHandle, gridBounds, index, tiles, exp);
+        }
+
+        if (exp.SpaceTiles == null)
+            return;
+
+        gridBounds = Matrix3.Invert(exp.SpaceMatrix).TransformBox(worldBounds);
+        drawHandle.SetTransform(exp.SpaceMatrix);
+        
+        DrawTiles(drawHandle, gridBounds, index, exp.SpaceTiles, exp);
+    }
+
+    private void DrawTiles(
+        DrawingHandleWorld drawHandle,
+        Box2 gridBounds,
+        int index,
+        Dictionary<int, List<Vector2i>> tileSets,
+        Explosion exp)
+    {
+        for (var j = 0; j < index; j++)
+        {
+            if (!tileSets.TryGetValue(j, out var tiles))
+                continue;
+
+            var frameIndex = (int) Math.Min(exp.Intensity[j] / IntensityPerState, exp.FireFrames.Count - 1);
+            var frames = exp.FireFrames[frameIndex];
+
+            foreach (var tile in tiles)
+            {
+                Vector2 bottomLeft = (tile.X, tile.Y);
+
+                if (!gridBounds.Contains((bottomLeft + 0.5f) * 1f))
+                    continue;
+
+                var texture = _robustRandom.Pick(frames);
+                drawHandle.DrawTexture(texture, bottomLeft, exp.FireColor);
+            }
+        }
+    }
+}
diff --git a/Content.Client/Explosion/ExplosionOverlaySystem.cs b/Content.Client/Explosion/ExplosionOverlaySystem.cs
new file mode 100644
index 0000000000..486f65e28a
--- /dev/null
+++ b/Content.Client/Explosion/ExplosionOverlaySystem.cs
@@ -0,0 +1,190 @@
+using Content.Shared.Explosion;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Explosion;
+
+/// <summary>
+///     This system is responsible for showing the client-side explosion effects (light source & fire-overlay). The
+///     fire overlay code is just a bastardized version of the atmos plasma fire overlay and uses the same texture.
+/// </summary>
+public sealed class ExplosionOverlaySystem : EntitySystem
+{
+    private ExplosionOverlay _overlay = default!;
+
+    [Dependency] private readonly IPrototypeManager _protoMan = default!;
+
+
+    /// <summary>
+    ///     For how many seconds should an explosion stay on-screen once it has finished expanding?
+    /// </summary>
+    public const float ExplosionPersistence = 0.3f;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<ExplosionEvent>(OnExplosion);
+        SubscribeNetworkEvent<ExplosionOverlayUpdateEvent>(HandleExplosionUpdate);
+
+        var overlayManager = IoCManager.Resolve<IOverlayManager>();
+        _overlay = new ExplosionOverlay();
+        if (!overlayManager.HasOverlay<ExplosionOverlay>())
+            overlayManager.AddOverlay(_overlay);
+    }
+
+    public override void FrameUpdate(float frameTime)
+    {
+        base.FrameUpdate(frameTime);
+
+        // increment the lifetime of completed explosions, and remove them if they have been ons screen for more
+        // than ExplosionPersistence seconds
+        foreach (var explosion in _overlay.CompletedExplosions.ToArray())
+        {
+            explosion.Lifetime += frameTime;
+
+            if (explosion.Lifetime >= ExplosionPersistence)
+            {
+                EntityManager.QueueDeleteEntity(explosion.LightEntity);
+                _overlay.CompletedExplosions.Remove(explosion);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     The server has processed some explosion. This updates the client-side overlay so that the area covered
+    ///     by the fire-visual matches up with the area that the explosion has affected.
+    /// </summary>
+    private void HandleExplosionUpdate(ExplosionOverlayUpdateEvent args)
+    {
+        if (args.ExplosionId != _overlay.ActiveExplosion?.Explosionid && !IsNewer(args.ExplosionId))
+        {
+            // out of order events. Ignore.
+            return;
+        }
+
+        _overlay.Index = args.Index;
+
+        if (_overlay.ActiveExplosion == null)
+        {
+            // no active explosion... events out of order?
+            return;
+        }
+
+        if (args.Index != int.MaxValue)
+            return;
+
+        // the explosion has finished expanding
+        _overlay.Index = 0;
+        _overlay.CompletedExplosions.Add(_overlay.ActiveExplosion);
+        _overlay.ActiveExplosion = null;
+    }
+
+    /// <summary>
+    ///     A new explosion occurred. This prepares the client-side light entity and stores the
+    ///     explosion/fire-effect overlay data.
+    /// </summary>
+    private void OnExplosion(ExplosionEvent args)
+    {
+        if (!_protoMan.TryIndex(args.TypeID, out ExplosionPrototype? type))
+            return;
+
+        // spawn in a light source at the epicenter
+        var lightEntity = Spawn("ExplosionLight", args.Epicenter);
+        var light = EnsureComp<PointLightComponent>(lightEntity);
+        light.Energy = light.Radius = args.Intensity.Count;
+        light.Color = type.LightColor;
+
+        if (_overlay.ActiveExplosion == null)
+        {
+            _overlay.ActiveExplosion = new(args, type, lightEntity);
+            return;
+        }
+
+        // we have a currently active explosion. Can happen when events are received out of order. either multiple
+        // explosions are happening in one tick, or a new explosion was received before the event telling us the old one
+        // finished got through.
+
+        if (IsNewer(args.ExplosionId))
+        {
+            // This is a newer explosion. Add the old-currently-active explosions to the completed list
+            _overlay.CompletedExplosions.Add(_overlay.ActiveExplosion);
+            _overlay.ActiveExplosion = new(args, type, lightEntity);
+        }
+        else
+        {
+            // explosions were out of order. keep the active one, and directly add the received one to the completed
+            // list.
+            _overlay.CompletedExplosions.Add(new(args, type, lightEntity));
+            return;
+        }
+    }
+
+    public bool IsNewer(byte explosionId)
+    {
+        if (_overlay.ActiveExplosion == null)
+            return true;
+
+        // byte goes up to 255, then wraps back to zero.
+        // what are the odds of more than 128 explosions happening in a tick?
+        return _overlay.ActiveExplosion.Explosionid < explosionId
+            || _overlay.ActiveExplosion.Explosionid > 192 && explosionId < 64;
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+
+        var overlayManager = IoCManager.Resolve<IOverlayManager>();
+        if (overlayManager.HasOverlay<ExplosionOverlay>())
+            overlayManager.RemoveOverlay<ExplosionOverlay>();
+    }
+}
+
+internal sealed class Explosion
+{
+    public Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles;
+    public List<float> Intensity;
+    public EntityUid LightEntity;
+    public MapId Map;
+    public byte Explosionid;
+
+    public Matrix3 SpaceMatrix;
+
+    /// <summary>
+    ///     How long have we been drawing this explosion, starting from the time the explosion was fully drawn.
+    /// </summary>
+    public float Lifetime;
+
+    /// <summary>
+    ///     The textures used for the explosion fire effect. Each fire-state is associated with an explosion
+    ///     intensity range, and each stat itself has several textures.
+    /// </summary>
+    public List<Texture[]> FireFrames = new();
+
+    public Color? FireColor;
+
+    internal Explosion(ExplosionEvent args, ExplosionPrototype type, EntityUid lightEntity)
+    {
+        Map = args.Epicenter.MapId;
+        SpaceTiles = args.SpaceTiles;
+        Tiles = args.Tiles;
+        Intensity = args.Intensity;
+        SpaceMatrix = args.SpaceMatrix;
+        Explosionid = args.ExplosionId;
+        FireColor = type.FireColor;
+        LightEntity = lightEntity;
+
+        var fireRsi = IoCManager.Resolve<IResourceCache>().GetResource<RSIResource>(type.TexturePath).RSI;
+        foreach (var state in fireRsi)
+        {
+            FireFrames.Add(state.GetFrames(RSI.State.Direction.South));
+            if (FireFrames.Count == type.FireStates)
+                break;
+        }
+    }
+}
diff --git a/Content.Server/AME/AMENodeGroup.cs b/Content.Server/AME/AMENodeGroup.cs
index 8c22be06fd..c434c1eb52 100644
--- a/Content.Server/AME/AMENodeGroup.cs
+++ b/Content.Server/AME/AMENodeGroup.cs
@@ -162,22 +162,21 @@ namespace Content.Server.AME
         {
             if(_cores.Count < 1 || MasterController == null) { return; }
 
-            var intensity = 0;
+            float radius = 0;
 
             /*
              * todo: add an exact to the shielding and make this find the core closest to the controller
              * so they chain explode, after helpers have been added to make it not cancer
             */
-            var epicenter = _cores.First();
 
             foreach (AMEShieldComponent core in _cores)
             {
-                intensity += MasterController.InjectionAmount;
+                radius += MasterController.InjectionAmount;
             }
 
-            intensity = Math.Min(intensity, 8);
-
-            EntitySystem.Get<ExplosionSystem>().SpawnExplosion(epicenter.Owner, intensity / 2, intensity, intensity * 2, intensity * 3);
+            radius *= 2;
+            radius = Math.Min(radius, 8);
+            EntitySystem.Get<ExplosionSystem>().TriggerExplosive(MasterController.Owner, radius: radius, delete: false);
         }
     }
 }
diff --git a/Content.Server/Administration/AdminVerbSystem.cs b/Content.Server/Administration/AdminVerbSystem.cs
index 4c975847ae..f388ff5e75 100644
--- a/Content.Server/Administration/AdminVerbSystem.cs
+++ b/Content.Server/Administration/AdminVerbSystem.cs
@@ -47,7 +47,7 @@ namespace Content.Server.Administration
         [Dependency] private readonly IAdminManager _adminManager = default!;
         [Dependency] private readonly IGameTiming _gameTiming = default!;
         [Dependency] private readonly EuiManager _euiManager = default!;
-        [Dependency] private readonly ExplosionSystem _explosions = default!;
+        [Dependency] private readonly ExplosionSystem _explosionSystem = default!;
         [Dependency] private readonly GhostRoleSystem _ghostRoleSystem = default!;
         [Dependency] private readonly ArtifactSystem _artifactSystem = default!;
 
@@ -155,8 +155,8 @@ namespace Content.Server.Administration
                 verb.Category = VerbCategory.Admin;
                 verb.Act = () =>
                 {
-                    var coords = Transform(args.Target).Coordinates;
-                    Timer.Spawn(_gameTiming.TickPeriod, () => _explosions.SpawnExplosion(coords, 0, 1, 2, 1), CancellationToken.None);
+                    var coords = Transform(args.Target).MapPosition;
+                    Timer.Spawn(_gameTiming.TickPeriod, () => _explosionSystem.QueueExplosion(coords, "Default", 30, 4, 8), CancellationToken.None);
                     if (TryComp(args.Target, out SharedBodyComponent? body))
                     {
                         body.Gib();
diff --git a/Content.Server/Administration/Commands/ExplosionCommand.cs b/Content.Server/Administration/Commands/ExplosionCommand.cs
index 6e94dc4030..a72c055deb 100644
--- a/Content.Server/Administration/Commands/ExplosionCommand.cs
+++ b/Content.Server/Administration/Commands/ExplosionCommand.cs
@@ -1,42 +1,134 @@
+using Content.Server.Administration.UI;
+using Content.Server.EUI;
 using Content.Server.Explosion.EntitySystems;
 using Content.Shared.Administration;
+using Content.Shared.Explosion;
 using Robust.Server.Player;
 using Robust.Shared.Console;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using System.Linq;
 
-namespace Content.Server.Administration.Commands
+namespace Content.Server.Administration.Commands;
+
+[AdminCommand(AdminFlags.Fun)]
+public sealed class OpenExplosionEui : IConsoleCommand
 {
-    [AdminCommand(AdminFlags.Fun)]
-    public sealed class ExplosionCommand : IConsoleCommand
-    {
-        public string Command => "explode";
-        public string Description => "Train go boom";
-        public string Help => "Usage: explode <x> <y> <dev> <heavy> <light> <flash>\n" +
-                              "The explosion happens on the same map as the user.";
+    public string Command => "explosionui";
+    public string Description => "Opens a window for easy access to station destruction";
+    public string Help => $"Usage: {Command}";
 
-        public void Execute(IConsoleShell shell, string argStr, string[] args)
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        var player = shell.Player as IPlayerSession;
+        if (player == null)
         {
-            var player = shell.Player as IPlayerSession;
-            if (player?.AttachedEntity is not {Valid: true} playerEntity)
+            shell.WriteLine("This does not work from the server console.");
+            return;
+        }
+
+        var eui = IoCManager.Resolve<EuiManager>();
+        var ui = new SpawnExplosionEui();
+        eui.OpenEui(ui, player);
+    }
+}
+
+[AdminCommand(AdminFlags.Fun)] // for the admin. Not so much for anyone else.
+public sealed class ExplosionCommand : IConsoleCommand
+{
+    public string Command => "explosion";
+    public string Description => "Train go boom";
+
+    // Note that if you change the arguments, you should also update the client-side SpawnExplosionWindow, as that just
+    // uses this command.
+    public string Help => "Usage: explosion intensity [slope] [maxIntensity] [x y] [mapId] [prototypeId]";
+
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length == 0 || args.Length == 4 || args.Length > 7)
+        {
+            shell.WriteLine("Wrong number of arguments.");
+            return;
+        }
+
+        if (!float.TryParse(args[0], out var intensity))
+        {
+            shell.WriteLine($"Failed to parse intensity: {args[0]}");
+            return;
+        }
+ 
+        float slope = 5;
+        if (args.Length > 1 && !float.TryParse(args[1], out slope))
+        {
+            shell.WriteLine($"Failed to parse float: {args[1]}");
+            return;
+        }
+
+        float maxIntensity = 100;
+        if (args.Length > 2 && !float.TryParse(args[2], out maxIntensity))
+        {
+            shell.WriteLine($"Failed to parse float: {args[2]}");
+            return;
+        }
+
+        float x = 0, y = 0;
+        if (args.Length > 4)
+        {
+            if (!float.TryParse(args[3], out x) ||
+                !float.TryParse(args[4], out y))
             {
-                shell.WriteLine("You must have an attached entity.");
+                shell.WriteLine($"Failed to parse coordinates: {(args[3], args[4])}");
+                return;
+            }
+        }
+
+        MapCoordinates coords;
+        if (args.Length > 5)
+        {
+            if (!int.TryParse(args[5], out var parsed))
+            {
+                shell.WriteLine($"Failed to parse map ID: {args[5]}");
+                return;
+            }
+            coords = new MapCoordinates((x, y), new(parsed));
+        }
+        else
+        {
+            // attempt to find the player's current position
+            var entMan = IoCManager.Resolve<IEntityManager>();
+            if (!entMan.TryGetComponent(shell.Player?.AttachedEntity, out TransformComponent? xform))
+            {
+                shell.WriteLine($"Failed get default coordinates/map via player's transform. Need to specify explicitly.");
                 return;
             }
 
-            var x = float.Parse(args[0]);
-            var y = float.Parse(args[1]);
+            if (args.Length > 4)
+                coords = new MapCoordinates((x, y), xform.MapID);
+            else
+                coords = xform.MapPosition;
 
-            var dev = int.Parse(args[2]);
-            var hvy = int.Parse(args[3]);
-            var lgh = int.Parse(args[4]);
-            var fla = int.Parse(args[5]);
-
-            var mapTransform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(playerEntity).GetMapTransform();
-            var coords = new EntityCoordinates(mapTransform.Owner, x, y);
-
-            EntitySystem.Get<ExplosionSystem>().SpawnExplosion(coords, dev, hvy, lgh, fla);
         }
+
+        ExplosionPrototype? type;
+        var protoMan = IoCManager.Resolve<IPrototypeManager>();
+        if (args.Length > 6)
+        {
+            if (!protoMan.TryIndex(args[6], out type))
+            {
+                shell.WriteLine($"Unknown explosion prototype: {args[6]}");
+                return;
+            }
+        }
+        else
+        {
+            // no prototype was specified, so lets default to whichever one was defined first
+            var types = protoMan.EnumeratePrototypes<ExplosionPrototype>();
+            if (!types.Any())
+                return;
+
+            type = types.First();
+        }
+
+        EntitySystem.Get<ExplosionSystem>().QueueExplosion(coords, type.ID, intensity, slope, maxIntensity);
     }
 }
diff --git a/Content.Server/Administration/UI/SpawnExplosionEui.cs b/Content.Server/Administration/UI/SpawnExplosionEui.cs
new file mode 100644
index 0000000000..e2c1626b23
--- /dev/null
+++ b/Content.Server/Administration/UI/SpawnExplosionEui.cs
@@ -0,0 +1,39 @@
+using Content.Server.EUI;
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Administration;
+using Content.Shared.Eui;
+using JetBrains.Annotations;
+
+namespace Content.Server.Administration.UI;
+
+/// <summary>
+///     Admin Eui for spawning and preview-ing explosions
+/// </summary>
+[UsedImplicitly]
+public sealed class SpawnExplosionEui : BaseEui
+{
+    public override void HandleMessage(EuiMessageBase msg)
+    {
+        if (msg is SpawnExplosionEuiMsg.Close)
+        {
+            Close();
+            return;
+        }
+
+        if (msg is not SpawnExplosionEuiMsg.PreviewRequest request)
+            return;
+
+        if (request.TotalIntensity <= 0 || request.IntensitySlope <= 0)
+            return;
+
+        var explosion = EntitySystem.Get<ExplosionSystem>().GenerateExplosionPreview(request);
+
+        if (explosion == null)
+        {
+            Logger.Error("Failed to generate explosion preview.");
+            return;
+        }
+
+        SendMessage(new SpawnExplosionEuiMsg.PreviewData(explosion, request.IntensitySlope, request.TotalIntensity));
+    }
+}
diff --git a/Content.Server/Atmos/Components/GasTankComponent.cs b/Content.Server/Atmos/Components/GasTankComponent.cs
index c4b042a261..1a3986bc25 100644
--- a/Content.Server/Atmos/Components/GasTankComponent.cs
+++ b/Content.Server/Atmos/Components/GasTankComponent.cs
@@ -245,14 +245,14 @@ namespace Content.Server.Atmos.Components
                 var range = (pressure - TankFragmentPressure) / TankFragmentScale;
 
                 // Let's cap the explosion, yeah?
+                // !1984
                 if (range > MaxExplosionRange)
                 {
                     range = MaxExplosionRange;
                 }
 
-                EntitySystem.Get<ExplosionSystem>().SpawnExplosion(Owner, (int) (range * 0.25f), (int) (range * 0.5f), (int) (range * 1.5f), 1);
+                EntitySystem.Get<ExplosionSystem>().TriggerExplosive(Owner, radius: range);
 
-                _entMan.QueueDeleteEntity(Owner);
                 return;
             }
 
diff --git a/Content.Server/Atmos/EntitySystems/AirtightSystem.cs b/Content.Server/Atmos/EntitySystems/AirtightSystem.cs
index db2f173bbf..89792aa5e0 100644
--- a/Content.Server/Atmos/EntitySystems/AirtightSystem.cs
+++ b/Content.Server/Atmos/EntitySystems/AirtightSystem.cs
@@ -1,4 +1,5 @@
 using Content.Server.Atmos.Components;
+using Content.Server.Explosion.EntitySystems;
 using Content.Server.Kudzu;
 using Content.Shared.Atmos;
 using JetBrains.Annotations;
@@ -14,6 +15,7 @@ namespace Content.Server.Atmos.EntitySystems
     {
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
+        [Dependency] private readonly ExplosionSystem _explosionSystem = default!;
 
         public override void Initialize()
         {
@@ -104,6 +106,7 @@ namespace Content.Server.Atmos.EntitySystems
             if (!gridId.IsValid())
                 return;
 
+            _explosionSystem.UpdateAirtightMap(gridId, pos);
             _atmosphereSystem.UpdateAdjacent(gridId, pos);
             _atmosphereSystem.InvalidateTile(gridId, pos);
 
diff --git a/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs b/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
index 4416f74dfc..65cb6e542f 100644
--- a/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
+++ b/Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
@@ -1,78 +1,68 @@
-using System;
 using System.Text.Json.Serialization;
-using Content.Server.Chemistry.Components.SolutionManager;
 using Content.Server.Explosion.EntitySystems;
-using Content.Shared.Administration.Logs;
 using Content.Shared.Chemistry.Reagent;
 using Content.Shared.Database;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization.Manager.Attributes;
+using Content.Shared.Explosion;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Server.Chemistry.ReactionEffects
 {
     [DataDefinition]
-    public sealed class ExplosionReactionEffect : ReagentEffect
+    public class ExplosionReactionEffect : ReagentEffect
     {
-        [DataField("devastationRange")]
+        /// <summary>
+        ///     The type of explosion. Determines damage types and tile break chance scaling.
+        /// </summary>
+        [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
         [JsonIgnore]
-        private float _devastationRange = 1;
-
-        [DataField("heavyImpactRange")]
-        [JsonIgnore]
-        private float _heavyImpactRange = 2;
-
-        [DataField("lightImpactRange")]
-        [JsonIgnore]
-        private float _lightImpactRange = 3;
-
-        [DataField("flashRange")]
-        [JsonIgnore]
-        private float _flashRange;
+        public string ExplosionType = default!;
 
         /// <summary>
-        /// If true, then scale ranges by intensity. If not, the ranges are the same regardless of reactant amount.
+        ///     The max intensity the explosion can have at a given tile. Places an upper limit of damage and tile break
+        ///     chance.
         /// </summary>
-        [DataField("scaled")]
+        [DataField("maxIntensity")]
         [JsonIgnore]
-        private bool _scaled;
+        public float MaxIntensity = 5;
+        
+        /// <summary>
+        ///     How quickly intensity drops off as you move away from the epicenter
+        /// </summary>
+        [DataField("intensitySlope")]
+        [JsonIgnore]
+        public float IntensitySlope = 1;
 
         /// <summary>
-        /// Maximum scaling on ranges. For example, if it equals 5, then it won't scaled anywhere past
-        /// 5 times the minimum reactant amount.
+        ///     The maximum total intensity that this chemical reaction can achieve. Basically here to prevent people
+        ///     from creating a nuke by collecting enough potassium and water.
         /// </summary>
-        [DataField("maxScale")]
+        /// <remarks>
+        ///     A slope of 1 and MaxTotalIntensity of 100 corresponds to a radius of around 4.5 tiles.
+        /// </remarks>
+        [DataField("maxTotalIntensity")]
         [JsonIgnore]
-        private float _maxScale = 1;
+        public float MaxTotalIntensity = 100;
+
+        /// <summary>
+        ///     The intensity of the explosion per unit reaction.
+        /// </summary>
+        [DataField("intensityPerUnit")]
+        [JsonIgnore]
+        public float IntensityPerUnit = 1;
 
         public override bool ShouldLog => true;
         public override LogImpact LogImpact => LogImpact.High;
 
         public override void Effect(ReagentEffectArgs args)
         {
-            var floatIntensity = (float) args.Quantity;
+            var intensity = MathF.Min((float) args.Quantity * IntensityPerUnit, MaxTotalIntensity);
 
-            if (!args.EntityManager.HasComponent<SolutionContainerManagerComponent>(args.SolutionEntity))
-                return;
-
-            //Handle scaling
-            if (_scaled)
-            {
-                floatIntensity = MathF.Min(floatIntensity, _maxScale);
-            }
-            else
-            {
-                floatIntensity = 1;
-            }
-
-            //Calculate intensities
-            var finalDevastationRange = (int)MathF.Round(_devastationRange * floatIntensity);
-            var finalHeavyImpactRange = (int)MathF.Round(_heavyImpactRange * floatIntensity);
-            var finalLightImpactRange = (int)MathF.Round(_lightImpactRange * floatIntensity);
-            var finalFlashRange = (int)MathF.Round(_flashRange * floatIntensity);
-            EntitySystem.Get<ExplosionSystem>().SpawnExplosion(args.SolutionEntity, finalDevastationRange,
-                finalHeavyImpactRange, finalLightImpactRange, finalFlashRange);
+            EntitySystem.Get<ExplosionSystem>().QueueExplosion(
+                args.SolutionEntity,
+                ExplosionType,
+                intensity,
+                IntensitySlope,
+                MaxIntensity);
         }
     }
 }
-
-
diff --git a/Content.Server/Destructible/DestructibleSystem.cs b/Content.Server/Destructible/DestructibleSystem.cs
index ed4c91775f..868a5ac5f7 100644
--- a/Content.Server/Destructible/DestructibleSystem.cs
+++ b/Content.Server/Destructible/DestructibleSystem.cs
@@ -1,13 +1,17 @@
 using Content.Server.Construction;
 using Content.Server.Destructible.Thresholds;
+using Content.Server.Destructible.Thresholds.Behaviors;
+using Content.Server.Destructible.Thresholds.Triggers;
 using Content.Server.Explosion.EntitySystems;
 using Content.Server.Stack;
 using Content.Shared.Acts;
 using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
 using JetBrains.Annotations;
 using Robust.Server.GameObjects;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
+using System;
 
 namespace Content.Server.Destructible
 {
@@ -50,6 +54,40 @@ namespace Content.Server.Destructible
                     return;
             }
         }
+
+        // FFS this shouldn't be this hard. Maybe this should just be a field of the destructible component. Its not
+        // like there is currently any entity that is NOT just destroyed upon reaching a total-damage value.
+        /// <summary>
+        ///     Figure out how much damage an entity needs to have in order to be destroyed.
+        /// </summary>
+        /// <remarks>
+        ///     This assumes that this entity has some sort of destruction or breakage behavior triggered by a
+        ///     total-damage threshold.
+        /// </remarks>
+        public FixedPoint2 DestroyedAt(EntityUid uid, DestructibleComponent? destructible = null)
+        {
+            if (!Resolve(uid, ref destructible, logMissing: false))
+                return FixedPoint2.MaxValue;
+
+            // We have nested for loops here, but the vast majority of components only have one threshold with 1-3 behaviors.
+            // Really, this should probably just be a property of the damageable component.
+            var damageNeeded = FixedPoint2.MaxValue;
+            foreach (var threshold in destructible.Thresholds)
+            {
+                if (threshold.Trigger is not DamageTrigger trigger)
+                    continue;
+
+                foreach (var behavior in threshold.Behaviors)
+                {
+                    if (behavior is DoActsBehavior actBehavior &&
+                        actBehavior.HasAct(ThresholdActs.Destruction | ThresholdActs.Breakage))
+                    {
+                        damageNeeded = Math.Min(damageNeeded.Float(), trigger.Damage);
+                    }
+                }
+            }
+            return damageNeeded;
+        }
     }
 
     // Currently only used for destructible integration tests. Unless other uses are found for this, maybe this should just be removed and the tests redone.
diff --git a/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs b/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs
index c850aebc7b..02d817144e 100644
--- a/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs
+++ b/Content.Server/Destructible/Thresholds/Behaviors/ExplodeBehavior.cs
@@ -14,7 +14,7 @@ namespace Content.Server.Destructible.Thresholds.Behaviors
     {
         public void Execute(EntityUid owner, DestructibleSystem system)
         {
-            system.ExplosionSystem.SpawnExplosion(owner);
+            system.ExplosionSystem.TriggerExplosive(owner);
         }
     }
 }
diff --git a/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs b/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
index b760ce1341..e2e204131d 100644
--- a/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
+++ b/Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs
@@ -1,40 +1,8 @@
-using Content.Server.Throwing;
-using Content.Shared.Acts;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Maths;
 
-namespace Content.Server.Explosion.Components
+namespace Content.Server.Explosion.Components;
+
+// TODO EXPLOSION make this a tag? or just get rid of it and launch all unanchored physics entities?
+[RegisterComponent]
+public sealed class ExplosionLaunchedComponent : Component
 {
-    [RegisterComponent]
-    public sealed class ExplosionLaunchedComponent : Component, IExAct
-    {
-        [Dependency] private readonly IEntityManager _entMan = default!;
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            if (_entMan.Deleted(Owner))
-                return;
-
-            var sourceLocation = eventArgs.Source;
-            var targetLocation = _entMan.GetComponent<TransformComponent>(eventArgs.Target).Coordinates;
-
-            if (sourceLocation.Equals(targetLocation)) return;
-
-            var offset = (targetLocation.ToMapPos(_entMan) - sourceLocation.ToMapPos(_entMan));
-
-            //Don't throw if the direction is center (0,0)
-            if (offset == Vector2.Zero) return;
-
-            var direction = offset.Normalized;
-
-            var throwForce = eventArgs.Severity switch
-            {
-                ExplosionSeverity.Heavy => 30,
-                ExplosionSeverity.Light => 20,
-                _ => 0,
-            };
-
-            Owner.TryThrow(direction, throwForce);
-        }
-    }
 }
diff --git a/Content.Server/Explosion/Components/ExplosionResistanceComponent.cs b/Content.Server/Explosion/Components/ExplosionResistanceComponent.cs
new file mode 100644
index 0000000000..1a3f700eab
--- /dev/null
+++ b/Content.Server/Explosion/Components/ExplosionResistanceComponent.cs
@@ -0,0 +1,30 @@
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Explosion;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
+
+namespace Content.Server.Explosion.Components;
+
+/// <summary>
+///     Component that provides entities with explosion resistance.
+/// </summary>
+/// <remarks>
+///     This is desirable over just using damage modifier sets, given that equipment like bomb-suits need to
+///     significantly reduce the damage, but shouldn't be silly overpowered in regular combat.
+/// </remarks>
+[RegisterComponent]
+[Friend(typeof(ExplosionSystem))]
+public sealed class ExplosionResistanceComponent : Component
+{
+    /// <summary>
+    ///     The resistance values for this component, This fraction is added to the total resistance.
+    /// </summary>
+    [DataField("resistance")]
+    public float GlobalResistance = 0;
+
+    /// <summary>
+    ///     Like <see cref="GlobalResistance"/>, but specified specific to each explosion type for more customizability.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("resistances", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<float, ExplosionPrototype>))]
+    public Dictionary<string, float> Resistances = new();
+}
diff --git a/Content.Server/Explosion/Components/ExplosiveComponent.cs b/Content.Server/Explosion/Components/ExplosiveComponent.cs
index a8f98ff685..7ca715fb86 100644
--- a/Content.Server/Explosion/Components/ExplosiveComponent.cs
+++ b/Content.Server/Explosion/Components/ExplosiveComponent.cs
@@ -1,34 +1,59 @@
-using Content.Server.Chemistry.ReactionEffects;
-using Content.Server.Destructible.Thresholds.Behaviors;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization.Manager.Attributes;
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Explosion;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
-namespace Content.Server.Explosion.Components
+namespace Content.Server.Explosion.Components;
+
+/// <summary>
+///     Specifies an explosion that can be spawned by this entity. The explosion itself is spawned via <see
+///     cref="ExplosionSystem.TriggerExplosive"/>.
+/// </summary>
+/// <remarks>
+///      The total intensity may be overridden by whatever system actually calls TriggerExplosive(), but this
+///      component still determines the explosion type and other properties.
+/// </remarks>
+[RegisterComponent]
+public sealed class ExplosiveComponent : Component
 {
+    public override string Name => "Explosive";
+
     /// <summary>
-    ///     Specifies an explosion range should this entity be exploded.
+    ///     The explosion prototype. This determines the damage types, the tile-break chance, and some visual
+    ///     information (e.g., the light that the explosion gives off).
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
+    public string ExplosionType = default!;
+
+    /// <summary>
+    ///     The maximum intensity the explosion can have on a single time. This limits the maximum damage and tile
+    ///     break chance the explosion can achieve at any given location.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("maxIntensity")]
+    public float MaxIntensity = 4;
+
+    /// <summary>
+    ///     How quickly the intensity drops off as you move away from the epicenter.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("intensitySlope")]
+    public float IntensitySlope = 1;
+
+    /// <summary>
+    ///     The total intensity of this explosion. The radius of the explosion scales like the cube root of this
+    ///     number (see <see cref="ExplosionSystem.RadiusToIntensity"/>).
     /// </summary>
     /// <remarks>
-    ///     Explosions can be caused by:
-    ///     <list type="bullet">
-    ///         <item>Reaching a damage threshold that causes a <see cref="ExplodeBehavior"/></item>
-    ///         <item>Being triggered via the <see cref="ExplodeOnTriggerComponent"/></item>
-    ///         <item>Manually by some other system via functions in <see cref="ExplosionHelper"/> (for example, chemistry's
-    ///         <see cref="ExplosionReactionEffect"/>).</item>
-    ///     </list>
+    ///     This number can be overridden by passing optional argument to <see
+    ///     cref="ExplosionSystem.TriggerExplosive"/>.
     /// </remarks>
-    [RegisterComponent]
-    public sealed class ExplosiveComponent : Component
-    {
-        [DataField("devastationRange")]
-        public int DevastationRange;
-        [DataField("heavyImpactRange")]
-        public int HeavyImpactRange;
-        [DataField("lightImpactRange")]
-        public int LightImpactRange;
-        [DataField("flashRange")]
-        public int FlashRange;
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("totalIntensity")]
+    public float TotalIntensity = 10;
 
-        public bool Exploding { get; set; } = false;
-    }
+    /// <summary>
+    ///     Avoid somehow double-triggering this explosion (e.g. by damaging this entity from it's own explosion.
+    /// </summary>
+    public bool Exploded;
 }
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs
new file mode 100644
index 0000000000..0aae00a223
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Airtight.cs
@@ -0,0 +1,141 @@
+using Content.Server.Atmos.Components;
+using Content.Server.Destructible;
+using Content.Shared.Atmos;
+using Content.Shared.Damage;
+using Content.Shared.Explosion;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    [Dependency] private readonly DestructibleSystem _destructibleSystem = default!;
+
+    // The explosion intensity required to break an entity depends on the explosion type. So it is stored in a
+    // Dictionary<string, float>
+    //
+    // Hence, each tile has a tuple (Dictionary<string, float>, AtmosDirection). This specifies what directions are
+    // blocked, and how intense a given explosion type needs to be in order to destroy ALL airtight entities on that
+    // tile. This is the TileData struct.
+    //
+    // We then need this data for every tile on a grid. So this mess of a variable maps the Grid ID and Vector2i grid
+    // indices to this tile-data struct.
+    private Dictionary<GridId, Dictionary<Vector2i, TileData>> _airtightMap = new();
+
+    public void UpdateAirtightMap(GridId gridId, Vector2i tile)
+    {
+        if (_mapManager.TryGetGrid(gridId, out var grid))
+            UpdateAirtightMap(grid, tile);
+    }
+
+    /// <summary>
+    ///     Update the map of explosion blockers.
+    /// </summary>
+    /// <remarks>
+    ///     Gets a list of all airtight entities on a tile. Assembles a <see cref="AtmosDirection"/> that specifies
+    ///     what directions are blocked, along with the largest explosion tolerance. Note that as we only keep track
+    ///     of the largest tolerance, this means that the explosion map will actually be inaccurate if you have
+    ///     something like a normal and a reinforced windoor on the same tile. But given that this is a pretty rare
+    ///     occurrence, I am fine with this.
+    /// </remarks>
+    public void UpdateAirtightMap(IMapGrid grid, Vector2i tile)
+    {
+        Dictionary<string, float>  tolerance = new();
+        var blockedDirections = AtmosDirection.Invalid;
+
+        if (!_airtightMap.ContainsKey(grid.Index))
+            _airtightMap[grid.Index] = new();
+
+        foreach (var uid in grid.GetAnchoredEntities(tile))
+        {
+            if (!EntityManager.TryGetComponent(uid, out AirtightComponent? airtight) || !airtight.AirBlocked)
+                continue;
+
+            blockedDirections |= airtight.AirBlockedDirection;
+            foreach (var (type, value) in GetExplosionTolerance(uid))
+            {
+                if (!tolerance.TryAdd(type, value))
+                    tolerance[type] = Math.Max(tolerance[type], value);
+            }
+        }
+
+        if (blockedDirections != AtmosDirection.Invalid)
+            _airtightMap[grid.Index][tile] = new(tolerance, blockedDirections);
+        else
+            _airtightMap[grid.Index].Remove(tile);
+    }
+
+    /// <summary>
+    ///     On receiving damage, re-evaluate how much explosion damage is needed to destroy an airtight entity.
+    /// </summary>
+    private void OnAirtightDamaged(EntityUid uid, AirtightComponent airtight, DamageChangedEvent args)
+    {
+        // do we need to update our explosion blocking map?
+        if (!airtight.AirBlocked)
+            return;
+
+        if (!EntityManager.TryGetComponent(uid, out TransformComponent transform) || !transform.Anchored)
+            return;
+
+        if (!_mapManager.TryGetGrid(transform.GridID, out var grid))
+            return;
+
+        UpdateAirtightMap(grid, grid.CoordinatesToTile(transform.Coordinates));
+    }
+
+    /// <summary>
+    ///     Return a dictionary that specifies how intense a given explosion type needs to be in order to destroy an entity.
+    /// </summary>
+    public Dictionary<string, float> GetExplosionTolerance(EntityUid uid)
+    {
+        // How much total damage is needed to destroy this entity? This also includes "break" behaviors. This ASSUMES
+        // that this will result in a non-airtight entity.Entities that ONLY break via construction graph node changes
+        // are currently effectively "invincible" as far as this is concerned. This really should be done more rigorously.
+        var totalDamageTarget = _destructibleSystem.DestroyedAt(uid);
+
+        Dictionary<string, float> explosionTolerance = new();
+
+        if (totalDamageTarget == FixedPoint2.MaxValue || !TryComp(uid, out DamageableComponent? damageable))
+            return explosionTolerance;
+
+        // What multiple of each explosion type damage set will result in the damage exceeding the required amount? This
+        // does not support entities dynamically changing explosive resistances (e.g. via clothing). But these probably
+        // shouldn't be airtight structures anyways....
+
+        foreach (var explosionType in _prototypeManager.EnumeratePrototypes<ExplosionPrototype>())
+        {
+            // evaluate the damage that this damage type would do to this entity
+            var damagePerIntensity = FixedPoint2.Zero;
+            foreach (var (type, value) in explosionType.DamagePerIntensity.DamageDict)
+            {
+                if (!damageable.Damage.DamageDict.ContainsKey(type))
+                    continue;
+
+                var ev = new GetExplosionResistanceEvent(explosionType.ID);
+                RaiseLocalEvent(uid, ev, false);
+
+                damagePerIntensity += value * Math.Clamp(0, 1 - ev.Resistance, 1);
+            }
+
+            explosionTolerance[explosionType.ID] = (float) ((totalDamageTarget - damageable.TotalDamage) / damagePerIntensity);
+        }
+
+        return explosionTolerance;
+    }
+}
+
+/// <summary>
+///     Data struct that describes the explosion-blocking airtight entities on a tile.
+/// </summary>
+internal struct TileData
+{
+    public TileData(Dictionary<string, float> explosionTolerance, AtmosDirection blockedDirections)
+    {
+        ExplosionTolerance = explosionTolerance;
+        BlockedDirections = blockedDirections;
+    }
+
+    public Dictionary<string, float> ExplosionTolerance;
+    public AtmosDirection BlockedDirections = AtmosDirection.Invalid;
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
new file mode 100644
index 0000000000..83f5870e8f
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
@@ -0,0 +1,438 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+// This partial part of the explosion system has all of the functions used to facilitate explosions moving across grids.
+// A good portion of it is focused around keeping track of what tile-indices on a grid correspond to tiles that border
+// space. AFAIK no other system currently needs to track these "edge-tiles". If they do, this should probably be a
+// property of the grid itself?
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    /// <summary>
+    ///     Set of tiles of each grid that are directly adjacent to space, along with the directions that face space.
+    /// </summary>
+    private Dictionary<GridId, Dictionary<Vector2i, AtmosDirection>> _gridEdges = new();
+
+    /// <summary>
+    ///     Set of tiles of each grid that are diagonally adjacent to space
+    /// </summary>
+    private Dictionary<GridId, HashSet<Vector2i>> _diagGridEdges = new();
+
+    /// <summary>
+    ///     On grid startup, prepare a map of grid edges.
+    /// </summary>
+    private void OnGridStartup(GridStartupEvent ev)
+    {
+        if (!_mapManager.TryGetGrid(ev.GridId, out var grid))
+            return;
+
+        Dictionary<Vector2i, AtmosDirection> edges = new();
+        HashSet<Vector2i> diagEdges = new();
+        _gridEdges[ev.GridId] = edges;
+        _diagGridEdges[ev.GridId] = diagEdges;
+
+        foreach (var tileRef in grid.GetAllTiles())
+        {
+            if (tileRef.Tile.IsEmpty)
+                continue;
+
+            if (IsEdge(grid, tileRef.GridIndices, out var dir))
+                edges.Add(tileRef.GridIndices, dir);
+            else if (IsDiagonalEdge(grid, tileRef.GridIndices))
+                diagEdges.Add(tileRef.GridIndices);
+        }
+    }
+
+    private void OnGridRemoved(GridRemovalEvent ev)
+    {
+        _airtightMap.Remove(ev.GridId);
+        _gridEdges.Remove(ev.GridId);
+        _diagGridEdges.Remove(ev.GridId);
+    }
+
+    /// <summary>
+    ///     Take our map of grid edges, where each is defined in their own grid's reference frame, and map those
+    ///     edges all onto one grids reference frame.
+    /// </summary>
+    public (Dictionary<Vector2i, GridBlockData>, ushort) TransformGridEdges(MapId targetMap, GridId? referenceGrid, List<GridId> localGrids)
+    {
+        Dictionary<Vector2i, GridBlockData> transformedEdges = new();
+
+        var targetMatrix = Matrix3.Identity;
+        Angle targetAngle = new();
+        ushort tileSize = DefaultTileSize;
+
+        // if the explosion is centered on some grid (and not just space), get the transforms.
+        if (referenceGrid != null)
+        {
+            var targetGrid = _mapManager.GetGrid(referenceGrid.Value);
+            var xform = Transform(targetGrid.GridEntityId);
+            targetAngle = xform.WorldRotation;
+            targetMatrix = xform.InvWorldMatrix;
+            tileSize = targetGrid.TileSize;
+        }
+
+        var offsetMatrix = Matrix3.Identity;
+        offsetMatrix.R0C2 = tileSize / 2;
+        offsetMatrix.R1C2 = tileSize / 2;
+
+        // here we will get a triple nested for loop:
+        // foreach other grid
+        //   foreach edge tile in that grid
+        //     foreach tile in our grid that touches that tile (vast majority of the time: 1 tile, but could be up to 4)
+
+        HashSet<Vector2i> transformedTiles = new();
+        foreach (var gridToTransform in localGrids)
+        {
+            // we treat the target grid separately
+            if (gridToTransform == referenceGrid)
+                continue;
+
+            if (!_gridEdges.TryGetValue(gridToTransform, out var edges))
+                continue;
+
+            if (!_mapManager.TryGetGrid(gridToTransform, out var grid) ||
+                grid.ParentMapId != targetMap)
+                continue;
+
+            if (grid.TileSize != tileSize)
+            {
+                Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
+                continue;
+            }
+
+            var xform = EntityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            var matrix = offsetMatrix * xform.WorldMatrix * targetMatrix;
+            var angle = xform.WorldRotation - targetAngle;
+
+            var (x, y) = angle.RotateVec((tileSize / 4, tileSize / 4));
+
+            foreach (var (tile, dir) in edges)
+            {
+                var center = matrix.Transform(tile);
+
+                // this tile might touch several other tiles, or maybe just one tile. Here we use a Vector2i HashSet to
+                // remove duplicates.
+                transformedTiles.Clear();
+                transformedTiles.Add(new((int) MathF.Floor(center.X + x), (int) MathF.Floor(center.Y + y)));  // initial direction
+                transformedTiles.Add(new((int) MathF.Floor(center.X - y), (int) MathF.Floor(center.Y + x)));  // rotated 90 degrees
+                transformedTiles.Add(new((int) MathF.Floor(center.X - x), (int) MathF.Floor(center.Y - y)));  // rotated 180 degrees
+                transformedTiles.Add(new((int) MathF.Floor(center.X + y), (int) MathF.Floor(center.Y - x)));  // rotated 270 degrees
+
+                foreach (var newIndices in transformedTiles)
+                {
+                    if (!transformedEdges.TryGetValue(newIndices, out var data))
+                    {
+                        data = new();
+                        transformedEdges[newIndices] = data;
+                    }
+                    data.BlockingGridEdges.Add(new(tile, gridToTransform, center, angle, tileSize));
+                }
+            }
+        }
+
+        // Next we transform any diagonal edges.
+        Vector2i newIndex;
+        foreach (var gridToTransform in localGrids)
+        {
+            // we treat the target grid separately
+            if (gridToTransform == referenceGrid)
+                continue;
+
+            if (!_diagGridEdges.TryGetValue(gridToTransform, out var diagEdges))
+                continue;
+
+            if (!_mapManager.TryGetGrid(gridToTransform, out var grid) ||
+                grid.ParentMapId != targetMap)
+                continue;
+
+            if (grid.TileSize != tileSize)
+            {
+                Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
+                continue;
+            }
+
+            var xform = EntityManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            var matrix = offsetMatrix * xform.WorldMatrix * targetMatrix;
+            var angle = xform.WorldRotation - targetAngle;
+
+            foreach (var tile in diagEdges)
+            {
+                var center = matrix.Transform(tile);
+                newIndex = new((int) MathF.Floor(center.X), (int) MathF.Floor(center.Y));
+                if (!transformedEdges.TryGetValue(newIndex, out var data))
+                {
+                    data = new();
+                    transformedEdges[newIndex] = data;
+                }
+
+                // explosions are not allowed to propagate diagonally ONTO grids. so we just use defaults for some fields.
+                data.BlockingGridEdges.Add(new(default, null, center, angle, tileSize));
+            }
+        }
+
+        if (referenceGrid == null)
+            return (transformedEdges, tileSize);
+
+        // finally, we also include the blocking tiles from the reference grid.
+
+        if (_gridEdges.TryGetValue(referenceGrid.Value, out var localEdges))
+        {
+            foreach (var (tile, _) in localEdges)
+            {
+                // grids cannot overlap, so tile should NEVER be an existing entry.
+                var data = new GridBlockData();
+                transformedEdges[tile] = data;
+                
+                data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
+                data.BlockingGridEdges.Add(new(tile, referenceGrid.Value, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
+            }
+        }
+
+        if (_diagGridEdges.TryGetValue(referenceGrid.Value, out var localDiagEdges))
+        {
+            foreach (var tile in localDiagEdges)
+            {
+
+                // grids cannot overlap, so tile should NEVER be an existing entry.
+                var data = new GridBlockData();
+                transformedEdges[tile] = data;
+
+                data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
+                data.BlockingGridEdges.Add(new(default, null, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
+            }
+        }
+
+        return (transformedEdges, tileSize);
+    }
+
+    /// <summary>
+    ///     Given an grid-edge blocking map, check if the blockers are allowed to propagate to each other through gaps in grids.
+    /// </summary>
+    /// <remarks>
+    ///     After grid edges were transformed into the reference frame of some other grid, this function figures out
+    ///     which of those edges are actually blocking explosion propagation.
+    /// </remarks>
+    public void GetUnblockedDirections(Dictionary<Vector2i, GridBlockData> transformedEdges, ushort tileSize)
+    {
+        foreach (var (tile, data) in transformedEdges)
+        {
+            if (data.UnblockedDirections == AtmosDirection.Invalid)
+                continue; // already all blocked.
+
+            var tileCenter = ((Vector2) tile + 0.5f) * tileSize;
+            foreach (var edge in data.BlockingGridEdges)
+            {
+                // if a blocking edge contains the center of the tile, block all directions
+                if (edge.Box.Contains(tileCenter))
+                {
+                    data.UnblockedDirections = AtmosDirection.Invalid;
+                    break;
+                }
+
+                // check north
+                if (edge.Box.Contains(tileCenter + (0, tileSize / 2)))
+                    data.UnblockedDirections &= ~AtmosDirection.North;
+
+                // check south
+                if (edge.Box.Contains(tileCenter + (0, -tileSize / 2)))
+                    data.UnblockedDirections &= ~AtmosDirection.South;
+
+                // check east
+                if (edge.Box.Contains(tileCenter + (tileSize / 2, 0)))
+                    data.UnblockedDirections &= ~AtmosDirection.East;
+
+                // check west
+                if (edge.Box.Contains(tileCenter + (-tileSize / 2, 0)))
+                    data.UnblockedDirections &= ~AtmosDirection.West;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     When a tile is updated, we might need to update the grid edge maps.
+    /// </summary>
+    private void OnTileChanged(object? sender, TileChangedEventArgs e)
+    {
+        // only need to update the grid-edge map if the tile changed from space to not-space.
+        if (!e.NewTile.Tile.IsEmpty && !e.OldTile.IsEmpty)
+            return;
+
+        var tileRef = e.NewTile;
+
+        if (!_mapManager.TryGetGrid(tileRef.GridIndex, out var grid))
+            return;
+
+        if (!_gridEdges.TryGetValue(tileRef.GridIndex, out var edges))
+        {
+            edges = new();
+            _gridEdges[tileRef.GridIndex] = edges;
+        }
+
+        if (!_diagGridEdges.TryGetValue(tileRef.GridIndex, out var diagEdges))
+        {
+            diagEdges = new();
+            _diagGridEdges[tileRef.GridIndex] = diagEdges;
+        }
+
+        if (tileRef.Tile.IsEmpty)
+        {
+            // if the tile is empty, it cannot itself be an edge tile.
+            edges.Remove(tileRef.GridIndices);
+            diagEdges.Remove(tileRef.GridIndices);
+
+            // add any valid neighbours to the list of edge-tiles
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+
+                var neighbourIndex = tileRef.GridIndices.Offset(direction);
+
+                if (grid.TryGetTileRef(neighbourIndex, out var neighbourTile) && !neighbourTile.Tile.IsEmpty)
+                {
+                    edges[neighbourIndex] = edges.GetValueOrDefault(neighbourIndex) | direction.GetOpposite();
+                    diagEdges.Remove(neighbourIndex);
+                }
+            }
+
+            foreach (var diagNeighbourIndex in GetDiagonalNeighbors(tileRef.GridIndices))
+            {
+                if (edges.ContainsKey(diagNeighbourIndex))
+                    continue;
+
+                if (grid.TryGetTileRef(diagNeighbourIndex, out var neighbourIndex) && !neighbourIndex.Tile.IsEmpty)
+                    diagEdges.Add(diagNeighbourIndex);
+            }
+
+            return;
+        }
+
+        // the tile is not empty space, but was previously. So update directly adjacent neighbours, which may no longer
+        // be edge tiles.
+        AtmosDirection spaceDir;
+        for (var i = 0; i < Atmospherics.Directions; i++)
+        {
+            var direction = (AtmosDirection) (1 << i);
+            var neighbourIndex = tileRef.GridIndices.Offset(direction);
+
+            if (edges.TryGetValue(neighbourIndex, out spaceDir))
+            {
+                spaceDir = spaceDir & ~direction.GetOpposite();
+                if (spaceDir != AtmosDirection.Invalid)
+                    edges[neighbourIndex] = spaceDir;
+                else
+                {
+                    // no longer a direct edge ...
+                    edges.Remove(neighbourIndex);
+
+                    // ... but it could now be a diagonal edge
+                    if (IsDiagonalEdge(grid, neighbourIndex, tileRef.GridIndices))
+                        diagEdges.Add(neighbourIndex);
+                }
+            }
+        }
+
+        // and again for diagonal neighbours
+        foreach (var neighborIndex in GetDiagonalNeighbors(tileRef.GridIndices))
+        {
+            if (diagEdges.Contains(neighborIndex) && !IsDiagonalEdge(grid, neighborIndex, tileRef.GridIndices))
+                diagEdges.Remove(neighborIndex);
+        }
+
+        // finally check if the new tile is itself an edge tile
+        if (IsEdge(grid, tileRef.GridIndices, out spaceDir))
+            edges.Add(tileRef.GridIndices, spaceDir);
+        else if (IsDiagonalEdge(grid, tileRef.GridIndices))
+            diagEdges.Add(tileRef.GridIndices);
+    }
+
+    /// <summary>
+    ///     Check whether a tile is on the edge of a grid (i.e., whether it borders space).
+    /// </summary>
+    /// <remarks>
+    ///     Optionally ignore a specific Vector2i. Used by <see cref="OnTileChanged"/> when we already know that a
+    ///     given tile is not space. This avoids unnecessary TryGetTileRef calls.
+    /// </remarks>
+    private bool IsEdge(IMapGrid grid, Vector2i index, out AtmosDirection spaceDirections)
+    {
+        spaceDirections = AtmosDirection.Invalid;
+        for (var i = 0; i < Atmospherics.Directions; i++)
+        {
+            var direction = (AtmosDirection) (1 << i);
+
+            if (!grid.TryGetTileRef(index.Offset(direction), out var neighborTile) || neighborTile.Tile.IsEmpty)
+                spaceDirections |= direction;
+        }
+
+        return spaceDirections != AtmosDirection.Invalid;
+    }
+
+    private bool IsDiagonalEdge(IMapGrid grid, Vector2i index, Vector2i? ignore = null)
+    {
+        foreach (var neighbourIndex in GetDiagonalNeighbors(index))
+        {
+            if (neighbourIndex == ignore)
+                continue;
+
+            if (!grid.TryGetTileRef(neighbourIndex, out var neighborTile) || neighborTile.Tile.IsEmpty)
+                return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Enumerate over diagonally adjacent tiles.
+    /// </summary>
+    internal static IEnumerable<Vector2i> GetDiagonalNeighbors(Vector2i pos)
+    {
+        yield return pos + (1, 1);
+        yield return pos + (-1, -1);
+        yield return pos + (1, -1);
+        yield return pos + (-1, 1);
+    }
+}
+
+public struct GridEdgeData : IEquatable<GridEdgeData>
+{
+    public Vector2i Tile;
+    public GridId? Grid;
+    public Box2Rotated Box;
+
+    public GridEdgeData(Vector2i tile, GridId? grid, Vector2 center, Angle angle, float size)
+    {
+        Tile = tile;
+        Grid = grid;
+        Box = new(Box2.CenteredAround(center, (size, size)), angle, center);
+    }
+
+    /// <inheritdoc />
+    public bool Equals(GridEdgeData other)
+    {
+        return Tile.Equals(other.Tile) && Grid.Equals(other.Grid);
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        unchecked
+        {
+            return (Tile.GetHashCode() * 397) ^ Grid.GetHashCode();
+        }
+    }
+}
+
+public record GridBlockData
+{
+    /// <summary>
+    ///     What directions of this tile are not blocked by some other grid?
+    /// </summary>
+    public AtmosDirection UnblockedDirections = AtmosDirection.All;
+
+    /// <summary>
+    ///     Hashset contains information about the edge-tiles, which belong to some other grid(s), that are blocking
+    ///     this tile.
+    /// </summary>
+    public HashSet<GridEdgeData> BlockingGridEdges = new();
+}
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
new file mode 100644
index 0000000000..93e3af4b73
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.Processing.cs
@@ -0,0 +1,569 @@
+using System.Linq;
+using Content.Server.Explosion.Components;
+using Content.Server.Throwing;
+using Content.Shared.Damage;
+using Content.Shared.Explosion;
+using Content.Shared.Maps;
+using Content.Shared.Physics;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    /// <summary>
+    ///     Used to identify explosions when communicating with the client. Might be needed if more than one explosion is spawned in a single tick.
+    /// </summary>
+    /// <remarks>
+    ///     Overflowing back to 0 should cause no issue, as long as you don't have more than 256 explosions happening in a single tick.
+    /// </remarks>
+    private byte _explosionCounter = 0;
+    // maybe should just use a UID/explosion-entity and a state to convey information?
+    // but then need to ignore PVS? Eeehh this works well enough for now.
+
+    /// <summary>
+    ///     Arbitrary definition for when an explosion is large enough to require separating the area/tile-finding and
+    ///     the processing into separate ticks.
+    /// </summary>
+    /// <remarks>
+    ///     Only used when the explosion processing is not limited by time.
+    /// </remarks>
+    public const int NukeArea = 400;
+
+    /// <summary>
+    ///     Used to limit explosion processing time. See <see cref="MaxProcessingTime"/>.
+    /// </summary>
+    internal readonly Stopwatch Stopwatch = new();
+
+    /// <summary>
+    ///     How many tiles to explode before checking the stopwatch timer
+    /// </summary>
+    internal static int TileCheckIteration = 1;
+
+    /// <summary>
+    ///     Queue for delayed processing of explosions. If there is an explosion that covers more than <see
+    ///     cref="TilesPerTick"/> tiles, other explosions will actually be delayed slightly. Unless it's a station
+    ///     nuke, this delay should never really be noticeable.
+    /// </summary>
+    private Queue<Func<Explosion?>> _explosionQueue = new();
+
+    /// <summary>
+    ///     The explosion currently being processed.
+    /// </summary>
+    private Explosion? _activeExplosion;
+
+    /// <summary>
+    ///     While processing an explosion, the "progress" is sent to clients, so that the explosion fireball effect
+    ///     syncs up with the damage. When the tile iteration increments, an update needs to be sent to clients.
+    ///     This integer keeps track of the last value sent to clients.
+    /// </summary>
+    private int _previousTileIteration;
+
+    /// <summary>
+    ///     Process the explosion queue.
+    /// </summary>
+    public override void Update(float frameTime)
+    {
+        if (_activeExplosion == null && _explosionQueue.Count == 0)
+            // nothing to do
+            return;
+
+        Stopwatch.Restart();
+        var x = Stopwatch.Elapsed.TotalMilliseconds;
+
+        var availableTime = MaxProcessingTime;
+
+        var tilesRemaining = TilesPerTick;
+        while (tilesRemaining > 0 && MaxProcessingTime > Stopwatch.Elapsed.TotalMilliseconds)
+        {
+            // if there is no active explosion, get a new one to process
+            if (_activeExplosion == null)
+            {
+                // EXPLOSION TODO allow explosion spawning to be interrupted by time limit. In the meantime, ensure that
+                // there is at-least 1ms of time left before creating a new explosion
+                if (MathF.Max(MaxProcessingTime - 1, 0.1f)  < Stopwatch.Elapsed.TotalMilliseconds)
+                    break;
+
+                if (!_explosionQueue.TryDequeue(out var spawnNextExplosion))
+                    break;
+
+                _activeExplosion = spawnNextExplosion();
+
+                // explosion spawning can be null if something somewhere went wrong. (e.g., negative explosion
+                // intensity).
+                if (_activeExplosion == null)
+                    continue;
+
+                _explosionCounter++;
+                _previousTileIteration = 0;
+
+                // just a lil nap
+                if (SleepNodeSys)
+                {
+                    _nodeGroupSystem.Snoozing = true;
+                    // snooze grid-chunk regeneration?
+                    // snooze power network (recipients look for new suppliers as wires get destroyed).
+                }
+
+                // if this is a single-tick explosion (i.e., not severely limited by number of tiles per tick or
+                // processing time, we want to process large explosion on a tick separate from the one they were
+                // generated on.
+                if (_activeExplosion.Area > NukeArea
+                    && MaxProcessingTime >= _gameTiming.TickPeriod.TotalMilliseconds)
+                {
+                    // start processing next turn.
+                    break;
+                }
+            }
+
+            var processed = _activeExplosion.Proccess(tilesRemaining);
+            tilesRemaining -= processed;
+
+            // has the explosion finished processing?
+            if (_activeExplosion.FinishedProcessing)
+                _activeExplosion = null;
+        }
+
+        Logger.InfoS("Explosion", $"Processed {TilesPerTick - tilesRemaining} tiles in {Stopwatch.Elapsed.TotalMilliseconds}ms");
+
+        // we have finished processing our tiles. Is there still an ongoing explosion?
+        if (_activeExplosion != null)
+        {
+            // update the client explosion overlays. This ensures that the fire-effects sync up with the entities currently being damaged.
+            if (_previousTileIteration == _activeExplosion.CurrentIteration)
+                return;
+
+            _previousTileIteration = _activeExplosion.CurrentIteration;
+            RaiseNetworkEvent(new ExplosionOverlayUpdateEvent(_explosionCounter, _previousTileIteration + 1));
+            return;
+        }
+
+        if (_explosionQueue.Count > 0)
+            return;
+
+        // We have finished processing all explosions. Clear client explosion overlays
+        RaiseNetworkEvent(new ExplosionOverlayUpdateEvent(_explosionCounter, int.MaxValue));
+
+        //wakey wakey
+        _nodeGroupSystem.Snoozing = false;
+    }
+
+    /// <summary>
+    ///     Determines whether an entity is blocking a tile or not. (whether it can prevent the tile from being uprooted
+    ///     by an explosion).
+    /// </summary>
+    /// <remarks>
+    ///     Used for a variation of <see cref="TurfHelpers.IsBlockedTurf()"/> that makes use of the fact that we have
+    ///     already done an entity lookup on a tile, and don't need to do so again.
+    /// </remarks>
+    public bool IsBlockingTurf(EntityUid uid)
+    {
+        if (EntityManager.IsQueuedForDeletion(uid))
+            return false;
+
+        if (!TryComp(uid, out IPhysBody? body))
+            return false;
+
+        return body.CanCollide && body.Hard && (body.CollisionLayer & (int) CollisionGroup.Impassable) != 0;
+    }
+
+    /// <summary>
+    ///     Find entities on a grid tile using the EntityLookupComponent and apply explosion effects. 
+    /// </summary>
+    /// <returns>True if the underlying tile can be uprooted, false if the tile is blocked by a dense entity</returns>
+    internal bool ExplodeTile(EntityLookupComponent lookup,
+        IMapGrid grid,
+        Vector2i tile,
+        float intensity,
+        float throwForce,
+        DamageSpecifier damage,
+        MapCoordinates epicenter,
+        HashSet<EntityUid> processed,
+        string id)
+    {
+        var gridBox = new Box2(tile * grid.TileSize, (tile + 1) * grid.TileSize);
+
+        // get the entities on a tile. Note that we cannot process them directly, or we get
+        // enumerator-changed-while-enumerating errors.
+        List<EntityUid> list = new();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref gridBox, entity => list.Add(entity));
+
+        // process those entities
+        foreach (var entity in list)
+        {
+            ProcessEntity(entity, epicenter, processed, damage, throwForce, id, false);
+        }
+
+        // process anchored entities
+        var tileBlocked = false;
+        foreach (var entity in grid.GetAnchoredEntities(tile).ToList())
+        {
+            ProcessEntity(entity, epicenter, processed, damage, throwForce, id, true);
+            tileBlocked |= IsBlockingTurf(entity);
+        }
+
+        // Next, we get the intersecting entities AGAIN, but purely for throwing. This way, glass shards spawned from
+        // windows will be flung outwards, and not stay where they spawned. This is however somewhat unnecessary, and a
+        // prime candidate for computational cost-cutting. Alternatively, it would be nice if there was just some sort
+        // of spawned-on-destruction event that could be used to automatically assemble a list of new entities that need
+        // to be thrown.
+        //
+        // All things considered, until entity spawning & destruction is sped up, this isn't all that time consuming.
+        // (unless its a REALLY big explosion)
+        if (throwForce <= 0)
+            return !tileBlocked;
+
+        list.Clear();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref gridBox, entity => list.Add(entity));
+
+        foreach (var e in list)
+        {
+            // Here we only throw, no dealing damage. Containers n such might drop their entities after being destroyed, but
+            // they handle their own damage pass-through.
+            ProcessEntity(e, epicenter, processed, null, throwForce, id, false);
+        }
+
+        return !tileBlocked;
+    }
+
+    /// <summary>
+    ///     Same as <see cref="ExplodeTile"/>, but for SPAAAAAAACE.
+    /// </summary>
+    internal void ExplodeSpace(EntityLookupComponent lookup,
+        Matrix3 spaceMatrix,
+        Matrix3 invSpaceMatrix,
+        Vector2i tile,
+        float intensity,
+        float throwForce,
+        DamageSpecifier damage,
+        MapCoordinates epicenter,
+        HashSet<EntityUid> processed,
+        string id)
+    {
+        var gridBox = new Box2(tile * DefaultTileSize, (DefaultTileSize, DefaultTileSize));
+        var worldBox = spaceMatrix.TransformBox(gridBox);
+        List<EntityUid> list = new();
+
+        EntityUidQueryCallback callback = uid =>
+        {
+            if (gridBox.Contains(invSpaceMatrix.Transform(Transform(uid).WorldPosition)))
+                list.Add(uid);
+        };
+
+        _entityLookup.FastEntitiesIntersecting(lookup, ref worldBox, callback);
+
+        foreach (var entity in list)
+        {
+            ProcessEntity(entity, epicenter, processed, damage, throwForce, id, false);
+        }
+
+        if (throwForce <= 0)
+            return;
+
+        list.Clear();
+        _entityLookup.FastEntitiesIntersecting(lookup, ref worldBox, callback);
+        foreach (var entity in list)
+        {
+            ProcessEntity(entity, epicenter, processed, null, throwForce, id, false);
+        }
+    }
+
+    /// <summary>
+    ///     This function actually applies the explosion affects to an entity.
+    /// </summary>
+    private void ProcessEntity(EntityUid uid, MapCoordinates epicenter, HashSet<EntityUid> processed, DamageSpecifier? damage, float throwForce, string id, bool anchored)
+    {
+        // check whether this is a valid target, and whether we have already damaged this entity (can happen with
+        // explosion-throwing).
+        if (!anchored && _containerSystem.IsEntityInContainer(uid) || !processed.Add(uid))
+            return;
+
+        // damage
+        if (damage != null)
+        {
+            var ev = new GetExplosionResistanceEvent(id);
+            RaiseLocalEvent(uid, ev, false);
+            var coeff = Math.Clamp(0, 1 - ev.Resistance, 1);
+
+            if (!MathHelper.CloseTo(0, coeff))
+                _damageableSystem.TryChangeDamage(uid, damage * coeff, ignoreResistances: true);
+        }
+
+        // throw
+        if (!anchored
+            && throwForce > 0
+            && !EntityManager.IsQueuedForDeletion(uid)
+            && HasComp<ExplosionLaunchedComponent>(uid)
+            && TryComp(uid, out TransformComponent? transform))
+        {
+            uid.TryThrow(transform.WorldPosition - epicenter.Position, throwForce);
+        }
+
+        // TODO EXPLOSION puddle / flammable ignite?
+
+        // TODO EXPLOSION deaf/ear damage? other explosion effects?
+    }
+
+    /// <summary>
+    ///     Tries to damage floor tiles. Not to be confused with the function that damages entities intersecting the
+    ///     grid tile.
+    /// </summary>
+    public void DamageFloorTile(TileRef tileRef,
+        float intensity,
+        List<(Vector2i GridIndices, Tile Tile)> damagedTiles,
+        ExplosionPrototype type)
+    {
+        var tileDef = _tileDefinitionManager[tileRef.Tile.TypeId];
+
+        while (_robustRandom.Prob(type.TileBreakChance(intensity)))
+        {
+            intensity -= type.TileBreakRerollReduction;
+
+            if (tileDef is not ContentTileDefinition contentTileDef)
+                break;
+
+            // does this have a base-turf that we can break it down to?
+            if (contentTileDef.BaseTurfs.Count == 0)
+                break;
+
+            tileDef = _tileDefinitionManager[contentTileDef.BaseTurfs[^1]];
+        }
+
+        if (tileDef.TileId == tileRef.Tile.TypeId)
+            return;
+
+        damagedTiles.Add((tileRef.GridIndices, new Tile(tileDef.TileId)));
+    }
+}
+
+/// <summary>
+///     This is a data class that stores information about the area affected by an explosion, for processing by <see
+///     cref="ExplosionSystem"/>.
+/// </summary>
+/// <remarks>
+///     This is basically the output of <see cref="ExplosionSystem.GetExplosionTiles()"/>, but wrapped in an enumerator
+///     to iterate over the tiles, along with the ability to keep track of what entities have already been damaged by
+///     this explosion.
+/// </remarks>
+sealed class Explosion
+{
+    struct ExplosionData
+    {
+        public EntityLookupComponent Lookup;
+        public Dictionary<int, List<Vector2i>> TileLists;
+        public IMapGrid? MapGrid;
+    }
+
+    /// <summary>
+    ///     Used to avoid applying explosion effects repeatedly to the same entity. Particularly important if the
+    ///     explosion throws this entity, as then it will be moving while the explosion is happening.
+    /// </summary>
+    public readonly HashSet<EntityUid> ProcessedEntities = new();
+
+    /// <summary>
+    ///     This integer tracks how much of this explosion has been processed.
+    /// </summary>
+    public int CurrentIteration { get; private set; } = 0;
+
+    public readonly ExplosionPrototype ExplosionType;
+    public readonly MapCoordinates Epicenter;
+    private readonly Matrix3 _spaceMatrix;
+    private readonly Matrix3 _invSpaceMatrix;
+
+    private readonly List<ExplosionData> _explosionData = new();
+    private readonly List<float> _tileSetIntensity;
+
+    public bool FinishedProcessing;
+
+    // shitty enumerator implementation
+    private DamageSpecifier _currentDamage = default!;
+    private EntityLookupComponent _currentLookup = default!;
+    private IMapGrid? _currentGrid;
+    private float _currentIntensity;
+    private float _currentThrowForce;
+    private List<Vector2i>.Enumerator _currentEnumerator;
+    private int _currentDataIndex;
+    private Dictionary<IMapGrid, List<(Vector2i, Tile)>> _tileUpdateDict = new();
+
+    public int Area;
+
+    private readonly ExplosionSystem _system;
+
+    public Explosion(ExplosionSystem system,
+        ExplosionPrototype explosionType,
+        SpaceExplosion? spaceData,
+        List<GridExplosion> gridData,
+        List<float> tileSetIntensity,
+        MapCoordinates epicenter,
+        Matrix3 spaceMatrix,
+        int area)
+    {
+        _system = system;
+        ExplosionType = explosionType;
+        _tileSetIntensity = tileSetIntensity;
+        Epicenter = epicenter;
+        Area = area;
+
+        var entityMan = IoCManager.Resolve<IEntityManager>();
+        var mapMan = IoCManager.Resolve<IMapManager>();
+
+        if (spaceData != null)
+        {
+            var mapUid = mapMan.GetMapEntityId(epicenter.MapId);
+
+            _explosionData.Add(new()
+            {
+                TileLists = spaceData.TileLists,
+                Lookup = entityMan.GetComponent<EntityLookupComponent>(mapUid),
+                MapGrid = null
+            });
+
+            _spaceMatrix = spaceMatrix;
+            _invSpaceMatrix = Matrix3.Invert(spaceMatrix);
+        }
+
+        foreach (var grid in gridData)
+        {
+            _explosionData.Add(new()
+            {
+                TileLists = grid.TileLists,
+                Lookup = entityMan.GetComponent<EntityLookupComponent>(grid.Grid.GridEntityId),
+                MapGrid = grid.Grid
+            });
+        }
+
+        TryGetNextTileEnumerator();
+    }
+
+    private bool TryGetNextTileEnumerator()
+    {
+        while (CurrentIteration < _tileSetIntensity.Count)
+        {
+            _currentIntensity = _tileSetIntensity[CurrentIteration];
+            _currentDamage = ExplosionType.DamagePerIntensity * _currentIntensity;
+            _currentThrowForce = Area > _system.ThrowLimit ? 0 : 10 * MathF.Sqrt(_currentIntensity);
+
+            // for each grid/space tile set
+            while (_currentDataIndex < _explosionData.Count)
+            {
+                // try get any tile hash-set corresponding to this intensity
+                var tileSets = _explosionData[_currentDataIndex].TileLists;
+                if (!tileSets.TryGetValue(CurrentIteration, out var tileList))
+                {
+                    _currentDataIndex++;
+                    continue;
+                }
+
+                _currentEnumerator = tileList.GetEnumerator();
+                _currentLookup = _explosionData[_currentDataIndex].Lookup;
+                _currentGrid = _explosionData[_currentDataIndex].MapGrid;
+
+                _currentDataIndex++;
+                return true;
+            }
+
+            // this explosion intensity has been fully processed, move to the next one
+            CurrentIteration++;
+            _currentDataIndex = 0;
+        }
+
+        // no more explosion data to process
+        FinishedProcessing = true;
+        return false;
+    }
+
+    private bool MoveNext()
+    {
+        if (FinishedProcessing)
+            return false;
+
+        while (!FinishedProcessing)
+        {
+            if (_currentEnumerator.MoveNext())
+                return true;
+            else
+                TryGetNextTileEnumerator();
+        }
+
+        return false;
+    }
+
+    public int Proccess(int processingTarget)
+    {
+        // In case the explosion terminated early last tick due to exceeding the allocated processing time, use this
+        // time to update the tiles.
+        SetTiles();
+
+        int processed;
+        for (processed = 0; processed < processingTarget; processed++)
+        {
+            if (processed % ExplosionSystem.TileCheckIteration == 0 &&
+                _system.Stopwatch.Elapsed.TotalMilliseconds > _system.MaxProcessingTime)
+            {
+                break;
+            }
+
+            if (_currentGrid != null &&
+                _currentGrid.TryGetTileRef(_currentEnumerator.Current, out var tileRef) &&
+                !tileRef.Tile.IsEmpty)
+            {
+                if (!_tileUpdateDict.TryGetValue(_currentGrid, out var tileUpdateList))
+                {
+                    tileUpdateList = new();
+                    _tileUpdateDict[_currentGrid] = tileUpdateList;
+                }
+
+                var canDamageFloor = _system.ExplodeTile(_currentLookup,
+                    _currentGrid,
+                    _currentEnumerator.Current,
+                    _currentIntensity,
+                    _currentThrowForce,
+                    _currentDamage,
+                    Epicenter,
+                    ProcessedEntities,
+                    ExplosionType.ID);
+
+                if (canDamageFloor)
+                    _system.DamageFloorTile(tileRef, _currentIntensity, tileUpdateList, ExplosionType);
+            }
+            else
+            {
+                _system.ExplodeSpace(_currentLookup,
+                    _spaceMatrix,
+                    _invSpaceMatrix,
+                    _currentEnumerator.Current,
+                    _currentIntensity,
+                    _currentThrowForce,
+                    _currentDamage,
+                    Epicenter,
+                    ProcessedEntities,
+                    ExplosionType.ID);
+            }
+
+            if (!MoveNext())
+                break;
+        }
+
+        SetTiles();
+        return processed;
+    }
+
+    private void SetTiles()
+    {
+        if (!_system.IncrementalTileBreaking && !FinishedProcessing)
+            return;
+
+        foreach (var (grid, list) in _tileUpdateDict)
+        {
+            if (list.Count > 0)
+            {
+                grid.SetTiles(list);
+            }
+        }
+        _tileUpdateDict.Clear();
+    }
+}
+
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs
new file mode 100644
index 0000000000..759e63f43f
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.TileFill.cs
@@ -0,0 +1,334 @@
+using System.Linq;
+using Content.Shared.Administration;
+using Content.Shared.Explosion;
+using Robust.Shared.Map;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+// This partial part of the explosion system has all of the functions used to create the actual explosion map.
+// I.e, to get the sets of tiles & intensity values that describe an explosion.
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    /// <summary>
+    ///     This is the main explosion generating function. 
+    /// </summary>
+    /// <param name="epicenter">The center of the explosion</param>
+    /// <param name="typeID">The explosion type. this determines the explosion damage</param>
+    /// <param name="totalIntensity">The final sum of the tile intensities. This governs the overall size of the
+    /// explosion</param>
+    /// <param name="slope">How quickly does the intensity decrease when moving away from the epicenter.</param>
+    /// <param name="maxIntensity">The maximum intensity that the explosion can have at any given tile. This
+    /// effectively caps the damage that this explosion can do.</param>
+    /// <returns>A list of tile-sets and a list of intensity values which describe the explosion.</returns>
+    private (int, List<float>, SpaceExplosion?, Dictionary<GridId, GridExplosion>, Matrix3)? GetExplosionTiles(
+        MapCoordinates epicenter,
+        string typeID,
+        float totalIntensity,
+        float slope,
+        float maxIntensity)
+    {
+        if (totalIntensity <= 0 || slope <= 0)
+            return null;
+
+        Vector2i initialTile;
+        GridId? epicentreGrid = null;
+        var (localGrids, referenceGrid) = GetLocalGrids(epicenter, totalIntensity, slope, maxIntensity);
+
+        // get the epicenter tile indices
+        if (_mapManager.TryFindGridAt(epicenter, out var candidateGrid) &&
+            candidateGrid.TryGetTileRef(candidateGrid.WorldToTile(epicenter.Position), out var tileRef) &&
+            !tileRef.Tile.IsEmpty)
+        {
+            epicentreGrid = candidateGrid.Index;
+            initialTile = tileRef.GridIndices;
+        }
+        else if (referenceGrid != null)
+        {
+            // reference grid defines coordinate system that the explosion in space will use
+            initialTile = _mapManager.GetGrid(referenceGrid.Value).WorldToTile(epicenter.Position);
+        }
+        else
+        {
+            // this is a space-based explosion that (should) not touch any grids.
+            initialTile = new Vector2i(
+                    (int) Math.Floor(epicenter.Position.X / DefaultTileSize),
+                    (int) Math.Floor(epicenter.Position.Y / DefaultTileSize));
+        }
+
+        // Main data for the exploding tiles in space and on various grids
+        Dictionary<GridId, GridExplosion> gridData = new();
+        SpaceExplosion? spaceData = null;
+
+        // The intensity slope is how much the intensity drop over a one-tile distance. The actual algorithm step-size is half of thhat.
+        var stepSize = slope / 2;
+
+        // Hashsets used for when grid-based explosion propagate into space. Basically: used to move data between
+        // `gridData` and `spaceData` in-between neighbor finding iterations.
+        HashSet<Vector2i> spaceJump = new();
+        HashSet<Vector2i> previousSpaceJump;
+
+        // As above, but for space-based explosion propagating from space onto grids.
+        HashSet<GridId> encounteredGrids = new();
+        Dictionary<GridId, HashSet<Vector2i>>? previousGridJump;
+
+        // variables for transforming between grid and space-coordiantes
+        var spaceMatrix = Matrix3.Identity;
+        var spaceAngle = Angle.Zero;
+        if (referenceGrid != null)
+        {
+            var xform = Transform(_mapManager.GetGrid(referenceGrid.Value).GridEntityId);
+            spaceMatrix = xform.WorldMatrix;
+            spaceAngle = xform.WorldRotation;
+        }
+
+        // is the explosion starting on a grid?
+        if (epicentreGrid != null)
+        {
+            // set up the initial `gridData` instance
+            encounteredGrids.Add(epicentreGrid.Value);
+
+            if (!_airtightMap.TryGetValue(epicentreGrid.Value, out var airtightMap))
+                airtightMap = new();
+
+            var initialGridData = new GridExplosion(
+                _mapManager.GetGrid(epicentreGrid.Value),
+                airtightMap,
+                maxIntensity,
+                stepSize,
+                typeID,
+                _gridEdges[epicentreGrid.Value],
+                referenceGrid,
+                spaceMatrix,
+                spaceAngle);
+
+            gridData[epicentreGrid.Value] = initialGridData;
+
+            initialGridData.InitTile(initialTile);
+        }
+        else
+        {
+            // set up the space explosion data
+            spaceData = new SpaceExplosion(this, epicenter.MapId, referenceGrid, localGrids);
+            spaceData.InitTile(initialTile);
+        }
+
+        // Is this even a multi-tile explosion?
+        if (totalIntensity < stepSize)
+            // Bit anticlimactic. All that set up for nothing....
+            return (1, new List<float> { totalIntensity }, spaceData, gridData, spaceMatrix);
+        
+        // These variables keep track of the total intensity we have distributed
+        List<int> tilesInIteration = new() { 1 };
+        List<float> iterationIntensity = new() {stepSize};
+        var totalTiles = 0;
+        var remainingIntensity = totalIntensity - stepSize;
+
+        var iteration = 1;
+        var maxIntensityIndex = 0;
+
+        // If an explosion is trapped in an indestructible room, we can end the neighbor finding steps early.
+        // These variables are used to check if we can abort early.
+        float previousIntensity;
+        var intensityUnchangedLastLoop = false;
+
+        // Main flood-fill / neighbor-finding loop
+        while (remainingIntensity > 0 && iteration <= MaxIterations && totalTiles < MaxArea)
+        {
+            previousIntensity = remainingIntensity;
+
+            // First, we increase the intensity of the tiles that were already discovered in previous iterations.
+            for (var i = maxIntensityIndex; i < iteration; i++)
+            {
+                var intensityIncrease = MathF.Min(stepSize, maxIntensity - iterationIntensity[i]);
+
+                if (tilesInIteration[i] * intensityIncrease >= remainingIntensity)
+                {
+                    // there is not enough intensity left to distribute. add a fractional amount and break.
+                    iterationIntensity[i] += (float) remainingIntensity / tilesInIteration[i];
+                    remainingIntensity = 0;
+                    break;
+                }
+
+                iterationIntensity[i] += intensityIncrease;
+                remainingIntensity -= tilesInIteration[i] * intensityIncrease;
+
+                // Has this tile-set has reached max intensity? If so, stop iterating over it in  future
+                if (intensityIncrease < stepSize)
+                    maxIntensityIndex++;
+            }
+
+            if (remainingIntensity <= 0) break;
+
+            // Next, we will add a new iteration of tiles
+
+            // In order to treat "cost" of moving off a grid on the same level as moving onto a grid, both space -> grid and grid -> space have to be delayed by one iteration.
+            previousSpaceJump = spaceJump;
+            previousGridJump = spaceData?.GridJump;
+            spaceJump = new();
+
+            var newTileCount = 0;
+
+            if (previousGridJump != null)
+                encounteredGrids.UnionWith(previousGridJump.Keys);
+
+            foreach (var grid in encounteredGrids)
+            {
+                // is this a new grid, for which we must create a new explosion data set
+                if (!gridData.TryGetValue(grid, out var data))
+                {
+                    if (!_airtightMap.TryGetValue(grid, out var airtightMap))
+                        airtightMap = new();
+
+                    data = new GridExplosion(
+                        _mapManager.GetGrid(grid),
+                        airtightMap,
+                        maxIntensity,
+                        stepSize,
+                        typeID,
+                        _gridEdges[grid],
+                        referenceGrid,
+                        spaceMatrix,
+                        spaceAngle);
+
+                    gridData[grid] = data;
+                }
+
+                // get the new neighbours, and populate gridToSpaceTiles in the process.
+                newTileCount += data.AddNewTiles(iteration, previousGridJump?.GetValueOrDefault(grid));
+                spaceJump.UnionWith(data.SpaceJump);
+            }
+
+            // if space-data is null, but some grid-based explosion reached space, we need to initialize it.
+            if (spaceData == null && previousSpaceJump.Count != 0)
+                spaceData = new SpaceExplosion(this, epicenter.MapId, referenceGrid, localGrids);
+
+            // If the explosion has reached space, do that neighbors finding step as well.
+            if (spaceData != null)
+                newTileCount += spaceData.AddNewTiles(iteration, previousSpaceJump);
+
+            // Does adding these tiles bring us above the total target intensity?
+            tilesInIteration.Add(newTileCount);
+            if (newTileCount * stepSize >= remainingIntensity)
+            {
+                iterationIntensity.Add((float) remainingIntensity / newTileCount);
+                break;
+            }
+
+            // add the new tiles and decrement available intensity
+            remainingIntensity -= newTileCount * stepSize;
+            iterationIntensity.Add(stepSize);
+            totalTiles += newTileCount;
+
+            // It is possible that the explosion has some max intensity and is stuck in a container whose walls it
+            // cannot break. if the remaining intensity remains unchanged TWO loops in a row, we know that this is the
+            // case.
+            if (intensityUnchangedLastLoop && remainingIntensity == previousIntensity)
+                break;
+
+            intensityUnchangedLastLoop = remainingIntensity == previousIntensity;
+            iteration += 1;
+        }
+
+        if (totalTiles >= MaxArea) 
+            Logger.Info("Whooooo! MAXCAP!");
+
+        // Neighbor finding is done. Perform final clean up and return.
+        foreach (var grid in gridData.Values)
+        {
+            grid.CleanUp();
+        }
+        spaceData?.CleanUp();
+
+        return (totalTiles, iterationIntensity, spaceData, gridData, spaceMatrix);
+    }
+
+    /// <summary>
+    ///     Look for grids in an area and returns them. Also selects a special grid that will be used to determine the
+    ///     orientation of an explosion in space.
+    /// </summary>
+    /// <remarks>
+    ///     Note that even though an explosion may start ON a grid, the explosion in space may still be orientated to
+    ///     match a separate grid. This is done so that if you have something like a tiny suicide-bomb shuttle exploding
+    ///     near a large station, the explosion will still orient to match the station, not the tiny shuttle.
+    /// </remarks>
+    public (List<GridId>, GridId?) GetLocalGrids(MapCoordinates epicenter, float totalIntensity, float slope, float maxIntensity)
+    {
+        // Get the explosion radius (approx radius if it were in open-space). Note that if the explosion is confined in
+        // some directions but not in others, the actual explosion may reach further than this distance from the
+        // epicenter. Conversely, it might go nowhere near as far.
+        var radius = 0.5f + IntensityToRadius(totalIntensity, slope, maxIntensity);
+
+        // to avoid a silly lookup for silly input numbers, cap the radius to half of the theoretical maximum (lookup area gets doubled later on).
+        radius = Math.Min(radius, MaxIterations / 4);
+
+        GridId? referenceGrid = null;
+        float mass = 0;
+
+        // First attempt to find a grid that is relatively close to the explosion's center. Instead of looking in a
+        // diameter x diameter sized box, use a smaller box with radius sized sides:
+        var box = Box2.CenteredAround(epicenter.Position, (radius, radius));
+
+        foreach (var grid in _mapManager.FindGridsIntersecting(epicenter.MapId, box))
+        {
+            if (TryComp(grid.GridEntityId, out PhysicsComponent? physics) && physics.Mass > mass)
+            {
+                mass = physics.Mass;
+                referenceGrid = grid.Index;
+            }
+        }
+
+        // Next, we use a much larger lookup to determine all grids relevant to the explosion. This is used to determine
+        // what grids should be includes during the grid-edge transformation steps. This means that if a grid is not in
+        // this set, the explosion can never propagate from space onto this grid.
+
+        // As mentioned before, the `diameter` is only indicative, as an explosion that is obstructed (e.g., in a
+        // tunnel) may travel further away from the epicenter. But this should be very rare for space-traversing
+        // explosions. So instead of using the largest possible distance that an explosion could theoretically travel
+        // and using that for the grid look-up, we will just arbitrarily fudge the lookup size to be twice the diameter.
+
+        box = box.Scale(4); // box with width and height of 4*radius.
+        var mapGrids = _mapManager.FindGridsIntersecting(epicenter.MapId, box).ToList();
+        var grids = mapGrids.Select(x => x.Index).ToList();
+
+        if (referenceGrid != null)
+            return (grids, referenceGrid);
+
+        // We still don't have are reference grid. So lets also look in the enlarged region
+        foreach (var grid in mapGrids)
+        {
+            if (TryComp(grid.GridEntityId, out PhysicsComponent? physics) && physics.Mass > mass)
+            {
+                mass = physics.Mass;
+                referenceGrid = grid.Index;
+            }
+        }
+
+        return (grids, referenceGrid);
+    }
+
+    public ExplosionEvent? GenerateExplosionPreview(SpawnExplosionEuiMsg.PreviewRequest request)
+    {
+        var stopwatch = new Stopwatch();
+        stopwatch.Start();
+
+        var results = GetExplosionTiles(
+            request.Epicenter,
+            request.TypeId,
+            request.TotalIntensity,
+            request.IntensitySlope,
+            request.MaxIntensity);
+
+        if (results == null)
+            return null;
+
+        var (area, iterationIntensity, spaceData, gridData, spaceMatrix) = results.Value;
+
+        Logger.Info($"Generated explosion preview with {area} tiles in {stopwatch.Elapsed.TotalMilliseconds}ms");
+
+        // the explosion event that **would** be sent to all clients, if it were a real explosion.
+        return GetExplosionEvent(request.Epicenter, request.TypeId, spaceMatrix, spaceData, gridData.Values, iterationIntensity);
+    }
+}
+
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
index c1b14d15eb..81e99ea2a4 100644
--- a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cs
@@ -1,392 +1,274 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using Content.Server.Administration.Logs;
+using Content.Server.Atmos.Components;
 using Content.Server.Explosion.Components;
-using Content.Shared.Acts;
+using Content.Server.NodeContainer.EntitySystems;
 using Content.Shared.Camera;
-using Content.Shared.Database;
-using Content.Shared.Interaction;
-using Content.Shared.Interaction.Helpers;
-using Content.Shared.Maps;
-using Content.Shared.Physics;
-using Content.Shared.Sound;
-using Content.Shared.Tag;
-using Robust.Server.GameObjects;
+using Content.Shared.Damage;
+using Content.Shared.Explosion;
+using Robust.Server.Containers;
+using Robust.Server.Player;
 using Robust.Shared.Audio;
-using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
+using Robust.Shared.Configuration;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Physics;
 using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Timing;
 
-namespace Content.Server.Explosion.EntitySystems
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
 {
-    public sealed class ExplosionSystem : EntitySystem
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IRobustRandom _robustRandom = default!;
+    [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+
+    [Dependency] private readonly DamageableSystem _damageableSystem = default!;
+    [Dependency] private readonly ContainerSystem _containerSystem = default!;
+    [Dependency] private readonly NodeGroupSystem _nodeGroupSystem = default!;
+    [Dependency] private readonly CameraRecoilSystem _recoilSystem = default!;
+    [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+
+    /// <summary>
+    ///     "Tile-size" for space when there are no nearby grids to use as a reference.
+    /// </summary>
+    public const ushort DefaultTileSize = 1;
+
+    private AudioParams _audioParams = AudioParams.Default.WithVolume(-3f);
+
+    public override void Initialize()
     {
-        [Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
+        base.Initialize();
 
-        /// <summary>
-        /// Distance used for camera shake when distance from explosion is (0.0, 0.0).
-        /// Avoids getting NaN values down the line from doing math on (0.0, 0.0).
-        /// </summary>
-        private static readonly Vector2 EpicenterDistance = (0.1f, 0.1f);
+        // handled in ExplosionSystemGridMap.cs
+        SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoved);
+        SubscribeLocalEvent<GridStartupEvent>(OnGridStartup);
+        SubscribeLocalEvent<ExplosionResistanceComponent, GetExplosionResistanceEvent>(OnGetResistance);
+        _mapManager.TileChanged += OnTileChanged;
 
-        /// <summary>
-        /// Chance of a tile breaking if the severity is Light and Heavy
-        /// </summary>
-        private const float LightBreakChance = 0.3f;
-        private const float HeavyBreakChance = 0.8f;
+        // handled in ExplosionSystemAirtight.cs
+        SubscribeLocalEvent<AirtightComponent, DamageChangedEvent>(OnAirtightDamaged);
+        SubscribeCvars();
+    }
 
-        // TODO move this to the component
-        private static readonly SoundSpecifier ExplosionSound = new SoundCollectionSpecifier("explosion");
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _mapManager.TileChanged -= OnTileChanged;
+        UnsubscribeCvars();
+    }
 
-        [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
-        [Dependency] private readonly IGameTiming _timing = default!;
-        [Dependency] private readonly IMapManager _maps = default!;
-        [Dependency] private readonly IRobustRandom _random = default!;
-        [Dependency] private readonly ITileDefinitionManager _tiles = default!;
+    private void OnGetResistance(EntityUid uid, ExplosionResistanceComponent component, GetExplosionResistanceEvent args)
+    {
+        args.Resistance += component.GlobalResistance;
+        if (component.Resistances.TryGetValue(args.ExplotionPrototype, out var resistance))
+            args.Resistance += resistance;
+    }
 
-        [Dependency] private readonly ActSystem _acts = default!;
-        [Dependency] private readonly EffectSystem _effects = default!;
-        [Dependency] private readonly TriggerSystem _triggers = default!;
-        [Dependency] private readonly AdminLogSystem _logSystem = default!;
-        [Dependency] private readonly CameraRecoilSystem _cameraRecoil = default!;
-        [Dependency] private readonly TagSystem _tags = default!;
+    /// <summary>
+    ///     Given an entity with an explosive component, spawn the appropriate explosion.
+    /// </summary>
+    /// <remarks>
+    ///     Also accepts radius or intensity arguments. This is useful for explosives where the intensity is not
+    ///     specified in the yaml / by the component, but determined dynamically (e.g., by the quantity of a
+    ///     solution in a reaction).
+    /// </remarks>
+    public void TriggerExplosive(EntityUid uid, ExplosiveComponent? explosive = null, bool delete = true, float? totalIntensity = null, float? radius = null)
+    {
+        // log missing: false, because some entities (e.g. liquid tanks) attempt to trigger explosions when damaged,
+        // but may not actually be explosive.
+        if (!Resolve(uid, ref explosive, logMissing: false))
+            return;
 
-        private bool IgnoreExplosivePassable(EntityUid e)
+        // No reusable explosions here.
+        if (explosive.Exploded)
+            return;
+
+        explosive.Exploded = true;
+
+        // Override the explosion intensity if optional arguments were provided.
+        if (radius != null)
+            totalIntensity ??= RadiusToIntensity((float) radius, explosive.IntensitySlope, explosive.MaxIntensity);
+        totalIntensity ??= explosive.TotalIntensity;
+
+        QueueExplosion(uid,
+            explosive.ExplosionType,
+            (float) totalIntensity,
+            explosive.IntensitySlope,
+            explosive.MaxIntensity);
+
+        if (delete)
+            EntityManager.QueueDeleteEntity(uid);
+    }
+
+    /// <summary>
+    ///     Find the strength needed to generate an explosion of a given radius. More useful for radii larger then 4, when the explosion becomes less "blocky".
+    /// </summary>
+    /// <remarks>
+    ///     This assumes the explosion is in a vacuum / unobstructed. Given that explosions are not perfectly
+    ///     circular, here radius actually means the sqrt(Area/pi), where the area is the total number of tiles
+    ///     covered by the explosion. Until you get to radius 30+, this is functionally equivalent to the
+    ///     actual radius.
+    /// </remarks>
+    public float RadiusToIntensity(float radius, float slope, float maxIntensity = 0)
+    {
+        // If you consider the intensity at each tile in an explosion to be a height. Then a circular explosion is
+        // shaped like a cone. So total intensity is like the volume of a cone with height = slope * radius. Of
+        // course, as the explosions are not perfectly circular, this formula isn't perfect, but the formula works
+        // reasonably well.
+
+        // This should actually use the formula for the volume of a distorted octagonal frustum. But this is good
+        // enough.
+
+        var coneVolume = slope * MathF.PI / 3 * MathF.Pow(radius, 3);
+
+        if (maxIntensity <= 0 || slope * radius < maxIntensity)
+            return coneVolume;
+
+        // This explosion is limited by the maxIntensity.
+        // Instead of a cone, we have a conical frustum.
+
+        // Subtract the volume of the missing cone segment, with height:
+        var h = slope * radius - maxIntensity;
+        return coneVolume - h * MathF.PI / 3 * MathF.Pow(h / slope, 2);
+    }
+
+    /// <summary>
+    ///     Inverse formula for <see cref="RadiusToIntensity"/>
+    /// </summary>
+    public float IntensityToRadius(float totalIntensity, float slope, float maxIntensity)
+    {
+        // max radius to avoid being capped by max-intensity
+        var r0 = maxIntensity / slope;
+
+        // volume at r0
+        var v0 = RadiusToIntensity(r0, slope);
+
+        if (totalIntensity <= v0)
         {
-            return _tags.HasTag(e, "ExplosivePassable");
+            // maxIntensity is a non-issue, can use simple inverse formula
+            return MathF.Cbrt(3 * totalIntensity / (slope * MathF.PI));
         }
 
-        private ExplosionSeverity CalculateSeverity(float distance, float devastationRange, float heavyRange)
+        return r0 * (MathF.Sqrt(12 * totalIntensity/ v0 - 3) / 6 + 0.5f);
+    }
+
+    /// <summary>
+    ///     Queue an explosions, centered on some entity.
+    /// </summary>
+    public void QueueExplosion(EntityUid uid,
+        string typeId,
+        float intensity,
+        float slope,
+        float maxTileIntensity)
+    {
+        QueueExplosion(Transform(uid).MapPosition, typeId, intensity, slope, maxTileIntensity);
+    }
+
+    /// <summary>
+    ///     Queue an explosion, with a specified epicenter and set of starting tiles.
+    /// </summary>
+    public void QueueExplosion(MapCoordinates epicenter,
+        string typeId,
+        float totalIntensity,
+        float slope,
+        float maxTileIntensity)
+    {
+        if (totalIntensity <= 0 || slope <= 0)
+            return;
+
+        if (!_prototypeManager.TryIndex<ExplosionPrototype>(typeId, out var type))
         {
-            if (distance < devastationRange)
-            {
-                return ExplosionSeverity.Destruction;
-            }
-            else if (distance < heavyRange)
-            {
-                return ExplosionSeverity.Heavy;
-            }
-            else
-            {
-                return ExplosionSeverity.Light;
-            }
+            Logger.Error($"Attempted to spawn unknown explosion prototype: {type}");
+            return;
         }
 
-        private void CameraShakeInRange(EntityCoordinates epicenter, float maxRange)
+        _explosionQueue.Enqueue(() => SpawnExplosion(epicenter, type, totalIntensity,
+            slope, maxTileIntensity));
+    }
+
+    /// <summary>
+    ///     This function actually spawns the explosion. It returns an <see cref="Explosion"/> instance with
+    ///     information about the affected tiles for the explosion system to process. It will also trigger the
+    ///     camera shake and sound effect.
+    /// </summary>
+    private Explosion? SpawnExplosion(MapCoordinates epicenter,
+        ExplosionPrototype type,
+        float totalIntensity,
+        float slope,
+        float maxTileIntensity)
+    {
+        var results = GetExplosionTiles(epicenter, type.ID, totalIntensity, slope, maxTileIntensity);
+
+        if (results == null)
+            return null;
+
+        var (area, iterationIntensity, spaceData, gridData, spaceMatrix) = results.Value;
+
+        RaiseNetworkEvent(GetExplosionEvent(epicenter, type.ID, spaceMatrix, spaceData, gridData.Values, iterationIntensity));
+
+        // camera shake
+        CameraShake(iterationIntensity.Count * 2.5f, epicenter, totalIntensity);
+
+        //For whatever bloody reason, sound system requires ENTITY coordinates.
+        var mapEntityCoords = EntityCoordinates.FromMap(EntityManager, _mapManager.GetMapEntityId(epicenter.MapId), epicenter);
+
+        // play sound.
+        var audioRange = iterationIntensity.Count * 5;
+        var filter = Filter.Pvs(epicenter).AddInRange(epicenter, audioRange);
+        SoundSystem.Play(filter, type.Sound.GetSound(), mapEntityCoords, _audioParams);
+
+        return new Explosion(this,
+            type,
+            spaceData,
+            gridData.Values.ToList(),
+            iterationIntensity,
+            epicenter,
+            spaceMatrix,
+            area
+            );
+    }
+
+    /// <summary>
+    ///     Constructor for the shared <see cref="ExplosionEvent"/> using the server-exclusive explosion classes.
+    /// </summary>
+    internal ExplosionEvent GetExplosionEvent(MapCoordinates epicenter, string id, Matrix3 spaceMatrix, SpaceExplosion? spaceData, IEnumerable<GridExplosion> gridData, List<float> iterationIntensity)
+    {
+        var spaceTiles = spaceData?.TileLists;
+
+        Dictionary<GridId, Dictionary<int, List<Vector2i>>> tileLists = new();
+        foreach (var grid in gridData)
         {
-            var players = Filter.Empty()
-                .AddInRange(epicenter.ToMap(EntityManager), MathF.Ceiling(maxRange))
-                .Recipients;
-
-            foreach (var player in players)
-            {
-                if (player.AttachedEntity is not {Valid: true} playerEntity ||
-                    !EntityManager.HasComponent<CameraRecoilComponent>(playerEntity))
-                {
-                    continue;
-                }
-
-                var playerPos = EntityManager.GetComponent<TransformComponent>(playerEntity).WorldPosition;
-                var delta = epicenter.ToMapPos(EntityManager) - playerPos;
-
-                //Change if zero. Will result in a NaN later breaking camera shake if not changed
-                if (delta.EqualsApprox((0.0f, 0.0f)))
-                    delta = EpicenterDistance;
-
-                var distance = delta.LengthSquared;
-                var effect = 10 * (1 / (1 + distance));
-                if (effect > 0.01f)
-                {
-                    var kick = -delta.Normalized * effect;
-                    _cameraRecoil.KickCamera(player.AttachedEntity.Value, kick);
-                }
-            }
+            tileLists.Add(grid.Grid.Index, grid.TileLists);
         }
 
-        /// <summary>
-        /// Damage entities inside the range. The damage depends on a discrete
-        /// damage bracket [light, heavy, devastation] and the distance from the epicenter
-        /// </summary>
-        /// <returns>
-        /// A dictionary of coordinates relative to the parents of every grid of entities that survived the explosion,
-        /// have an airtight component and are currently blocking air. Like a wall.
-        /// </returns>
-        private void DamageEntitiesInRange(
-            EntityCoordinates epicenter,
-            Box2 boundingBox,
-            float devastationRange,
-            float heavyRange,
-            float maxRange,
-            MapId mapId)
+        return new ExplosionEvent(_explosionCounter, epicenter, id, iterationIntensity, spaceTiles, tileLists, spaceMatrix);
+    }
+
+    private void CameraShake(float range, MapCoordinates epicenter, float totalIntensity)
+    {
+        var players = Filter.Empty();
+        players.AddInRange(epicenter, range, _playerManager, EntityManager);
+
+        foreach (var player in players.Recipients)
         {
-            var entitiesInRange = _entityLookup.GetEntitiesInRange(mapId, boundingBox, 0).ToList();
+            if (player.AttachedEntity is not EntityUid uid)
+                continue;
 
-            var impassableEntities = new List<(EntityUid, float)>();
-            var nonImpassableEntities = new List<(EntityUid, float)>();
-            // TODO: Given this seems to rely on physics it should just query directly like everything else.
+            var playerPos = Transform(player.AttachedEntity!.Value).WorldPosition;
+            var delta = epicenter.Position - playerPos;
 
-            // The entities are paired with their distance to the epicenter
-            // and splitted into two lists based on if they are Impassable or not
-            foreach (var entity in entitiesInRange)
-            {
-                if (Deleted(entity) || entity.IsInContainer())
-                {
-                    continue;
-                }
+            if (delta.EqualsApprox(Vector2.Zero))
+                delta = new(0.01f, 0);
 
-                if (!EntityManager.GetComponent<TransformComponent>(entity).Coordinates.TryDistance(EntityManager, epicenter, out var distance) ||
-                    distance > maxRange)
-                {
-                    continue;
-                }
-
-                if (!EntityManager.TryGetComponent(entity, out FixturesComponent? fixturesComp) || fixturesComp.Fixtures.Count < 1)
-                {
-                    continue;
-                }
-
-                if (!EntityManager.TryGetComponent(entity, out PhysicsComponent? body))
-                {
-                    continue;
-                }
-
-                if ((body.CollisionLayer & (int) CollisionGroup.Impassable) != 0)
-                {
-                    impassableEntities.Add((entity, distance));
-                }
-                else
-                {
-                    nonImpassableEntities.Add((entity, distance));
-                }
-            }
-
-            // The Impassable entities are sorted in descending order
-            // Entities closer to the epicenter are first
-            impassableEntities.Sort((x, y) => x.Item2.CompareTo(y.Item2));
-
-            // Impassable entities are handled first. If they are damaged enough, they are destroyed and they may
-            // be able to spawn a new entity. I.e Wall -> Girder.
-            // Girder has a tag ExplosivePassable, and the predicate make it so the entities with this tag are ignored
-            var epicenterMapPos = epicenter.ToMap(EntityManager);
-            foreach (var (entity, distance) in impassableEntities)
-            {
-                if (!_interactionSystem.InRangeUnobstructed(epicenterMapPos, entity, maxRange, predicate: IgnoreExplosivePassable))
-                {
-                    continue;
-                }
-
-                _acts.HandleExplosion(epicenter, entity, CalculateSeverity(distance, devastationRange, heavyRange));
-            }
-
-            // Impassable entities were handled first so NonImpassable entities have a bigger chance to get hit. As now
-            // there are probably more ExplosivePassable entities around
-            foreach (var (entity, distance) in nonImpassableEntities)
-            {
-                if (!_interactionSystem.InRangeUnobstructed(epicenterMapPos, entity, maxRange, predicate: IgnoreExplosivePassable))
-                {
-                    continue;
-                }
-
-                _acts.HandleExplosion(epicenter, entity, CalculateSeverity(distance, devastationRange, heavyRange));
-            }
-        }
-
-        /// <summary>
-        /// Damage tiles inside the range. The type of tile can change depending on a discrete
-        /// damage bracket [light, heavy, devastation], the distance from the epicenter and
-        /// a probability bracket [<see cref="LightBreakChance"/>, <see cref="HeavyBreakChance"/>, 1.0].
-        /// </summary>
-        ///
-        private void DamageTilesInRange(EntityCoordinates epicenter,
-                                               GridId gridId,
-                                               Box2 boundingBox,
-                                               float devastationRange,
-                                               float heaveyRange,
-                                               float maxRange)
-        {
-            if (!_maps.TryGetGrid(gridId, out var mapGrid))
-            {
-                return;
-            }
-
-            if (!EntityManager.EntityExists(mapGrid.GridEntityId))
-            {
-                return;
-            }
-
-            var tilesInGridAndCircle = mapGrid.GetTilesIntersecting(boundingBox);
-            var epicenterMapPos = epicenter.ToMap(EntityManager);
-
-            foreach (var tile in tilesInGridAndCircle)
-            {
-                var tileLoc = mapGrid.GridTileToLocal(tile.GridIndices);
-                if (!tileLoc.TryDistance(EntityManager, epicenter, out var distance) ||
-                    distance > maxRange)
-                {
-                    continue;
-                }
-
-                if (tile.IsBlockedTurf(false))
-                {
-                    continue;
-                }
-
-                if (!_interactionSystem.InRangeUnobstructed(tileLoc.ToMap(EntityManager), epicenterMapPos, maxRange, predicate: IgnoreExplosivePassable))
-                {
-                    continue;
-                }
-
-                var tileDef = (ContentTileDefinition) _tiles[tile.Tile.TypeId];
-                var baseTurfs = tileDef.BaseTurfs;
-                if (baseTurfs.Count == 0)
-                {
-                    continue;
-                }
-
-                var zeroTile = new Tile(_tiles[baseTurfs[0]].TileId);
-                var previousTile = new Tile(_tiles[baseTurfs[^1]].TileId);
-
-                var severity = CalculateSeverity(distance, devastationRange, heaveyRange);
-
-                switch (severity)
-                {
-                    case ExplosionSeverity.Light:
-                        if (!previousTile.IsEmpty && _random.Prob(LightBreakChance))
-                        {
-                            mapGrid.SetTile(tileLoc, previousTile);
-                        }
-                        break;
-                    case ExplosionSeverity.Heavy:
-                        if (!previousTile.IsEmpty && _random.Prob(HeavyBreakChance))
-                        {
-                            mapGrid.SetTile(tileLoc, previousTile);
-                        }
-                        break;
-                    case ExplosionSeverity.Destruction:
-                        mapGrid.SetTile(tileLoc, zeroTile);
-                        break;
-                }
-            }
-        }
-
-        private void FlashInRange(EntityCoordinates epicenter, float flashRange)
-        {
-            if (flashRange > 0)
-            {
-                var time = _timing.CurTime;
-                var message = new EffectSystemMessage
-                {
-                    EffectSprite = "Effects/explosion.rsi",
-                    RsiState = "explosionfast",
-                    Born = time,
-                    DeathTime = time + TimeSpan.FromSeconds(5),
-                    Size = new Vector2(flashRange / 2, flashRange / 2),
-                    Coordinates = epicenter,
-                    Rotation = 0f,
-                    ColorDelta = new Vector4(0, 0, 0, -1500f),
-                    Color = Vector4.Multiply(new Vector4(255, 255, 255, 750), 0.5f),
-                    Shaded = false
-                };
-
-                _effects.CreateParticle(message);
-            }
-        }
-
-        public void SpawnExplosion(
-            EntityUid entity,
-            int devastationRange = 0,
-            int heavyImpactRange = 0,
-            int lightImpactRange = 0,
-            int flashRange = 0,
-            EntityUid? user = null,
-            ExplosiveComponent? explosive = null,
-            TransformComponent? transform = null)
-        {
-            if (!Resolve(entity, ref transform))
-            {
-                return;
-            }
-
-            Resolve(entity, ref explosive, false);
-
-            if (explosive is { Exploding: false })
-            {
-                _triggers.Explode(entity, explosive, user);
-            }
-            else
-            {
-                while (EntityManager.EntityExists(entity) && entity.TryGetContainer(out var container))
-                {
-                    entity = container.Owner;
-                }
-
-                if (!EntityManager.TryGetComponent(entity, out transform))
-                {
-                    return;
-                }
-
-                var epicenter = transform.Coordinates;
-
-                SpawnExplosion(epicenter, devastationRange, heavyImpactRange, lightImpactRange, flashRange, entity, user);
-            }
-        }
-
-        public void SpawnExplosion(
-            EntityCoordinates epicenter,
-            int devastationRange = 0,
-            int heavyImpactRange = 0,
-            int lightImpactRange = 0,
-            int flashRange = 0,
-            EntityUid? entity = null,
-            EntityUid? user = null)
-        {
-            var mapId = epicenter.GetMapId(EntityManager);
-            if (mapId == MapId.Nullspace)
-            {
-                return;
-            }
-
-            // logging
-            var range = $"{devastationRange}/{heavyImpactRange}/{lightImpactRange}/{flashRange}";
-            if (entity == null || !entity.Value.IsValid())
-            {
-                _logSystem.Add(LogType.Explosion, LogImpact.High, $"Explosion spawned at {epicenter:coordinates} with range {range}");
-            }
-            else if (user == null || !user.Value.IsValid())
-            {
-                _logSystem.Add(LogType.Explosion, LogImpact.High,
-                    $"{ToPrettyString(entity.Value):entity} exploded at {epicenter:coordinates} with range {range}");
-            }
-            else
-            {
-                _logSystem.Add(LogType.Explosion, LogImpact.High,
-                    $"{ToPrettyString(user.Value):user} caused {ToPrettyString(entity.Value):entity} to explode at {epicenter:coordinates} with range {range}");
-            }
-
-            var maxRange = MathHelper.Max(devastationRange, heavyImpactRange, lightImpactRange, 0);
-            var epicenterMapPos = epicenter.ToMapPos(EntityManager);
-            var boundingBox = new Box2(epicenterMapPos - new Vector2(maxRange, maxRange),
-                epicenterMapPos + new Vector2(maxRange, maxRange));
-
-            SoundSystem.Play(Filter.Broadcast(), ExplosionSound.GetSound(), epicenter);
-            DamageEntitiesInRange(epicenter, boundingBox, devastationRange, heavyImpactRange, maxRange, mapId);
-
-            var mapGridsNear = _maps.FindGridsIntersecting(mapId, boundingBox);
-
-            foreach (var gridId in mapGridsNear)
-            {
-                DamageTilesInRange(epicenter, gridId.Index, boundingBox, devastationRange, heavyImpactRange, maxRange);
-            }
-
-            CameraShakeInRange(epicenter, maxRange);
-            FlashInRange(epicenter, flashRange);
+            var distance = delta.Length;
+            var effect = 5 * MathF.Pow(totalIntensity, 0.5f) * (1 - distance / range);
+            if (effect > 0.01f)
+                _recoilSystem.KickCamera(uid, -delta.Normalized * effect);
         }
     }
 }
diff --git a/Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs
new file mode 100644
index 0000000000..4dd2f8e477
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/ExplosionSystem.cvars.cs
@@ -0,0 +1,44 @@
+using Content.Shared.CCVar;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+public sealed partial class ExplosionSystem : EntitySystem
+{
+    public int MaxIterations { get; private set; }
+    public int MaxArea { get; private set; }
+    public float MaxProcessingTime { get; private set; }
+    public int TilesPerTick { get; private set; }
+    public int ThrowLimit { get; private set; }
+    public bool SleepNodeSys { get; private set; }
+    public bool IncrementalTileBreaking { get; private set; }
+
+    private void SubscribeCvars()
+    {
+        _cfg.OnValueChanged(CCVars.ExplosionTilesPerTick, SetTilesPerTick, true);
+        _cfg.OnValueChanged(CCVars.ExplosionThrowLimit, SetThrowLimit, true);
+        _cfg.OnValueChanged(CCVars.ExplosionSleepNodeSys, SetSleepNodeSys, true);
+        _cfg.OnValueChanged(CCVars.ExplosionMaxArea, SetMaxArea, true);
+        _cfg.OnValueChanged(CCVars.ExplosionMaxIterations, SetMaxIterations, true);
+        _cfg.OnValueChanged(CCVars.ExplosionMaxProcessingTime, SetMaxProcessingTime, true);
+        _cfg.OnValueChanged(CCVars.ExplosionIncrementalTileBreaking, SetIncrementalTileBreaking, true);
+    }
+
+    private void UnsubscribeCvars()
+    {
+        _cfg.UnsubValueChanged(CCVars.ExplosionTilesPerTick, SetTilesPerTick);
+        _cfg.UnsubValueChanged(CCVars.ExplosionThrowLimit, SetThrowLimit);
+        _cfg.UnsubValueChanged(CCVars.ExplosionSleepNodeSys, SetSleepNodeSys);
+        _cfg.UnsubValueChanged(CCVars.ExplosionMaxArea, SetMaxArea);
+        _cfg.UnsubValueChanged(CCVars.ExplosionMaxIterations, SetMaxIterations);
+        _cfg.UnsubValueChanged(CCVars.ExplosionMaxProcessingTime, SetMaxProcessingTime);
+        _cfg.UnsubValueChanged(CCVars.ExplosionIncrementalTileBreaking, SetIncrementalTileBreaking);
+    }
+
+    private void SetTilesPerTick(int value) => TilesPerTick = value;
+    private void SetThrowLimit(int value) => ThrowLimit = value;
+    private void SetSleepNodeSys(bool value) => SleepNodeSys = value;
+    private void SetMaxArea(int value) => MaxArea = value;
+    private void SetMaxIterations(int value) => MaxIterations = value;
+    private void SetMaxProcessingTime(float value) => MaxProcessingTime = value;
+    private void SetIncrementalTileBreaking(bool value) => IncrementalTileBreaking = value;
+}
diff --git a/Content.Server/Explosion/EntitySystems/GridExplosion.cs b/Content.Server/Explosion/EntitySystems/GridExplosion.cs
new file mode 100644
index 0000000000..52650c28b2
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/GridExplosion.cs
@@ -0,0 +1,311 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+internal sealed class GridExplosion : TileExplosion
+{
+    public IMapGrid Grid;
+    private bool _needToTransform = false;
+
+    private Matrix3 _matrix = Matrix3.Identity;
+    private Vector2 _offset;
+
+    private HashSet<Vector2i> _processedSpaceTiles = new();
+
+    // Tiles which neighbor an exploding tile, but have not yet had the explosion spread to them due to an
+    // airtight entity on the exploding tile that prevents the explosion from spreading in that direction. These
+    // will be added as a neighbor after some delay, once the explosion on that tile is sufficiently strong to
+    // destroy the airtight entity.
+    private Dictionary<int, List<(Vector2i, AtmosDirection)>> _delayedNeighbors = new();
+
+    private Dictionary<Vector2i, TileData> _airtightMap;
+
+    private float _maxIntensity;
+    private float _intensityStepSize;
+    private string _typeID;
+
+    /// <summary>
+    ///     Tiles on this grid that are not actually on this grid.... uhh ... yeah.... look its faster than checking
+    ///     atmos directions every iteration.
+    /// </summary>
+    private HashSet<Vector2i> _spaceTiles = new();
+
+    public HashSet<Vector2i> SpaceJump = new();
+
+    private Dictionary<Vector2i, AtmosDirection> _edgeTiles;
+
+    public GridExplosion(
+        IMapGrid grid,
+        Dictionary<Vector2i, TileData> airtightMap,
+        float maxIntensity,
+        float intensityStepSize,
+        string typeID,
+        Dictionary<Vector2i, AtmosDirection> edgeTiles,
+        GridId? referenceGrid,
+        Matrix3 spaceMatrix,
+        Angle spaceAngle)
+    {
+        Grid = grid;
+        _airtightMap = airtightMap;
+        _maxIntensity = maxIntensity;
+        _intensityStepSize = intensityStepSize;
+        _typeID = typeID;
+        _edgeTiles = edgeTiles;
+
+        // initialise SpaceTiles
+        foreach (var (tile, dir) in _edgeTiles)
+        {
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+                if (dir.IsFlagSet(direction))
+                    _spaceTiles.Add(tile.Offset(direction));
+            }
+        }
+
+        // TODO EXPLOSIONS fix this shit.
+        foreach (var tile in _edgeTiles.Keys)
+        {
+            foreach (var diagTile in ExplosionSystem.GetDiagonalNeighbors(tile))
+            {
+                if (_spaceTiles.Contains(diagTile))
+                    continue;
+
+                if (!Grid.TryGetTileRef(diagTile, out var tileRef) || tileRef.Tile.IsEmpty)
+                    _spaceTiles.Add(diagTile);
+            }
+        }
+
+        if (referenceGrid == Grid.Index)
+            return;
+
+        _needToTransform = true;
+        var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Grid.GridEntityId);
+        var size = (float) Grid.TileSize;
+
+        _matrix.R0C2 = size / 2;
+        _matrix.R1C2 = size / 2;
+        _matrix *= transform.WorldMatrix * Matrix3.Invert(spaceMatrix);
+        var relativeAngle = transform.WorldRotation - spaceAngle;
+        _offset = relativeAngle.RotateVec((size / 4, size / 4));
+    }
+
+    public int AddNewTiles(int iteration, HashSet<Vector2i>? gridJump)
+    {
+        SpaceJump = new();
+        NewTiles = new();
+        NewBlockedTiles = new();
+
+        // Mark tiles as entered if any were just freed due to airtight/explosion blockers being destroyed.
+        if (FreedTileLists.TryGetValue(iteration, out var freed))
+        {
+            freed.ExceptWith(EnteredBlockedTiles);
+            EnteredBlockedTiles.UnionWith(freed);
+            NewFreedTiles = freed;
+        }
+        else
+        {
+            NewFreedTiles = new();
+            FreedTileLists[iteration] = NewFreedTiles;
+        }
+
+        // Add adjacent tiles
+        if (TileLists.TryGetValue(iteration - 2, out var adjacent))
+            AddNewAdjacentTiles(iteration, adjacent, false);
+        if (FreedTileLists.TryGetValue(iteration - 2, out var delayedAdjacent))
+            AddNewAdjacentTiles(iteration, delayedAdjacent, true);
+
+        // Add diagonal tiles
+        if (TileLists.TryGetValue(iteration - 3, out var diagonal))
+            AddNewDiagonalTiles(iteration, diagonal, false);
+        if (FreedTileLists.TryGetValue(iteration - 3, out var delayedDiagonal))
+            AddNewDiagonalTiles(iteration, delayedDiagonal, true);
+
+        // Add delayed tiles
+        AddDelayedNeighbors(iteration);
+
+        // Tiles from Spaaaace
+        if (gridJump != null)
+        {
+            foreach (var tile in gridJump)
+            {
+                ProcessNewTile(iteration, tile, AtmosDirection.Invalid);
+            }
+        }
+
+        // Store new tiles
+        if (NewTiles.Count != 0)
+            TileLists[iteration] = NewTiles;
+        if (NewBlockedTiles.Count != 0)
+            BlockedTileLists[iteration] = NewBlockedTiles;
+
+        return NewTiles.Count + NewBlockedTiles.Count;
+    }
+
+    protected override void ProcessNewTile(int iteration, Vector2i tile, AtmosDirection entryDirections)
+    {
+        // Is there an airtight blocker on this tile?
+        if (!_airtightMap.TryGetValue(tile, out var tileData))
+        {
+            // No blocker. Ezy. Though maybe this a space tile?
+
+            if (_spaceTiles.Contains(tile))
+                JumpToSpace(tile);
+            else if (ProcessedTiles.Add(tile))
+                NewTiles.Add(tile);
+
+            return;
+        }
+
+        // If the explosion is entering this new tile from an unblocked direction, we add it directly. Note that because
+        // for space -> grid jumps, we don't have a direction from which the explosion came, we will only assume it is
+        // unblocked if all space-facing directions are unblocked. Though this could eventually be done properly.
+
+        bool blocked;
+        var blockedDirections = tileData.BlockedDirections;
+        if (entryDirections == AtmosDirection.Invalid) // is coming from space?
+        {
+            var spaceDirections = _edgeTiles[tile];
+            blocked = (blockedDirections & spaceDirections) != 0; // at least one space direction is blocked.
+        }
+        else
+            blocked = (blockedDirections & entryDirections) == entryDirections;// **ALL** entry directions are blocked
+
+        if (blocked)
+        {
+            // was this tile already entered from some other direction?
+            if (EnteredBlockedTiles.Contains(tile))
+                return;
+
+            // Did the explosion already attempt to enter this tile from some other direction? 
+            if (!UnenteredBlockedTiles.Add(tile))
+                return;
+
+            NewBlockedTiles.Add(tile);
+
+            // At what explosion iteration would this blocker be destroyed?
+
+            if (!tileData.ExplosionTolerance.TryGetValue(_typeID, out var sealIntegrity))
+                sealIntegrity = float.MaxValue; // indestructible airtight entity
+
+            var clearIteration = iteration + (int) MathF.Ceiling(sealIntegrity / _intensityStepSize);
+            if (FreedTileLists.TryGetValue(clearIteration, out var list))
+                list.Add(tile);
+            else
+                FreedTileLists[clearIteration] = new() { tile };
+
+            return;
+        }
+
+        // was this tile already entered from some other direction?
+        if (!EnteredBlockedTiles.Add(tile))
+            return;
+
+        // Did the explosion already attempt to enter this tile from some other direction? 
+        if (UnenteredBlockedTiles.Contains(tile))
+        {
+            NewFreedTiles.Add(tile);
+            return;
+        }
+
+        // This is a completely new tile, and we just so happened to enter it from an unblocked direction.
+        NewTiles.Add(tile);
+    }
+
+    private void JumpToSpace(Vector2i tile)
+    {
+        // Did we already jump/process this tile?
+        if (!_processedSpaceTiles.Add(tile))
+            return;
+
+        if (!_needToTransform)
+        {
+            SpaceJump.Add(tile);
+            return;
+        }
+
+        var center = _matrix.Transform(tile);
+        SpaceJump.Add(new((int) MathF.Floor(center.X + _offset.X), (int) MathF.Floor(center.Y + _offset.Y)));
+        SpaceJump.Add(new((int) MathF.Floor(center.X - _offset.Y), (int) MathF.Floor(center.Y + _offset.X)));
+        SpaceJump.Add(new((int) MathF.Floor(center.X - _offset.X), (int) MathF.Floor(center.Y - _offset.Y)));
+        SpaceJump.Add(new((int) MathF.Floor(center.X + _offset.Y), (int) MathF.Floor(center.Y - _offset.X)));
+    }
+
+    private void AddDelayedNeighbors(int iteration)
+    {
+        if (!_delayedNeighbors.TryGetValue(iteration, out var delayed))
+            return;
+
+        foreach (var (tile, direction) in delayed)
+        {
+            ProcessNewTile(iteration, tile, direction);
+        }
+
+        _delayedNeighbors.Remove(iteration);
+    }
+
+    // Gets the tiles that are directly adjacent to other tiles. If a currently exploding tile has an airtight entity
+    // that blocks the explosion from propagating in some direction, those tiles are added to a list of delayed tiles
+    // that will be added to the explosion in some future iteration.
+    private void AddNewAdjacentTiles(int iteration, IEnumerable<Vector2i> tiles, bool ignoreTileBlockers = false)
+    {
+        foreach (var tile in tiles)
+        {
+            var blockedDirections = AtmosDirection.Invalid;
+            float sealIntegrity = 0;
+
+            // Note that if (grid, tile) is not a valid key, then airtight.BlockedDirections will default to 0 (no blocked directions)
+            if (_airtightMap.TryGetValue(tile, out var tileData))
+            {
+                blockedDirections = tileData.BlockedDirections;
+                if (!tileData.ExplosionTolerance.TryGetValue(_typeID, out sealIntegrity))
+                    sealIntegrity = float.MaxValue; // indestructible airtight entity
+            }
+
+            // First, yield any neighboring tiles that are not blocked by airtight entities on this tile
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+                if (ignoreTileBlockers || !blockedDirections.IsFlagSet(direction))
+                {
+                    ProcessNewTile(iteration, tile.Offset(direction), direction.GetOpposite());
+                }
+            }
+
+            // If there are no blocked directions, we are done with this tile.
+            if (ignoreTileBlockers || blockedDirections == AtmosDirection.Invalid)
+                continue;
+
+            // This tile has one or more airtight entities anchored to it blocking the explosion from traveling in
+            // some directions. First, check whether this blocker can even be destroyed by this explosion?
+            if (sealIntegrity > _maxIntensity || float.IsNaN(sealIntegrity))
+                continue;
+
+            // At what explosion iteration would this blocker be destroyed?
+            var clearIteration = iteration + (int) MathF.Ceiling(sealIntegrity / _intensityStepSize);
+
+            // Get the delayed neighbours list
+            if (!_delayedNeighbors.TryGetValue(clearIteration, out var list))
+            {
+                list = new();
+                _delayedNeighbors[clearIteration] = list;
+            }
+
+            // Check which directions are blocked, and add them to the list.
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+                if (blockedDirections.IsFlagSet(direction))
+                {
+                    list.Add((tile.Offset(direction), direction.GetOpposite()));
+                }
+            }
+        }
+    }
+
+    protected override AtmosDirection GetUnblockedDirectionOrAll(Vector2i tile)
+    {
+        return ~_airtightMap.GetValueOrDefault(tile).BlockedDirections;
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs b/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs
new file mode 100644
index 0000000000..d6d8e5efb1
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/SpaceExplosion.cs
@@ -0,0 +1,157 @@
+using Content.Shared.Atmos;
+using Robust.Shared.Map;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+internal sealed class SpaceExplosion : TileExplosion
+{
+    /// <summary>
+    ///     The keys of this dictionary correspond to space tiles that intersect a grid. The values have information
+    ///     about what grid (which could be more than one), and in what directions the space-based explosion is allowed
+    ///     to propagate from this tile.
+    /// </summary>
+    private Dictionary<Vector2i, GridBlockData> _gridBlockMap;
+
+    /// <summary>
+    ///     After every iteration, this data set will store all the grid-tiles that were reached as a result of the
+    ///     explosion expanding in space.
+    /// </summary>
+    internal Dictionary<GridId, HashSet<Vector2i>> GridJump = new();
+
+    internal SpaceExplosion(ExplosionSystem system, MapId targetMap, GridId? referenceGrid, List<GridId> localGrids)
+    {
+        (_gridBlockMap, var tileSize) = system.TransformGridEdges(targetMap, referenceGrid, localGrids);
+        system.GetUnblockedDirections(_gridBlockMap, tileSize);
+    }
+
+    internal int AddNewTiles(int iteration, HashSet<Vector2i> inputSpaceTiles)
+    {
+        NewTiles = new();
+        NewBlockedTiles = new();
+        NewFreedTiles = new();
+        GridJump = new();
+
+        // Adjacent tiles
+        if (TileLists.TryGetValue(iteration - 2, out var adjacent))
+            AddNewAdjacentTiles(iteration, adjacent);
+        if (FreedTileLists.TryGetValue((iteration - 2) % 3, out var delayedAdjacent))
+            AddNewAdjacentTiles(iteration, delayedAdjacent);
+
+        // Diagonal tiles
+        if (TileLists.TryGetValue(iteration - 3, out var diagonal))
+            AddNewDiagonalTiles(iteration, diagonal);
+        if (FreedTileLists.TryGetValue((iteration - 3) % 3, out var delayedDiagonal))
+            AddNewDiagonalTiles(iteration, delayedDiagonal);
+
+        // Tiles entering space from some grid.
+        foreach (var tile in inputSpaceTiles)
+        {
+            ProcessNewTile(iteration, tile, AtmosDirection.All);
+        }
+
+        // Store new tiles
+        if (NewTiles.Count != 0)
+            TileLists[iteration] = NewTiles;
+        if (NewBlockedTiles.Count != 0)
+            BlockedTileLists[iteration] = NewBlockedTiles;
+        FreedTileLists[iteration % 3] = NewFreedTiles;
+
+        // return new tile count
+        return NewTiles.Count + NewBlockedTiles.Count;
+    }
+
+    private void JumpToGrid(GridBlockData blocker)
+    {
+        foreach (var edge in blocker.BlockingGridEdges)
+        {
+            if (edge.Grid == null) continue;
+
+            if (!GridJump.TryGetValue(edge.Grid.Value, out var set))
+            {
+                set = new();
+                GridJump[edge.Grid.Value] = set;
+            }
+
+            set.Add(edge.Tile);
+        }
+    }
+
+    private void AddNewAdjacentTiles(int iteration, IEnumerable<Vector2i> tiles)
+    {
+        foreach (var tile in tiles)
+        {
+            var unblockedDirections = GetUnblockedDirectionOrAll(tile);
+
+            if (unblockedDirections == AtmosDirection.Invalid)
+                continue;
+
+            for (var i = 0; i < Atmospherics.Directions; i++)
+            {
+                var direction = (AtmosDirection) (1 << i);
+
+                if (!unblockedDirections.IsFlagSet(direction))
+                    continue; // explosion cannot propagate in this direction. Ever.
+
+                ProcessNewTile(iteration, tile.Offset(direction), direction.GetOpposite());
+            }
+        }
+    }
+
+    internal override void InitTile(Vector2i initialTile)
+    {
+        base.InitTile(initialTile);
+
+        // It might be the case that the initial space-explosion tile actually overlaps on a grid. In that case we
+        // need to manually add it to the `spaceToGridTiles` dictionary. This would normally be done automatically
+        // during the neighbor finding steps.
+        if (_gridBlockMap.TryGetValue(initialTile, out var blocker))
+            JumpToGrid(blocker);
+    }
+
+    protected override void ProcessNewTile(int iteration, Vector2i tile, AtmosDirection entryDirection)
+    {
+        if (!_gridBlockMap.TryGetValue(tile, out var blocker))
+        {
+            // this tile does not intersect any grids. Add it (if its new) and continue.
+            if (ProcessedTiles.Add(tile))
+                NewTiles.Add(tile);
+            return;
+        }
+
+        // Is the entry to this tile blocked?
+        if ((blocker.UnblockedDirections & entryDirection) == 0)
+        {
+            // was this tile already entered from some other direction?
+            if (EnteredBlockedTiles.Contains(tile))
+                return;
+
+            // Did the explosion already attempt to enter this tile from some other direction? 
+            if (!UnenteredBlockedTiles.Add(tile))
+                return;
+
+            // First time the explosion is reaching this tile.
+            NewBlockedTiles.Add(tile);
+            JumpToGrid(blocker);
+        }
+
+        // Was this tile already entered?
+        if (!EnteredBlockedTiles.Add(tile))
+            return;
+
+        // Did the explosion already attempt to enter this tile from some other direction? 
+        if (UnenteredBlockedTiles.Contains(tile))
+        {
+            NewFreedTiles.Add(tile);
+            return;
+        }
+
+        // This is a completely new tile, and we just so happened to enter it from an unblocked direction.
+        NewTiles.Add(tile);
+        JumpToGrid(blocker);
+    }
+
+    protected override AtmosDirection GetUnblockedDirectionOrAll(Vector2i tile)
+    {
+        return _gridBlockMap.TryGetValue(tile, out var blocker) ? blocker.UnblockedDirections : AtmosDirection.All;
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/TileExplosion.cs b/Content.Server/Explosion/EntitySystems/TileExplosion.cs
new file mode 100644
index 0000000000..4050434d1b
--- /dev/null
+++ b/Content.Server/Explosion/EntitySystems/TileExplosion.cs
@@ -0,0 +1,116 @@
+using Content.Shared.Atmos;
+
+namespace Content.Server.Explosion.EntitySystems;
+
+/// <summary>
+///     This is the base class for <see cref="SpaceExplosion"/> and <see cref="GridExplosion"/>. It just exists to avoid some code duplication, because those classes are generally quite distinct.
+/// </summary>
+internal abstract class TileExplosion
+{
+    // Main tile data sets, mapping iterations onto tile lists
+    internal Dictionary<int, List<Vector2i>> TileLists = new();
+    protected Dictionary<int, List<Vector2i>> BlockedTileLists = new();
+    protected Dictionary<int, HashSet<Vector2i>> FreedTileLists = new();
+
+    // The new tile lists added each iteration. I **could** just pass these along to every function, but IMO it is more
+    // readable if they are just private variables.
+    protected List<Vector2i> NewTiles = default!;
+    protected List<Vector2i> NewBlockedTiles = default!;
+    protected HashSet<Vector2i> NewFreedTiles = default!;
+
+    // HashSets used to ensure uniqueness of tiles. Prevents the explosion from looping back in on itself.
+    protected HashSet<Vector2i> ProcessedTiles = new();
+    protected HashSet<Vector2i> UnenteredBlockedTiles = new();
+    protected HashSet<Vector2i> EnteredBlockedTiles = new();
+
+    internal virtual void InitTile(Vector2i initialTile)
+    {
+        ProcessedTiles.Add(initialTile);
+        TileLists[0] = new() { initialTile };
+    }
+
+    protected abstract void ProcessNewTile(int iteration, Vector2i tile, AtmosDirection entryDirections);
+
+    protected abstract AtmosDirection GetUnblockedDirectionOrAll(Vector2i tile);
+
+    protected void AddNewDiagonalTiles(int iteration, IEnumerable<Vector2i> tiles, bool ignoreLocalBlocker = false)
+    {
+        AtmosDirection entryDirection = AtmosDirection.Invalid;
+        foreach (var tile in tiles)
+        {
+            var freeDirections = ignoreLocalBlocker ? AtmosDirection.All : GetUnblockedDirectionOrAll(tile);
+
+            // Get the free directions of the directly adjacent tiles            
+            var freeDirectionsN = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.North));
+            var freeDirectionsE = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.East));
+            var freeDirectionsS = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.South));
+            var freeDirectionsW = GetUnblockedDirectionOrAll(tile.Offset(AtmosDirection.West));
+
+            // North East
+            if (freeDirections.IsFlagSet(AtmosDirection.North) && freeDirectionsN.IsFlagSet(AtmosDirection.SouthEast))
+                entryDirection |= AtmosDirection.West;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.East) && freeDirectionsE.IsFlagSet(AtmosDirection.NorthWest))
+                entryDirection |= AtmosDirection.South;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (1, 1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+
+            // North West
+            if (freeDirections.IsFlagSet(AtmosDirection.North) && freeDirectionsN.IsFlagSet(AtmosDirection.SouthWest))
+                entryDirection |= AtmosDirection.East;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.West) && freeDirectionsW.IsFlagSet(AtmosDirection.NorthEast))
+                entryDirection |= AtmosDirection.West;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (-1, 1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+
+            // South East
+            if (freeDirections.IsFlagSet(AtmosDirection.South) && freeDirectionsS.IsFlagSet(AtmosDirection.NorthEast))
+                entryDirection |= AtmosDirection.West;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.East) && freeDirectionsE.IsFlagSet(AtmosDirection.SouthWest))
+                entryDirection |= AtmosDirection.North;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (1, -1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+
+            // South West
+            if (freeDirections.IsFlagSet(AtmosDirection.South) && freeDirectionsS.IsFlagSet(AtmosDirection.NorthWest))
+                entryDirection |= AtmosDirection.West;
+
+            if (freeDirections.IsFlagSet(AtmosDirection.West) && freeDirectionsW.IsFlagSet(AtmosDirection.SouthEast))
+                entryDirection |= AtmosDirection.North;
+
+            if (entryDirection != AtmosDirection.Invalid)
+            {
+                ProcessNewTile(iteration, tile + (-1, -1), entryDirection);
+                entryDirection = AtmosDirection.Invalid;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Merge all tile lists into a single output tile list.
+    /// </summary>
+    internal void CleanUp()
+    {
+        foreach (var (iteration, blocked) in BlockedTileLists)
+        {
+            if (TileLists.TryGetValue(iteration, out var tiles))
+                tiles.AddRange(blocked);
+            else
+                TileLists[iteration] = blocked;
+        }
+    }
+}
diff --git a/Content.Server/Explosion/EntitySystems/TriggerSystem.cs b/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
index b6ead70656..09fdba4329 100644
--- a/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
+++ b/Content.Server/Explosion/EntitySystems/TriggerSystem.cs
@@ -65,33 +65,11 @@ namespace Content.Server.Explosion.EntitySystems
             SubscribeLocalEvent<ToggleDoorOnTriggerComponent, TriggerEvent>(HandleDoorTrigger);
         }
 
-        #region Explosions
         private void HandleExplodeTrigger(EntityUid uid, ExplodeOnTriggerComponent component, TriggerEvent args)
         {
-            if (!EntityManager.TryGetComponent(uid, out ExplosiveComponent? explosiveComponent)) return;
-
-            Explode(uid, explosiveComponent, args.User);
+            _explosions.TriggerExplosive(uid);
         }
 
-        // You really shouldn't call this directly (TODO Change that when ExplosionHelper gets changed).
-        public void Explode(EntityUid uid, ExplosiveComponent component, EntityUid? user = null)
-        {
-            if (component.Exploding)
-            {
-                return;
-            }
-
-            component.Exploding = true;
-            _explosions.SpawnExplosion(uid,
-                component.DevastationRange,
-                component.HeavyImpactRange,
-                component.LightImpactRange,
-                component.FlashRange,
-                user);
-            EntityManager.QueueDeleteEntity(uid);
-        }
-        #endregion
-
         #region Flash
         private void HandleFlashTrigger(EntityUid uid, FlashOnTriggerComponent component, TriggerEvent args)
         {
diff --git a/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs b/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs
index a620fc4e44..abf1088da0 100644
--- a/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs
+++ b/Content.Server/NodeContainer/EntitySystems/NodeGroupSystem.cs
@@ -50,6 +50,8 @@ namespace Content.Server.NodeContainer.EntitySystems
         private int _gen = 1;
         private int _groupNetIdCounter = 1;
 
+        public bool Snoozing = false;
+
         public override void Initialize()
         {
             base.Initialize();
@@ -138,8 +140,11 @@ namespace Content.Server.NodeContainer.EntitySystems
         {
             base.Update(frameTime);
 
-            DoGroupUpdates();
-            VisDoUpdate(frameTime);
+            if (!Snoozing)
+            {
+                DoGroupUpdates();
+                VisDoUpdate(frameTime);
+            }
         }
 
         private void DoGroupUpdates()
diff --git a/Content.Server/Nuke/NukeComponent.cs b/Content.Server/Nuke/NukeComponent.cs
index 230a86b339..aa312bec06 100644
--- a/Content.Server/Nuke/NukeComponent.cs
+++ b/Content.Server/Nuke/NukeComponent.cs
@@ -1,7 +1,9 @@
 using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Explosion;
 using Content.Shared.Nuke;
 using Content.Shared.Sound;
 using Robust.Shared.Audio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Server.Nuke
 {
@@ -36,13 +38,6 @@ namespace Content.Server.Nuke
         [DataField("diskSlot")]
         public ItemSlot DiskSlot = new();
 
-        /// <summary>
-        ///     Annihilation radius in which  all human players will be gibed
-        /// </summary>
-        [DataField("blastRadius")]
-        [ViewVariables(VVAccess.ReadWrite)]
-        public int BlastRadius = 200;
-
         /// <summary>
         ///     After this time nuke will play last alert sound
         /// </summary>
@@ -67,6 +62,48 @@ namespace Content.Server.Nuke
         [DataField("disarmSound")]
         public SoundSpecifier DisarmSound = new SoundPathSpecifier("/Audio/Misc/notice2.ogg");
 
+        // These datafields here are duplicates of those in explosive component. But I'm hesitant to use explosive
+        // component, just in case at some point, somehow, when grenade crafting added in someone manages to wire up a
+        // proximity trigger or something to the nuke and set it off prematurely. I want to make sure they MEAN to set of
+        // the nuke.
+        #region ExplosiveComponent
+        /// <summary>
+        ///     The explosion prototype. This determines the damage types, the tile-break chance, and some visual
+        ///     information (e.g., the light that the explosion gives off).
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
+        public string ExplosionType = default!;
+
+        /// <summary>
+        ///     The maximum intensity the explosion can have on a single time. This limits the maximum damage and tile
+        ///     break chance the explosion can achieve at any given location.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("maxIntensity")]
+        public float MaxIntensity = 100;
+
+        /// <summary>
+        ///     How quickly the intensity drops off as you move away from the epicenter.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("intensitySlope")]
+        public float IntensitySlope = 5;
+
+        /// <summary>
+        ///     The total intensity of this explosion. The radius of the explosion scales like the cube root of this
+        ///     number (see <see cref="ExplosionSystem.RadiusToIntensity"/>).
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("totalIntensity")]
+        public float TotalIntensity = 100000;
+
+        /// <summary>
+        ///     Avoid somehow double-triggering this explosion.
+        /// </summary>
+        public bool Exploded;
+        #endregion
+
         /// <summary>
         ///     Time until explosion in seconds.
         /// </summary>
diff --git a/Content.Server/Nuke/NukeSystem.cs b/Content.Server/Nuke/NukeSystem.cs
index 0da655b40c..2a26ac9a77 100644
--- a/Content.Server/Nuke/NukeSystem.cs
+++ b/Content.Server/Nuke/NukeSystem.cs
@@ -1,10 +1,10 @@
 using Content.Server.Chat.Managers;
 using Content.Server.Construction.Components;
 using Content.Server.Coordinates.Helpers;
+using Content.Server.Explosion.EntitySystems;
 using Content.Server.Popups;
 using Content.Server.UserInterface;
 using Content.Shared.Audio;
-using Content.Shared.Body.Components;
 using Content.Shared.Containers.ItemSlots;
 using Content.Shared.Nuke;
 using Content.Shared.Sound;
@@ -19,7 +19,7 @@ namespace Content.Server.Nuke
         [Dependency] private readonly NukeCodeSystem _codes = default!;
         [Dependency] private readonly ItemSlotsSystem _itemSlots = default!;
         [Dependency] private readonly PopupSystem _popups = default!;
-        [Dependency] private readonly EntityLookupSystem _lookup = default!;
+        [Dependency] private readonly ExplosionSystem _explosions = default!;
         [Dependency] private readonly IChatManager _chat = default!;
 
         public override void Initialize()
@@ -397,19 +397,16 @@ namespace Content.Server.Nuke
             if (!Resolve(uid, ref component, ref transform))
                 return;
 
-            // gib anyone in a blast radius
-            // its lame, but will work for now
-            var pos = transform.Coordinates;
-            var ents = _lookup.GetEntitiesInRange(pos, component.BlastRadius);
-            foreach (var ent in ents)
-            {
-                var entUid = ent;
-                if (!EntityManager.EntityExists(entUid))
-                    continue;
+            if (component.Exploded)
+                return;
 
-                if (EntityManager.TryGetComponent(entUid, out SharedBodyComponent? body))
-                    body.Gib();
-            }
+            component.Exploded = true;
+
+            _explosions.QueueExplosion(uid,
+                component.ExplosionType,
+                component.TotalIntensity,
+                component.IntensitySlope,
+                component.MaxIntensity);
 
             EntityManager.DeleteEntity(uid);
         }
diff --git a/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs b/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs
index f0cda35540..d633840418 100644
--- a/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs
+++ b/Content.Server/Pointing/Components/RoguePointingArrowComponent.cs
@@ -1,6 +1,5 @@
 using Content.Server.Pointing.EntitySystems;
 using Content.Shared.Pointing.Components;
-using Content.Shared.Sound;
 using Robust.Shared.Analyzers;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -26,8 +25,5 @@ namespace Content.Server.Pointing.Components
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("chasingTime")]
         public float ChasingTime = 1;
-
-        [DataField("explosionSound")]
-        public SoundSpecifier ExplosionSound = new SoundCollectionSpecifier("explosion");
     }
 }
diff --git a/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs b/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs
index 3bfea1b949..a50422daeb 100644
--- a/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs
+++ b/Content.Server/Pointing/EntitySystems/RoguePointingSystem.cs
@@ -5,7 +5,6 @@ using Content.Shared.MobState.Components;
 using Content.Shared.Pointing.Components;
 using JetBrains.Annotations;
 using Robust.Server.GameObjects;
-using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
@@ -19,8 +18,7 @@ namespace Content.Server.Pointing.EntitySystems
     internal sealed class RoguePointingSystem : EntitySystem
     {
         [Dependency] private readonly IRobustRandom _random = default!;
-
-        [Dependency] private readonly ExplosionSystem _explosions = default!;
+        [Dependency] private readonly ExplosionSystem _explosion = default!;
 
         public override void Initialize()
         {
@@ -103,10 +101,7 @@ namespace Content.Server.Pointing.EntitySystems
                 {
                     return;
                 }
-
-                _explosions.SpawnExplosion(uid, 0, 2, 1, 1);
-                SoundSystem.Play(Filter.Pvs(uid, entityManager: EntityManager), component.ExplosionSound.GetSound(), uid);
-
+                _explosion.QueueExplosion(uid, "Default", 50, 3, 10);
                 EntityManager.QueueDeleteEntity(uid);
             }
         }
diff --git a/Content.Server/PowerCell/PowerCellSystem.cs b/Content.Server/PowerCell/PowerCellSystem.cs
index dacbe9be0f..b0e55f1170 100644
--- a/Content.Server/PowerCell/PowerCellSystem.cs
+++ b/Content.Server/PowerCell/PowerCellSystem.cs
@@ -88,10 +88,10 @@ public sealed class PowerCellSystem : SharedPowerCellSystem
         if (!Resolve(uid, ref battery))
             return;
 
-        var heavy = (int) Math.Ceiling(Math.Sqrt(battery.CurrentCharge) / 60);
-        var light = (int) Math.Ceiling(Math.Sqrt(battery.CurrentCharge) / 30);
+        var radius = MathF.Min(5, MathF.Ceiling(MathF.Sqrt(battery.CurrentCharge) / 30));
+        battery.CurrentCharge = 0;
 
-        _explosionSystem.SpawnExplosion(uid, 0, heavy, light, light * 2);
+        _explosionSystem.TriggerExplosive(uid, radius: radius);
         QueueDel(uid);
     }
 
diff --git a/Content.Server/Storage/Components/EntityStorageComponent.cs b/Content.Server/Storage/Components/EntityStorageComponent.cs
index bee8ec4a0e..23499a88d5 100644
--- a/Content.Server/Storage/Components/EntityStorageComponent.cs
+++ b/Content.Server/Storage/Components/EntityStorageComponent.cs
@@ -35,7 +35,7 @@ namespace Content.Server.Storage.Components
     [Virtual]
     [ComponentReference(typeof(IActivate))]
     [ComponentReference(typeof(IStorageComponent))]
-    public class EntityStorageComponent : Component, IActivate, IStorageComponent, IInteractUsing, IDestroyAct, IExAct
+    public class EntityStorageComponent : Component, IActivate, IStorageComponent, IInteractUsing, IDestroyAct
     {
         [Dependency] private readonly IEntityManager _entMan = default!;
 
@@ -478,24 +478,6 @@ namespace Content.Server.Storage.Components
             var entityLookup = EntitySystem.Get<EntityLookupSystem>();
             return entityLookup.GetEntitiesIntersecting(Owner, _enteringRange, LookupFlags.Approximate);
         }
-
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            if (eventArgs.Severity < ExplosionSeverity.Heavy)
-            {
-                return;
-            }
-
-            var containedEntities = Contents.ContainedEntities.ToList();
-            foreach (var entity in containedEntities)
-            {
-                var exActs = _entMan.GetComponents<IExAct>(entity).ToArray();
-                foreach (var exAct in exActs)
-                {
-                    exAct.OnExplosion(eventArgs);
-                }
-            }
-        }
     }
 
     public sealed class StorageOpenAttemptEvent : CancellableEntityEventArgs
diff --git a/Content.Server/Storage/Components/ServerStorageComponent.cs b/Content.Server/Storage/Components/ServerStorageComponent.cs
index 9d22e21338..a7f79a3477 100644
--- a/Content.Server/Storage/Components/ServerStorageComponent.cs
+++ b/Content.Server/Storage/Components/ServerStorageComponent.cs
@@ -43,7 +43,7 @@ namespace Content.Server.Storage.Components
     [ComponentReference(typeof(IActivate))]
     [ComponentReference(typeof(IStorageComponent))]
     [ComponentReference(typeof(SharedStorageComponent))]
-    public sealed class ServerStorageComponent : SharedStorageComponent, IInteractUsing, IActivate, IStorageComponent, IDestroyAct, IExAct, IAfterInteract
+    public sealed class ServerStorageComponent : SharedStorageComponent, IInteractUsing, IActivate, IStorageComponent, IDestroyAct, IAfterInteract
     {
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
@@ -667,30 +667,6 @@ namespace Content.Server.Storage.Components
             }
         }
 
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            if (eventArgs.Severity < ExplosionSeverity.Heavy)
-            {
-                return;
-            }
-
-            var storedEntities = StoredEntities?.ToList();
-
-            if (storedEntities == null)
-            {
-                return;
-            }
-
-            foreach (var entity in storedEntities)
-            {
-                var exActs = _entityManager.GetComponents<IExAct>(entity).ToArray();
-                foreach (var exAct in exActs)
-                {
-                    exAct.OnExplosion(eventArgs);
-                }
-            }
-        }
-
         private void PlaySoundCollection()
         {
             SoundSystem.Play(Filter.Pvs(Owner), StorageSoundCollection.GetSound(), Owner, AudioParams.Default);
diff --git a/Content.Shared/Acts/ActSystem.cs b/Content.Shared/Acts/ActSystem.cs
index 03add7917d..7527db0678 100644
--- a/Content.Shared/Acts/ActSystem.cs
+++ b/Content.Shared/Acts/ActSystem.cs
@@ -29,21 +29,6 @@ namespace Content.Shared.Acts
         void OnBreak(BreakageEventArgs eventArgs);
     }
 
-    public interface IExAct
-    {
-        /// <summary>
-        /// Called when explosion reaches the entity
-        /// </summary>
-        void OnExplosion(ExplosionEventArgs eventArgs);
-    }
-
-    public sealed class ExplosionEventArgs : EventArgs
-    {
-        public EntityCoordinates Source { get; set; }
-        public EntityUid Target { get; set; }
-        public ExplosionSeverity Severity { get; set; }
-    }
-
     [UsedImplicitly]
     public sealed class ActSystem : EntitySystem
     {
@@ -59,23 +44,7 @@ namespace Content.Shared.Acts
                 destroyAct.OnDestroy(eventArgs);
             }
 
-            EntityManager.QueueDeleteEntity(owner);
-        }
-
-        public void HandleExplosion(EntityCoordinates source, EntityUid target, ExplosionSeverity severity)
-        {
-            var eventArgs = new ExplosionEventArgs
-            {
-                Source = source,
-                Target = target,
-                Severity = severity
-            };
-            var exActs = EntityManager.GetComponents<IExAct>(target).ToList();
-
-            foreach (var exAct in exActs)
-            {
-                exAct.OnExplosion(eventArgs);
-            }
+            QueueDel(owner);
         }
 
         public void HandleBreakage(EntityUid owner)
@@ -89,11 +58,4 @@ namespace Content.Shared.Acts
             }
         }
     }
-
-    public enum ExplosionSeverity
-    {
-        Light,
-        Heavy,
-        Destruction,
-    }
 }
diff --git a/Content.Shared/Administration/SpawnExplosionEuiMsg.cs b/Content.Shared/Administration/SpawnExplosionEuiMsg.cs
new file mode 100644
index 0000000000..f9011bda30
--- /dev/null
+++ b/Content.Shared/Administration/SpawnExplosionEuiMsg.cs
@@ -0,0 +1,52 @@
+using Content.Shared.Eui;
+using Robust.Shared.Serialization;
+using Robust.Shared.Map;
+using Content.Shared.Explosion;
+
+namespace Content.Shared.Administration;
+
+public static class SpawnExplosionEuiMsg
+{
+    [Serializable, NetSerializable]
+    public sealed class Close : EuiMessageBase { }
+
+    /// <summary>
+    ///     This message is sent to the server to request explosion preview data.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public sealed class PreviewRequest : EuiMessageBase
+    {
+        public readonly MapCoordinates Epicenter;
+        public readonly string TypeId;
+        public readonly float TotalIntensity;
+        public readonly float IntensitySlope;
+        public readonly float MaxIntensity;
+
+        public PreviewRequest(MapCoordinates epicenter, string typeId, float totalIntensity, float intensitySlope, float maxIntensity)
+        {
+            Epicenter = epicenter;
+            TypeId = typeId;
+            TotalIntensity = totalIntensity;
+            IntensitySlope = intensitySlope;
+            MaxIntensity = maxIntensity;
+        }
+    }
+
+    /// <summary>
+    ///     This message is used to send explosion-preview data to the client.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public sealed class PreviewData : EuiMessageBase
+    {
+        public readonly float Slope;
+        public readonly float TotalIntensity;
+        public readonly ExplosionEvent Explosion;
+
+        public PreviewData(ExplosionEvent explosion, float slope, float totalIntensity)
+        {
+            Slope = slope;
+            TotalIntensity = totalIntensity;
+            Explosion = explosion;
+        }
+    }
+}
diff --git a/Content.Shared/CCVar/CCVars.cs b/Content.Shared/CCVar/CCVars.cs
index 5e0e20d96a..202f7413a2 100644
--- a/Content.Shared/CCVar/CCVars.cs
+++ b/Content.Shared/CCVar/CCVars.cs
@@ -348,6 +348,85 @@ namespace Content.Shared.CCVar
         public static readonly CVarDef<bool> AdminAnnounceLogout =
             CVarDef.Create("admin.announce_logout", true, CVar.SERVERONLY);
 
+        /*
+         * Explosions
+         */
+
+        /// <summary>
+        ///     How many tiles the explosion system will process per tick
+        /// </summary>
+        /// <remarks>
+        ///     Setting this too high will put a large load on a single tick. Setting this  too low will lead to
+        ///     unnaturally "slow" explosions.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionTilesPerTick =
+            CVarDef.Create("explosion.tilespertick", 100, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Upper limit on the size of an explosion before physics-throwing is disabled.
+        /// </summary>
+        /// <remarks>
+        ///     Large nukes tend to generate a lot of shrapnel that flies through space. This can functionally cripple
+        ///     the server TPS for a while after an explosion (or even during, if the explosion is processed
+        ///     incrementally. 
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionThrowLimit =
+            CVarDef.Create("explosion.throwlimit", 400, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     If this is true, explosion processing will pause the NodeGroupSystem to pause updating.
+        /// </summary>
+        /// <remarks>
+        ///     This only takes effect if an explosion needs more than one tick to process (i.e., covers more than <see
+        ///     cref="ExplosionTilesPerTick"/> tiles). If this is not enabled, the node-system will rebuild its graph
+        ///     every tick as the explosion shreds the station, causing significant slowdown.
+        /// </remarks>
+        public static readonly CVarDef<bool> ExplosionSleepNodeSys =
+            CVarDef.Create("explosion.nodesleep", true, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Upper limit on the total area that an explosion can affect before the neighbor-finding algorithm just
+        ///     stops. Defaults to a 60-rile radius explosion.
+        /// </summary>
+        /// <remarks>
+        ///     Actual area may be larger, as it currently doesn't terminate mid neighbor finding. I.e., area may be that of a ~51 tile radius circle instead.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionMaxArea =
+            CVarDef.Create("explosion.maxarea", (int) 3.14f * 50 * 50, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Upper limit on the number of neighbor finding steps for the explosion system neighbor-finding algorithm.
+        /// </summary>
+        /// <remarks>
+        ///     Effectively places an upper limit on the range that any explosion can have. In the vast majority of
+        ///     instances, <see cref="ExplosionMaxArea"/> will likely be hit before this becomes a limiting factor.
+        /// </remarks>
+        public static readonly CVarDef<int> ExplosionMaxIterations =
+            CVarDef.Create("explosion.maxiterations", 150, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Max Time in milliseconds to spend processing explosions every tick.
+        /// </summary>
+        /// <remarks>
+        ///     This time limiting is not perfectly implemented. Firstly, a significant chunk of processing time happens
+        ///     due to queued entity deletions, which happen outside of the system update code. Secondly, explosion
+        ///     spawning cannot currently be interrupted & resumed, and may lead to exceeding this time limit.
+        /// </remarks>
+        public static readonly CVarDef<float> ExplosionMaxProcessingTime =
+            CVarDef.Create("explosion.maxtime", 7f, CVar.SERVERONLY);
+
+        /// <summary>
+        ///     If the explosion is being processed incrementally over several ticks, this variable determines whether
+        ///     updating the grid tiles should be done incrementally at the end of every tick, or only once the explosion has finished processing.
+        /// </summary>
+        /// <remarks>
+        ///     The most notable consequence of this change is that explosions will only punch a hole in the station &
+        ///     create a vacumm once they have finished exploding. So airlocks will no longer slam shut as the explosion
+        ///     expands, just suddenly at the end.
+        /// </remarks>
+        public static readonly CVarDef<bool> ExplosionIncrementalTileBreaking =
+            CVarDef.Create("explosion.incrementaltile", false, CVar.SERVERONLY);
+
         /*
          * Admin logs
          */
diff --git a/Content.Shared/Damage/Components/DamageableComponent.cs b/Content.Shared/Damage/Components/DamageableComponent.cs
index 01ef07abdc..e130c9889f 100644
--- a/Content.Shared/Damage/Components/DamageableComponent.cs
+++ b/Content.Shared/Damage/Components/DamageableComponent.cs
@@ -25,7 +25,7 @@ namespace Content.Shared.Damage
     [RegisterComponent]
     [NetworkedComponent()]
     [Friend(typeof(DamageableSystem))]
-    public sealed class DamageableComponent : Component, IRadiationAct, IExAct
+    public sealed class DamageableComponent : Component, IRadiationAct
     {
         /// <summary>
         ///     This <see cref="DamageContainerPrototype"/> specifies what damage types are supported by this component.
@@ -92,27 +92,6 @@ namespace Content.Shared.Damage
 
             EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner, damage);
         }
-
-        // TODO EXPLOSION Remove this.
-        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-        {
-            var damageValue = eventArgs.Severity switch
-            {
-                ExplosionSeverity.Light => FixedPoint2.New(20),
-                ExplosionSeverity.Heavy => FixedPoint2.New(60),
-                ExplosionSeverity.Destruction => FixedPoint2.New(250),
-                _ => throw new ArgumentOutOfRangeException()
-            };
-
-            // Explosion should really just be a damage group instead of a list of types.
-            DamageSpecifier damage = new();
-            foreach (var typeID in ExplosionDamageTypeIDs)
-            {
-                damage.DamageDict.Add(typeID, damageValue);
-            }
-
-            EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner, damage);
-        }
     }
 
     [Serializable, NetSerializable]
diff --git a/Content.Shared/Explosion/ExplosionEvents.cs b/Content.Shared/Explosion/ExplosionEvents.cs
new file mode 100644
index 0000000000..876beff3ed
--- /dev/null
+++ b/Content.Shared/Explosion/ExplosionEvents.cs
@@ -0,0 +1,81 @@
+using Content.Shared.Inventory;
+using Robust.Shared.Map;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Explosion;
+
+/// <summary>
+///     Raised directed at an entity to determine its explosion resistance, probably right before it is about to be
+///     damaged by one.
+/// </summary>
+public class GetExplosionResistanceEvent : EntityEventArgs, IInventoryRelayEvent
+{
+    /// <summary>
+    ///     Can be set to whatever, but currently is being additively increased by components & clothing. So think twice
+    ///     before multiplying or directly setting this.
+    /// </summary>
+    public float Resistance = 0;
+
+    public readonly string ExplotionPrototype;
+
+    SlotFlags IInventoryRelayEvent.TargetSlots =>  ~SlotFlags.POCKET;
+
+    public GetExplosionResistanceEvent(string id)
+    {
+        ExplotionPrototype = id;
+    }
+}
+
+/// <summary>
+///     An explosion event. Used for client side rendering.
+/// </summary>
+[Serializable, NetSerializable]
+public class ExplosionEvent : EntityEventArgs
+{
+    public MapCoordinates Epicenter;
+
+    public Dictionary<int, List<Vector2i>>? SpaceTiles;
+    public Dictionary<GridId, Dictionary<int, List<Vector2i>>> Tiles;
+
+    public List<float> Intensity;
+
+    public string TypeID;
+
+    public Matrix3 SpaceMatrix;
+
+    public byte ExplosionId;
+
+    public ExplosionEvent(
+        byte explosionId,
+        MapCoordinates epicenter,
+        string typeID,
+        List<float> intensity,
+        Dictionary<int, List<Vector2i>>? spaceTiles,
+        Dictionary<GridId, Dictionary<int, List<Vector2i>>> tiles,
+        Matrix3 spaceMatrix)
+    {
+        Epicenter = epicenter;
+        SpaceTiles = spaceTiles;
+        Tiles = tiles;
+        Intensity = intensity;
+        TypeID = typeID;
+        SpaceMatrix = spaceMatrix;
+        ExplosionId = explosionId;
+    }
+}
+
+/// <summary>
+///     Update visual rendering of the explosion to correspond to the servers processing of it.
+/// </summary>
+[Serializable, NetSerializable]
+public class ExplosionOverlayUpdateEvent : EntityEventArgs
+{
+    public int Index;
+    public byte ExplosionId;
+
+    public ExplosionOverlayUpdateEvent(byte explosionId, int index)
+    {
+        Index = index;
+        ExplosionId = explosionId;
+    }
+}
diff --git a/Content.Shared/Explosion/ExplosionPrototype.cs b/Content.Shared/Explosion/ExplosionPrototype.cs
new file mode 100644
index 0000000000..f846a185ec
--- /dev/null
+++ b/Content.Shared/Explosion/ExplosionPrototype.cs
@@ -0,0 +1,89 @@
+using Content.Shared.Damage;
+using Content.Shared.Sound;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Explosion;
+
+[Prototype("explosion")]
+public sealed class ExplosionPrototype : IPrototype
+{
+    [DataField("id", required: true)]
+    public string ID { get; } = default!;
+
+    /// <summary>
+    ///     Damage to deal to entities. This is scaled by the explosion intensity.
+    /// </summary>
+    [DataField("damagePerIntensity", required: true)]
+    public readonly DamageSpecifier DamagePerIntensity = default!;
+
+    /// <summary>
+    ///     This set of points, together with <see cref="_tileBreakIntensity"/> define a function that maps the
+    ///     explosion intensity to a tile break chance via linear interpolation. 
+    /// </summary>
+    [DataField("tileBreakChance")]
+    private readonly float[] _tileBreakChance = { 0f, 1f };
+
+    /// <summary>
+    ///     This set of points, together with <see cref="_tileBreakChance"/> define a function that maps the
+    ///     explosion intensity to a tile break chance via linear interpolation. 
+    /// </summary>
+    [DataField("tileBreakIntensity")]
+    private readonly float[] _tileBreakIntensity = {0f, 15f };
+
+    /// <summary>
+    ///     When a tile is broken by an explosion, the intensity is reduced by this amount and is used to try and
+    ///     break the tile a second time. This is repeated until a roll fails or the tile has become space.
+    /// </summary>
+    /// <remarks>
+    ///     If this number is too small, even relatively weak explosions can have a non-zero
+    ///     chance to create a space tile.
+    /// </remarks>
+    [DataField("tileBreakRerollReduction")]
+    public readonly float TileBreakRerollReduction = 10f;
+
+    /// <summary>
+    ///     Color emitted by a point light at the center of the explosion.
+    /// </summary>
+    [DataField("lightColor")]
+    public readonly Color LightColor = Color.Orange;
+
+    /// <summary>
+    ///     Color used to modulate the fire texture.
+    /// </summary>
+    [DataField("fireColor")]
+    public readonly Color? FireColor;
+
+    [DataField("Sound")]
+    public readonly SoundSpecifier Sound = new SoundCollectionSpecifier("explosion");
+
+    [DataField("texturePath")]
+    public readonly string TexturePath = "/Textures/Effects/fire.rsi";
+
+    // Theres probably a better way to do this. Currently Atmos just hard codes a constant int, so I have no one to
+    // steal code from.
+    [DataField("fireStates")]
+    public readonly int FireStates = 3;
+
+    /// <summary>
+    ///     Basic function for linear interpolation of _tileBreakChance and _tileBreakIntensity
+    /// </summary>
+    public float TileBreakChance(float intensity)
+    {
+        if (_tileBreakChance.Length == 0 || _tileBreakChance.Length != _tileBreakIntensity.Length)
+        {
+            Logger.Error($"Malformed tile break chance definitions for explosion prototype: {ID}");
+            return 0;
+        }
+
+        if (intensity >= _tileBreakIntensity[^1] || _tileBreakIntensity.Length == 1)
+            return _tileBreakChance[^1];
+
+        if (intensity <= _tileBreakIntensity[0])
+            return _tileBreakChance[0];
+
+        int i = Array.FindIndex(_tileBreakIntensity, k => k >= intensity);
+
+        var slope = (_tileBreakChance[i] - _tileBreakChance[i - 1]) / (_tileBreakIntensity[i] - _tileBreakIntensity[i - 1]);
+        return _tileBreakChance[i - 1] + slope * (intensity - _tileBreakIntensity[i - 1]);
+    }
+}
diff --git a/Content.Shared/FixedPoint/FixedPoint2.cs b/Content.Shared/FixedPoint/FixedPoint2.cs
index e6a3dcdb53..180bbf9893 100644
--- a/Content.Shared/FixedPoint/FixedPoint2.cs
+++ b/Content.Shared/FixedPoint/FixedPoint2.cs
@@ -234,6 +234,11 @@ namespace Content.Shared.FixedPoint
                    _value == unit._value;
         }
 
+        public bool EqualsApprox(FixedPoint2 other, FixedPoint2 tolerance)
+        {
+            return Math.Abs(_value - other._value) < tolerance._value;
+        }
+
         public override readonly int GetHashCode()
         {
             // ReSharper disable once NonReadonlyMemberInGetHashCode
diff --git a/Content.Shared/Inventory/InventoryComponent.cs b/Content.Shared/Inventory/InventoryComponent.cs
index fd1959e62c..79bead9873 100644
--- a/Content.Shared/Inventory/InventoryComponent.cs
+++ b/Content.Shared/Inventory/InventoryComponent.cs
@@ -1,38 +1,10 @@
-using System.Linq;
-using Content.Shared.Acts;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Shared.Inventory;
 
-public abstract class InventoryComponent : Component, IExAct
+public abstract class InventoryComponent : Component
 {
-    [Dependency] private readonly IEntityManager _entityManager = default!;
-
     [DataField("templateId", required: true,
         customTypeSerializer: typeof(PrototypeIdSerializer<InventoryTemplatePrototype>))]
     public string TemplateId { get; } = "human";
-
-    void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
-    {
-        if (eventArgs.Severity < ExplosionSeverity.Heavy)
-        {
-            return;
-        }
-
-        if (EntitySystem.Get<InventorySystem>()
-            .TryGetContainerSlotEnumerator(Owner, out var enumerator, this))
-        {
-            while (enumerator.MoveNext(out var container))
-            {
-                if (!container.ContainedEntity.HasValue) continue;
-                foreach (var exAct in _entityManager.GetComponents<IExAct>(container.ContainedEntity.Value).ToArray())
-                {
-                    exAct.OnExplosion(eventArgs);
-                }
-            }
-        }
-    }
 }
diff --git a/Content.Shared/Inventory/InventorySystem.Relay.cs b/Content.Shared/Inventory/InventorySystem.Relay.cs
index 7b473f3b07..6cbe1a7e6f 100644
--- a/Content.Shared/Inventory/InventorySystem.Relay.cs
+++ b/Content.Shared/Inventory/InventorySystem.Relay.cs
@@ -1,8 +1,8 @@
-using Content.Shared.Damage;
+using Content.Shared.Damage;
 using Content.Shared.Electrocution;
+using Content.Shared.Explosion;
 using Content.Shared.Movement.EntitySystems;
 using Content.Shared.Slippery;
-using Robust.Shared.GameObjects;
 
 namespace Content.Shared.Inventory;
 
@@ -14,6 +14,7 @@ public partial class InventorySystem
         SubscribeLocalEvent<InventoryComponent, ElectrocutionAttemptEvent>(RelayInventoryEvent);
         SubscribeLocalEvent<InventoryComponent, SlipAttemptEvent>(RelayInventoryEvent);
         SubscribeLocalEvent<InventoryComponent, RefreshMovementSpeedModifiersEvent>(RelayInventoryEvent);
+        SubscribeLocalEvent<InventoryComponent, GetExplosionResistanceEvent>(RelayInventoryEvent);
     }
 
     protected void RelayInventoryEvent<T>(EntityUid uid, InventoryComponent component, T args) where T : EntityEventArgs, IInventoryRelayEvent
diff --git a/Resources/Audio/Effects/explosion1.ogg b/Resources/Audio/Effects/explosion1.ogg
index 14df2c88cc..622702912c 100644
Binary files a/Resources/Audio/Effects/explosion1.ogg and b/Resources/Audio/Effects/explosion1.ogg differ
diff --git a/Resources/Audio/Effects/explosion2.ogg b/Resources/Audio/Effects/explosion2.ogg
index 4c74233720..147049c6fd 100644
Binary files a/Resources/Audio/Effects/explosion2.ogg and b/Resources/Audio/Effects/explosion2.ogg differ
diff --git a/Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl b/Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl
new file mode 100644
index 0000000000..85f4a065f4
--- /dev/null
+++ b/Resources/Locale/en-US/administration/ui/admin-spawn-explosion-eui.ftl
@@ -0,0 +1,16 @@
+admin-explosion-eui-title = Spawn Explosions
+
+admin-explosion-eui-label-type = Explosion Type
+admin-explosion-eui-label-mapid = Map ID
+admin-explosion-eui-label-xmap = X (Map)
+admin-explosion-eui-label-ymap = Y (Map)
+admin-explosion-eui-label-current = Current Position
+admin-explosion-eui-label-preview = Preview
+admin-explosion-eui-label-total = Total Intensity
+admin-explosion-eui-label-slope = Intensity Slope
+admin-explosion-eui-label-max = Max Intensity
+admin-explosion-eui-label-directional = Directional
+admin-explosion-eui-label-angle = Angle
+admin-explosion-eui-label-spread = Spread
+admin-explosion-eui-label-distance = Distance
+admin-explosion-eui-label-spawn = Kabloom!
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Clothing/Head/helmets.yml b/Resources/Prototypes/Entities/Clothing/Head/helmets.yml
index bd6b2be6d5..728d38ee90 100644
--- a/Resources/Prototypes/Entities/Clothing/Head/helmets.yml
+++ b/Resources/Prototypes/Entities/Clothing/Head/helmets.yml
@@ -9,6 +9,8 @@
   - type: Clothing
     sprite: Clothing/Head/Helmets/bombsuit.rsi
   - type: IngestionBlocker
+  - type: ExplosionResistance
+    resistance: 0.25 # +0.65 from body -> 90%
 
 - type: entity
   parent: ClothingHeadBase
diff --git a/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml b/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml
index 61bec73c34..2881b2555b 100644
--- a/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml
+++ b/Resources/Prototypes/Entities/Clothing/OuterClothing/suits.yml
@@ -8,13 +8,15 @@
     sprite: Clothing/OuterClothing/Suits/bombsuit.rsi
   - type: Clothing
     sprite: Clothing/OuterClothing/Suits/bombsuit.rsi
-  - type: Armor
+  - type: Armor #explosion damage ignores "normal" armor, see ExplosionResistance.
     modifiers:
       coefficients:
-        Blunt: 0.2 #big blast protection, a little protection from heat, negligable cushioning from other damage cos its thick
+        Blunt: 0.5
         Slash: 0.9
         Piercing: 0.9
         Heat: 0.75
+  - type: ExplosionResistance
+    resistance: 0.65 # +0.25 from helmet -> 90%
 
 - type: entity
   parent: ClothingOuterBase
diff --git a/Resources/Prototypes/Entities/Effects/explosion_light.yml b/Resources/Prototypes/Entities/Effects/explosion_light.yml
new file mode 100644
index 0000000000..378e65ffcc
--- /dev/null
+++ b/Resources/Prototypes/Entities/Effects/explosion_light.yml
@@ -0,0 +1,9 @@
+- type: entity
+  abstract: true
+  id: ExplosionLight
+  name: explosion light
+  components:
+  - type: PointLight
+  - type: Tag
+    tags:
+    - HideContextMenu
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Objects/Devices/nuke.yml b/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
index c8d9e04311..9b1cb01359 100644
--- a/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
+++ b/Resources/Prototypes/Entities/Objects/Devices/nuke.yml
@@ -21,6 +21,11 @@
         layer:
         - SmallImpassable
     - type: Nuke
+      # ~35 tile radius in open space
+      explosionType: Default
+      maxIntensity: 100
+      intensitySlope: 5
+      totalIntensity: 200000
       diskSlot:
         name: Disk
         insertSound:
diff --git a/Resources/Prototypes/Entities/Objects/Power/powercells.yml b/Resources/Prototypes/Entities/Objects/Power/powercells.yml
index 1f24bed06b..4b003edaf3 100644
--- a/Resources/Prototypes/Entities/Objects/Power/powercells.yml
+++ b/Resources/Prototypes/Entities/Objects/Power/powercells.yml
@@ -8,6 +8,8 @@
   components:
   - type: Battery
   - type: PowerCell
+  - type: Explosive
+    explosionType: Default
   - type: Sprite
     netsync: false
   - type: SolutionContainerManager
diff --git a/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml b/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
index 994624e7b3..626ba8efcc 100644
--- a/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
+++ b/Resources/Prototypes/Entities/Objects/Tools/gas_tanks.yml
@@ -21,6 +21,9 @@
       icon: Interface/Actions/internal0.png
       iconOn: Interface/Actions/internal1.png
       event: !type:ToggleActionEvent
+  - type: Explosive
+    explosionType: Default
+    maxIntensity: 20
 
 - type: entity
   parent: GasTankBase
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
index 1e2dff0db4..31f7405f08 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/meteors.yml
@@ -18,10 +18,12 @@
     damage: {}
     deleteOnCollide: false
   - type: Explosive
-    devastationRange: 3
-    heavyImpactRange: 5
-    lightImpactRange: 7
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 2000.0
+    intensitySlope: 20
+    maxIntensity: 60 
+    # should be enough to kill reinforced walls, so meteors are actually a problem for the station.
+    # though maybe reinforced walls should just be nerfed?
   - type: Physics
     bodyType: Dynamic
     fixedRotation: false
@@ -29,7 +31,7 @@
     fixtures:
     - shape:
         !type:PhysShapeCircle
-          radius: 0.5
+          radius: 1.0
       mass: 200
       hard: true
       # Didn't use MapGrid for now as the bounds are stuffed.
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
index 04bc34c0a2..1ccc31f5b6 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Guns/Projectiles/projectiles.yml
@@ -187,10 +187,10 @@
     state: frag
   - type: ExplodeOnTrigger
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 2
-    lightImpactRange: 4
-    flashRange: 10
+    explosionType: Default
+    maxIntensity: 50
+    intensitySlope: 7.5
+    totalIntensity: 300
   - type: PointLight
     radius: 3.5
     color: orange
@@ -229,10 +229,9 @@
     state: grenade
   - type: ExplodeOnTrigger
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 2
-    lightImpactRange: 7
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 500 # a ~7 tile radius. This is pretty big.
+    maxIntensity: 10 # caps at 150 damage
 
 - type: entity
   id: BulletGrenadeFlash
@@ -260,10 +259,8 @@
     state: grenade
   - type: ExplodeOnTrigger
   - type: Explosive
-    devastationRange: 0
-    heavyImpactRange: 1
-    lightImpactRange: 4
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 64 # about a ~4 tile radius
 
 - type: entity
   id: BulletFoam
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml b/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml
index eaf25ef0d3..60b5d2dce6 100644
--- a/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Throwable/grenades.yml
@@ -18,10 +18,10 @@
   - type: OnUseTimerTrigger
     delay: 3.5
   - type: Explosive
-    devastationRange: 0
-    heavyImpactRange: 2
-    lightImpactRange: 4
-    flashRange: 7
+    explosionType: Default
+    maxIntensity: 10
+    intensitySlope: 3
+    totalIntensity: 120 # about a ~4 tile radius
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
@@ -94,10 +94,10 @@
   - type: OnUseTimerTrigger
     delay: 5
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 3
-    lightImpactRange: 5
-    flashRange: 10
+    explosionType: Default
+    totalIntensity: 400
+    intensitySlope: 3
+    maxIntensity: 20
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
@@ -129,9 +129,10 @@
   - type: OnUseTimerTrigger
     delay: 5
   - type: Explosive
-    devastationRange: 25
-    heavyImpactRange: 25
-    flashRange: 50
+    explosionType: Default
+    totalIntensity: 20000 # ~15 tile radius.
+    intensitySlope: 5
+    maxIntensity: 50
   - type: ExplodeOnTrigger
   - type: Damageable
     damageContainer: Inorganic
diff --git a/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml b/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
index 541ffb4f8f..c42a620496 100644
--- a/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
+++ b/Resources/Prototypes/Entities/Structures/Power/Generation/ame.yml
@@ -46,6 +46,10 @@
   - type: Anchorable
   - type: Pullable
   - type: AMEController
+  - type: Explosive
+    explosionType: Default
+    intensitySlope: 5
+    maxIntensity: 60
   - type: UserInterface
     interfaces:
     - key: enum.AMEControllerUiKey.Key
diff --git a/Resources/Prototypes/Entities/Structures/Power/substation.yml b/Resources/Prototypes/Entities/Structures/Power/substation.yml
index 970aa1be1f..57d68ccbc9 100644
--- a/Resources/Prototypes/Entities/Structures/Power/substation.yml
+++ b/Resources/Prototypes/Entities/Structures/Power/substation.yml
@@ -64,10 +64,10 @@
             min: 1
             max: 1
   - type: Explosive
-    devastationRange: 1
-    heavyImpactRange: 3
-    lightImpactRange: 5
-    flashRange: 6
+    explosionType: Default
+    maxIntensity: 100
+    intensitySlope: 2
+    totalIntensity: 200
   - type: Wires
     BoardName: "Substation"
     LayoutId: Substation
diff --git a/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml b/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml
index 1537a5bc08..21fc05f9ee 100644
--- a/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml
+++ b/Resources/Prototypes/Entities/Structures/Storage/Closets/Lockers/lockers.yml
@@ -167,6 +167,8 @@
       state_closed: freezer_door
   - type: AccessReader
     access: [ [ "Kitchen" ] ]
+  - type: ExplosionResistance
+    resistance: 0.90
 
 # Botanist
 - type: entity
diff --git a/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml b/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml
index c3eceef59b..ef8e2f5bfe 100644
--- a/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml
+++ b/Resources/Prototypes/Entities/Structures/Storage/Tanks/tanks.yml
@@ -19,12 +19,8 @@
       types:
         Heat: 10
   - type: Explosive
-    # The explosive component is independent of the stored liquid :/
-    # I dream of a day where all grenades/explosives will be reagent dependent.
-    devastationRange: 0
-    heavyImpactRange: 2
-    lightImpactRange: 6
-    flashRange: 5
+    explosionType: Default
+    totalIntensity: 120 # ~ 5 tile radius
 
 - type: entity
   id: WeldingFuelTankFull
diff --git a/Resources/Prototypes/Entities/Structures/Walls/barricades.yml b/Resources/Prototypes/Entities/Structures/Walls/barricades.yml
index 5c1ab1a037..6028351e04 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/barricades.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/barricades.yml
@@ -23,7 +23,6 @@
       - SmallImpassable
   - type: Tag
     tags:
-    - ExplosivePassable
     - Wooden
   - type: Damageable
     damageModifierSet: Wood
diff --git a/Resources/Prototypes/Entities/Structures/Walls/girder.yml b/Resources/Prototypes/Entities/Structures/Walls/girder.yml
index d4433cc925..8c4724ae25 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/girder.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/girder.yml
@@ -25,9 +25,6 @@
   - type: Sprite
     sprite: Structures/Walls/solid.rsi
     state: wall_girder
-  - type: Tag
-    tags:
-    - ExplosivePassable
   - type: Damageable
     damageContainer: Inorganic
     damageModifierSet: Metallic
diff --git a/Resources/Prototypes/Recipes/Reactions/chemicals.yml b/Resources/Prototypes/Recipes/Reactions/chemicals.yml
index 0a0c663e71..92f882f8df 100644
--- a/Resources/Prototypes/Recipes/Reactions/chemicals.yml
+++ b/Resources/Prototypes/Recipes/Reactions/chemicals.yml
@@ -88,13 +88,11 @@
       amount: 1
   effects:
     - !type:ExplosionReactionEffect
-      #Ranges used when 1 potassium + 1 water react (A unit reaction)
-      devastationRange: 0.025
-      heavyImpactRange: 0.05
-      lightImpactRange: 0.075
-      flashRange: 0.1
-      scaled: true #Scaled proportionally to amount of potassium and water
-      maxScale: 20 #Explosion strength stops scaling at 20 potassium + 20 water
+      explosionType: Default
+      maxIntensity: 1 # at most 15 damage per tile
+      intensityPerUnit: 0.5 # 50+50 reagent for maximum explosion 
+      intensitySlope: 2
+      maxTotalIntensity: 25
 
 - type: reaction
   id: Smoke
diff --git a/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml b/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
index 62731c9062..66a0cd9d4d 100644
--- a/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
+++ b/Resources/Prototypes/Recipes/Reactions/pyrotechnic.yml
@@ -37,12 +37,14 @@
       amount: 3
   effects:
   # TODO electro's pretty explosions PR make this big and firey!!
+  # Welp its fiery now (low damage). Someone else needs to come in and define how big it should get & how it compares to potassium
   # TODO solution temperature!!
   - !type:ExplosionReactionEffect
-    devastationRange: 0
-    heavyImpactRange: 0
-    lightImpactRange: 2
-    scaled: false
+    explosionType: Default # 15 damage per intensity
+    maxIntensity: 2 # at most 30 damage per tile.
+    intensityPerUnit: 2 # 80 total input reagent units for max size
+    intensitySlope: 1
+    maxTotalIntensity: 40
   - !type:PopupMessage
     messages: [ "clf3-explosion" ]
     type: Pvs
diff --git a/Resources/Prototypes/explosion.yml b/Resources/Prototypes/explosion.yml
new file mode 100644
index 0000000000..9de6203fe2
--- /dev/null
+++ b/Resources/Prototypes/explosion.yml
@@ -0,0 +1,39 @@
+- type: explosion
+  id: Default
+  damagePerIntensity:
+    types:
+      Heat: 5
+      Blunt: 5
+      Piercing: 5
+  tileBreakChance: [0, 0.5, 1]
+  tileBreakIntensity: [0, 10, 30]
+  tileBreakRerollReduction: 20
+  lightColor: Orange
+  texturePath: /Textures/Effects/fire.rsi 
+  fireStates: 3
+
+- type: explosion
+  id: Radioactive
+  damagePerIntensity:
+    types:
+      Radiation: 5
+      Heat: 4
+      Blunt: 3
+      Piercing: 3
+  lightColor: Green
+  fireColor: Green
+  texturePath: /Textures/Effects/fire_greyscale.rsi 
+  fireStates: 3
+
+- type: explosion
+  id: Cryo
+  damagePerIntensity:
+    types:
+      Cold: 5
+      Blunt: 2  
+  tileBreakChance: [0]
+  tileBreakIntensity: [0]
+  lightColor: Blue
+  fireColor: Blue
+  texturePath: /Textures/Effects/fire_greyscale.rsi 
+  fireStates: 3
diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/1.png b/Resources/Textures/Effects/fire_greyscale.rsi/1.png
new file mode 100644
index 0000000000..b3ceb657de
Binary files /dev/null and b/Resources/Textures/Effects/fire_greyscale.rsi/1.png differ
diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/2.png b/Resources/Textures/Effects/fire_greyscale.rsi/2.png
new file mode 100644
index 0000000000..1f03469c04
Binary files /dev/null and b/Resources/Textures/Effects/fire_greyscale.rsi/2.png differ
diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/3.png b/Resources/Textures/Effects/fire_greyscale.rsi/3.png
new file mode 100644
index 0000000000..949505eef6
Binary files /dev/null and b/Resources/Textures/Effects/fire_greyscale.rsi/3.png differ
diff --git a/Resources/Textures/Effects/fire_greyscale.rsi/meta.json b/Resources/Textures/Effects/fire_greyscale.rsi/meta.json
new file mode 100644
index 0000000000..d1b76a068b
--- /dev/null
+++ b/Resources/Textures/Effects/fire_greyscale.rsi/meta.json
@@ -0,0 +1 @@
+{"version": 1, "size": {"x": 32, "y": 32}, "license": "CC-BY-SA-3.0", "copyright": "Taken from https://github.com/tgstation/tgstation at 04e43d8c1d5097fdb697addd4395fb849dd341bd", "states": [{"name": "1", "directions": 4, "delays": [[0.1, 0.2, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.1, 0.1, 0.1]]}, {"name": "2", "directions": 4, "delays": [[0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]]}, {"name": "3", "directions": 4, "delays": [[0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], [0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]]}]}