diff --git a/Content.Client/Decals/DecalPlacementSystem.cs b/Content.Client/Decals/DecalPlacementSystem.cs
index ac39182ac68..70c1b10047c 100644
--- a/Content.Client/Decals/DecalPlacementSystem.cs
+++ b/Content.Client/Decals/DecalPlacementSystem.cs
@@ -35,6 +35,8 @@ public sealed partial class DecalPlacementSystem : EntitySystem
     private bool _placing;
     private bool _erasing;
 
+    public bool IsActive => _active; // Forge-Change
+
     public (DecalPrototype? Decal, bool Snap, Angle Angle, Color Color) GetActiveDecal()
     {
         return _active && _decalId != null ?
diff --git a/Content.Client/UserInterface/Systems/DecalPlacer/DecalPlacerUIController.cs b/Content.Client/UserInterface/Systems/DecalPlacer/DecalPlacerUIController.cs
index 7bfd99ed2f9..f9abe3413c4 100644
--- a/Content.Client/UserInterface/Systems/DecalPlacer/DecalPlacerUIController.cs
+++ b/Content.Client/UserInterface/Systems/DecalPlacer/DecalPlacerUIController.cs
@@ -75,7 +75,7 @@ private void EnsureWindow()
         ReloadPrototypes();
     }
 
-    private void CloseWindow()
+    public void CloseWindow() // Forge-Change
     {
         if (_window == null || _window.Disposed)
             return;
diff --git a/Content.Client/UserInterface/Systems/Sandbox/SandboxUIController.cs b/Content.Client/UserInterface/Systems/Sandbox/SandboxUIController.cs
index f4e37c5034c..49d90a5f34a 100644
--- a/Content.Client/UserInterface/Systems/Sandbox/SandboxUIController.cs
+++ b/Content.Client/UserInterface/Systems/Sandbox/SandboxUIController.cs
@@ -4,6 +4,7 @@
 using Content.Client.Markers;
 using Content.Client.Sandbox;
 using Content.Client.SubFloor;
+using Content.Client._Forge.WallPaint.UI;
 using Content.Client.UserInterface.Controls;
 using Content.Client.UserInterface.Systems.DecalPlacer;
 using Content.Client.UserInterface.Systems.Sandbox.Windows;
@@ -46,6 +47,7 @@ public sealed partial class SandboxUIController : UIController, IOnStateChanged<
     private EntitySpawningUIController EntitySpawningController => UIManager.GetUIController<EntitySpawningUIController>();
     private TileSpawningUIController TileSpawningController => UIManager.GetUIController<TileSpawningUIController>();
     private DecalPlacerUIController DecalPlacerController => UIManager.GetUIController<DecalPlacerUIController>();
+    private WallPaintUIController WallPaintController => UIManager.GetUIController<WallPaintUIController>();
 
     private MenuButton? SandboxButton => UIManager.GetActiveUIWidgetOrNull<MenuBar.Widgets.GameTopMenuBar>()?.SandboxButton;
 
@@ -61,6 +63,7 @@ public void OnStateEntered(GameplayState state)
             {
                 if (!_admin.CanAdminPlace())
                     return;
+                WallPaintController.CloseWindow(); // Forge-Change
                 EntitySpawningController.ToggleWindow();
             }));
         _input.SetInputCommand(ContentKeyFunctions.OpenSandboxWindow,
@@ -70,6 +73,7 @@ public void OnStateEntered(GameplayState state)
             {
                 if (!_admin.CanAdminPlace())
                     return;
+                WallPaintController.CloseWindow(); // Forge-Change
                 TileSpawningController.ToggleWindow();
             }));
         _input.SetInputCommand(ContentKeyFunctions.OpenDecalSpawnWindow,
@@ -77,6 +81,7 @@ public void OnStateEntered(GameplayState state)
             {
                 if (!_admin.CanAdminPlace())
                     return;
+                WallPaintController.CloseWindow(); // Forge-Change
                 DecalPlacerController.ToggleWindow();
             }));
 
@@ -140,9 +145,28 @@ private void EnsureWindow()
                 _console.ExecuteCommand($"rmcomp {pnent.Id} StationAiOverlay");
         };
         _window.RespawnButton.OnPressed += _ => _sandbox.Respawn();
-        _window.SpawnTilesButton.OnPressed += _ => TileSpawningController.ToggleWindow();
-        _window.SpawnEntitiesButton.OnPressed += _ => EntitySpawningController.ToggleWindow();
-        _window.SpawnDecalsButton.OnPressed += _ => DecalPlacerController.ToggleWindow();
+        _window.SpawnTilesButton.OnPressed += _ => // Forge-Change
+        {
+            WallPaintController.CloseWindow();
+            TileSpawningController.ToggleWindow();
+        };
+        _window.SpawnEntitiesButton.OnPressed += _ => // Forge-Change
+        {
+            WallPaintController.CloseWindow();
+            EntitySpawningController.ToggleWindow();
+        };
+        _window.SpawnDecalsButton.OnPressed += _ => // Forge-Change
+        {
+            WallPaintController.CloseWindow();
+            DecalPlacerController.ToggleWindow();
+        };
+        _window.PaintWallsButton.OnPressed += _ => // Forge-Change
+        {
+            EntitySpawningController.CloseWindow();
+            TileSpawningController.CloseWindow();
+            DecalPlacerController.CloseWindow();
+            WallPaintController.ToggleWindow();
+        };
         _window.GiveFullAccessButton.OnPressed += _ => _sandbox.GiveAdminAccess();
         _window.GiveAghostButton.OnPressed += _ => _sandbox.GiveAGhost();
         _window.ToggleLightButton.OnToggled += _ => _sandbox.ToggleLight();
@@ -197,6 +221,7 @@ private void CloseAll()
         _window?.Close();
         EntitySpawningController.CloseWindow();
         TileSpawningController.CloseWindow();
+        WallPaintController.CloseWindow();
     }
 
     private bool Copy(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
diff --git a/Content.Client/UserInterface/Systems/Sandbox/Windows/SandboxWindow.xaml b/Content.Client/UserInterface/Systems/Sandbox/Windows/SandboxWindow.xaml
index bec1d6b4d6f..e105349c9c0 100644
--- a/Content.Client/UserInterface/Systems/Sandbox/Windows/SandboxWindow.xaml
+++ b/Content.Client/UserInterface/Systems/Sandbox/Windows/SandboxWindow.xaml
@@ -8,6 +8,8 @@
         <Button Name="SpawnTilesButton" Access="Public" Text="{Loc sandbox-window-spawn-tiles-button}"/>
         <Button Name="SpawnEntitiesButton" Access="Public" Text="{Loc sandbox-window-spawn-entities-button}"/>
         <Button Name="SpawnDecalsButton" Access="Public" Text="{Loc sandbox-window-spawn-decals-button}"/>
+        <!-- Forge-Change -->
+        <Button Name="PaintWallsButton" Access="Public" Text="{Loc sandbox-window-paint-walls-button}"/>
 
         <Label Text="{Loc sandbox-window-visibility-label}"/>
         <Button Name="ToggleLightButton" Access="Public" Text="{Loc sandbox-window-toggle-lights-button}" ToggleMode="True"/>
diff --git a/Content.Client/_Forge/WallPaint/UI/WallPaintUIController.cs b/Content.Client/_Forge/WallPaint/UI/WallPaintUIController.cs
new file mode 100644
index 00000000000..41128eed630
--- /dev/null
+++ b/Content.Client/_Forge/WallPaint/UI/WallPaintUIController.cs
@@ -0,0 +1,71 @@
+using Content.Client.Gameplay;
+using Content.Client.Sandbox;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.Controllers;
+
+namespace Content.Client._Forge.WallPaint.UI;
+
+public sealed partial class WallPaintUIController : UIController, IOnStateExited<GameplayState>, IOnSystemChanged<SandboxSystem>
+{
+    [Dependency] private readonly IEntitySystemManager _systems = default!;
+    [UISystemDependency] private readonly SandboxSystem _sandbox = default!;
+
+    private WallPaintWindow? _window;
+
+    public void ToggleWindow()
+    {
+        EnsureWindow();
+
+        if (_window!.IsOpen)
+            _window.Close();
+        else if (_sandbox.SandboxAllowed)
+            _window.Open();
+    }
+
+    public void OnStateExited(GameplayState state)
+    {
+        DeactivatePaint();
+
+        if (_window == null)
+            return;
+
+        _window.Dispose();
+        _window = null;
+    }
+
+    public void OnSystemLoaded(SandboxSystem system)
+    {
+        _sandbox.SandboxDisabled += CloseWindow;
+    }
+
+    public void OnSystemUnloaded(SandboxSystem system)
+    {
+        _sandbox.SandboxDisabled -= CloseWindow;
+        DeactivatePaint();
+    }
+
+    private void EnsureWindow()
+    {
+        if (_window is { Disposed: false })
+            return;
+
+        DeactivatePaint();
+        _window = UIManager.CreateWindow<WallPaintWindow>();
+        LayoutContainer.SetAnchorPreset(_window, LayoutContainer.LayoutPreset.CenterLeft);
+    }
+
+    public void CloseWindow()
+    {
+        if (_window == null || _window.Disposed)
+            return;
+
+        _window.Close();
+    }
+
+    private void DeactivatePaint()
+    {
+        if (_systems.TryGetEntitySystem<WallPaintPlacementSystem>(out var wallPaint))
+            wallPaint.Deactivate();
+    }
+}
diff --git a/Content.Client/_Forge/WallPaint/UI/WallPaintWindow.xaml b/Content.Client/_Forge/WallPaint/UI/WallPaintWindow.xaml
new file mode 100644
index 00000000000..3db23d17423
--- /dev/null
+++ b/Content.Client/_Forge/WallPaint/UI/WallPaintWindow.xaml
@@ -0,0 +1,9 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               Title="{Loc 'wall-paint-window-title'}"
+               MinSize="250 230"
+               SetSize="250 230">
+    <BoxContainer Orientation="Vertical" SeparationOverride="4">
+        <ColorSelectorSliders Name="ColorPicker" IsAlphaVisible="True" />
+        <CheckBox Name="ErasePaint" Text="{Loc 'wall-paint-window-erase'}" />
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_Forge/WallPaint/UI/WallPaintWindow.xaml.cs b/Content.Client/_Forge/WallPaint/UI/WallPaintWindow.xaml.cs
new file mode 100644
index 00000000000..d8d6b0ba8cb
--- /dev/null
+++ b/Content.Client/_Forge/WallPaint/UI/WallPaintWindow.xaml.cs
@@ -0,0 +1,56 @@
+using Content.Shared._Forge.WallPaint;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Maths;
+
+namespace Content.Client._Forge.WallPaint.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class WallPaintWindow : DefaultWindow
+{
+    [Dependency] private IEntityManager _entity = default!;
+
+    private WallPaintPlacementSystem _wallPaint = default!;
+
+    public WallPaintWindow()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        _wallPaint = _entity.System<WallPaintPlacementSystem>();
+        ColorPicker.SelectorType = ColorSelectorSliders.ColorSelectorType.Hsv;
+        ColorPicker.Color = _wallPaint.Color;
+        ErasePaint.Pressed = _wallPaint.Erase;
+
+        ColorPicker.OnColorChanged += color =>
+        {
+            var clamped = WallPaintColor.Clamp(color);
+            if (!MathHelper.CloseToPercent(color, clamped))
+                ColorPicker.Color = clamped;
+
+            _wallPaint.SetColor(clamped);
+        };
+
+        ErasePaint.OnToggled += args => _wallPaint.SetErase(args.Pressed);
+    }
+
+    protected override void Opened()
+    {
+        base.Opened();
+        _wallPaint.SetActive(true);
+    }
+
+    public override void Close()
+    {
+        base.Close();
+        _wallPaint.Deactivate();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        _wallPaint.Deactivate();
+        base.Dispose(disposing);
+    }
+}
diff --git a/Content.Client/_Forge/WallPaint/WallPaintPlacementSystem.cs b/Content.Client/_Forge/WallPaint/WallPaintPlacementSystem.cs
new file mode 100644
index 00000000000..49b4ca53a2f
--- /dev/null
+++ b/Content.Client/_Forge/WallPaint/WallPaintPlacementSystem.cs
@@ -0,0 +1,256 @@
+using System.Numerics;
+using Content.Client.Clickable;
+using Content.Client.Decals;
+using Content.Shared._Forge.WallPaint;
+using Robust.Client.ComponentTrees;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.Placement;
+using Robust.Shared.Enums;
+using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Player;
+
+namespace Content.Client._Forge.WallPaint;
+
+public sealed partial class WallPaintPlacementSystem : EntitySystem
+{
+    [Dependency] private IEyeManager _eye = default!;
+    [Dependency] private IInputManager _input = default!;
+    [Dependency] private IPlacementManager _placement = default!;
+    [Dependency] private InputSystem _inputSystem = default!;
+    [Dependency] private DecalPlacementSystem _decals = default!;
+    [Dependency] private SharedTransformSystem _transform = default!;
+
+    private readonly ClickableEntityComparer _comparer = new();
+
+    private SpriteTreeSystem _spriteTree = default!;
+    private ClickableSystem _clickables = default!;
+    private EntityQuery<ClickableComponent> _clickQuery;
+    private PlacementSnapshot? _previousPlacement;
+    private bool _previousDecalsActive;
+    private Color _color = WallPaintColor.Clamp(Color.FromHex("#8B0000CC"));
+    private bool _active;
+    private bool _erase;
+
+    public Color Color => _color;
+    public bool Erase => _erase;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        CommandBinds.Builder
+            .Bind(EngineKeyFunctions.EditorPlaceObject, new PointerInputCmdHandler(HandlePaint, outsidePrediction: true))
+            .Register<WallPaintPlacementSystem>();
+
+        _spriteTree = EntityManager.System<SpriteTreeSystem>();
+        _clickables = EntityManager.System<ClickableSystem>();
+        _clickQuery = GetEntityQuery<ClickableComponent>();
+    }
+
+    public override void Shutdown()
+    {
+        Deactivate();
+        CommandBinds.Unregister<WallPaintPlacementSystem>();
+        base.Shutdown();
+    }
+
+    public void SetActive(bool active)
+    {
+        if (_active == active)
+            return;
+
+        _active = active;
+
+        if (_active)
+        {
+            CaptureSandboxState();
+            _placement.Clear();
+            _decals.SetActive(false);
+            _input.Contexts.SetActiveContext("editor");
+        }
+        else
+        {
+            RestoreSandboxState();
+        }
+    }
+
+    public void Deactivate()
+    {
+        SetActive(false);
+    }
+
+    public void SetColor(Color color)
+    {
+        _color = WallPaintColor.Clamp(color);
+    }
+
+    public void SetErase(bool erase)
+    {
+        _erase = erase;
+    }
+
+    private bool HandlePaint(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
+    {
+        if (!_active)
+            return false;
+
+        var target = GetPaintTarget(coords, uid);
+        if (target == null)
+            return true;
+
+        RaiseNetworkEvent(new WallPaintRequestEvent(GetNetEntity(target.Value), _color, _erase));
+        return true;
+    }
+
+    private EntityUid? GetPaintTarget(EntityCoordinates coords, EntityUid uid)
+    {
+        if (uid.IsValid() && HasComp<PaintableWallComponent>(uid))
+            return uid;
+
+        return GetClickablePaintTarget(_transform.ToMapCoordinates(coords));
+    }
+
+    private EntityUid? GetClickablePaintTarget(MapCoordinates coordinates)
+    {
+        if (_eye.CurrentEye == null)
+            return null;
+
+        var entities = _spriteTree.QueryAabb(coordinates.MapId, Box2.CenteredAround(coordinates.Position, new Vector2(1, 1)));
+        (EntityUid Uid, int DrawDepth, uint RenderOrder, float Bottom)? best = null;
+
+        foreach (var entity in entities)
+        {
+            if (!_clickQuery.TryGetComponent(entity.Uid, out var component) ||
+                !HasComp<PaintableWallComponent>(entity.Uid) ||
+                !_clickables.CheckClick((entity.Uid, component, entity.Component, entity.Transform), coordinates.Position, _eye.CurrentEye, out var drawDepth, out var renderOrder, out var bottom))
+            {
+                continue;
+            }
+
+            var candidate = (entity.Uid, drawDepth, renderOrder, bottom);
+            if (best == null || _comparer.Compare(candidate, best.Value) < 0)
+                best = candidate;
+        }
+
+        return best?.Uid;
+    }
+
+    private void CaptureSandboxState()
+    {
+        _previousPlacement = PlacementSnapshot.From(_placement);
+        _previousDecalsActive = _decals.IsActive;
+    }
+
+    private void RestoreSandboxState()
+    {
+        var restoredPlacement = _previousPlacement?.Restore(_placement) == true;
+        _previousPlacement = null;
+
+        if (_previousDecalsActive)
+            _decals.SetActive(true);
+
+        if (!restoredPlacement && !_previousDecalsActive)
+            _inputSystem.SetEntityContextActive();
+
+        _previousDecalsActive = false;
+    }
+
+    private sealed class ClickableEntityComparer : IComparer<(EntityUid Uid, int DrawDepth, uint RenderOrder, float Bottom)>
+    {
+        public int Compare(
+            (EntityUid Uid, int DrawDepth, uint RenderOrder, float Bottom) x,
+            (EntityUid Uid, int DrawDepth, uint RenderOrder, float Bottom) y)
+        {
+            var cmp = y.DrawDepth.CompareTo(x.DrawDepth);
+            if (cmp != 0)
+                return cmp;
+
+            cmp = y.RenderOrder.CompareTo(x.RenderOrder);
+            if (cmp != 0)
+                return cmp;
+
+            cmp = -y.Bottom.CompareTo(x.Bottom);
+            if (cmp != 0)
+                return cmp;
+
+            return y.Uid.CompareTo(x.Uid);
+        }
+    }
+
+    private sealed class PlacementSnapshot
+    {
+        private readonly PlacementInformation? _permission;
+        private readonly PlacementHijack? _hijack;
+        private readonly bool _eraser;
+        private readonly bool _replacement;
+        private readonly Direction _direction;
+        private readonly bool _mirrored;
+
+        private PlacementSnapshot(
+            PlacementInformation? permission,
+            PlacementHijack? hijack,
+            bool eraser,
+            bool replacement,
+            Direction direction,
+            bool mirrored)
+        {
+            _permission = permission;
+            _hijack = hijack;
+            _eraser = eraser;
+            _replacement = replacement;
+            _direction = direction;
+            _mirrored = mirrored;
+        }
+
+        public static PlacementSnapshot? From(IPlacementManager placement)
+        {
+            if (!placement.IsActive && !placement.Eraser)
+                return null;
+
+            return new PlacementSnapshot(
+                Clone(placement.CurrentPermission),
+                placement is PlacementManager manager ? manager.Hijack : null,
+                placement.Eraser,
+                placement.Replacement,
+                placement.Direction,
+                placement.Mirrored);
+        }
+
+        public bool Restore(IPlacementManager placement)
+        {
+            if (_permission != null)
+                placement.BeginPlacing(_permission, _hijack);
+
+            if (placement.Eraser != _eraser)
+                placement.ToggleEraser();
+
+            placement.Replacement = _replacement;
+            placement.Direction = _direction;
+            placement.Mirrored = _mirrored;
+            return _permission != null || _eraser;
+        }
+
+        private static PlacementInformation? Clone(PlacementInformation? source)
+        {
+            if (source == null)
+                return null;
+
+            return new PlacementInformation
+            {
+                MobUid = source.MobUid,
+                EntityType = source.EntityType,
+                TileType = source.TileType,
+                PlacementOption = source.PlacementOption,
+                Range = source.Range,
+                IsTile = source.IsTile,
+                Uses = source.Uses,
+                UseEditorContext = source.UseEditorContext,
+            };
+        }
+    }
+}
diff --git a/Content.Client/_Forge/WallPaint/WallPaintVisualsSystem.cs b/Content.Client/_Forge/WallPaint/WallPaintVisualsSystem.cs
new file mode 100644
index 00000000000..05410e20f5d
--- /dev/null
+++ b/Content.Client/_Forge/WallPaint/WallPaintVisualsSystem.cs
@@ -0,0 +1,183 @@
+using System.Linq;
+using Content.Shared._Forge.WallPaint;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Shared.GameStates;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._Forge.WallPaint;
+
+public sealed partial class WallPaintVisualsSystem : EntitySystem
+{
+    [Dependency] private IPrototypeManager _prototype = default!;
+
+    private const string ShaderPrototypeId = "WallPaintDarken";
+    private const float OpaqueAlphaThreshold = 0.95f;
+
+    private readonly Dictionary<EntityUid, PaintShaderState> _shaderStates = new();
+    private readonly Dictionary<PaintShaderKey, CachedPaintShader> _shaderCache = new();
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<WallPaintComponent, ComponentStartup>(OnPaintStartup);
+        SubscribeLocalEvent<WallPaintComponent, AfterAutoHandleStateEvent>(OnPaintHandleState);
+        SubscribeLocalEvent<WallPaintComponent, ComponentShutdown>(OnPaintShutdown);
+        SubscribeLocalEvent<PaintableWallComponent, ComponentStartup>(OnPaintableStartup);
+    }
+
+    public override void Shutdown()
+    {
+        foreach (var uid in _shaderStates.Keys.ToArray())
+        {
+            ClearShader(uid);
+        }
+
+        foreach (var cached in _shaderCache.Values)
+        {
+            cached.Shader.Dispose();
+        }
+
+        _shaderCache.Clear();
+        base.Shutdown();
+    }
+
+    private void OnPaintStartup(EntityUid uid, WallPaintComponent component, ComponentStartup args)
+    {
+        UpdateShader(uid, component);
+    }
+
+    private void OnPaintHandleState(EntityUid uid, WallPaintComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        UpdateShader(uid, component);
+    }
+
+    private void OnPaintShutdown(EntityUid uid, WallPaintComponent component, ComponentShutdown args)
+    {
+        ClearShader(uid);
+    }
+
+    private void OnPaintableStartup(EntityUid uid, PaintableWallComponent component, ComponentStartup args)
+    {
+        if (TryComp(uid, out WallPaintComponent? paint))
+            UpdateShader(uid, paint);
+    }
+
+    private void UpdateShader(EntityUid uid, WallPaintComponent paint, SpriteComponent? sprite = null)
+    {
+        if (!Resolve(uid, ref sprite, false))
+            return;
+
+        var key = new PaintShaderKey(paint.Color, paint.ProtectTransparent);
+        PaintShaderKey? previousKey = null;
+
+        if (!_shaderStates.TryGetValue(uid, out var state))
+        {
+            state = new PaintShaderState(key, AcquireShader(key));
+            _shaderStates.Add(uid, state);
+        }
+        else if (state.Key != key)
+        {
+            previousKey = state.Key;
+            state.Key = key;
+            state.Shader = AcquireShader(key);
+        }
+
+        var layerIndex = 0;
+        foreach (var layer in sprite.AllLayers.Cast<SpriteComponent.Layer>())
+        {
+            if (layerIndex >= state.PreviousLayers.Count)
+                state.PreviousLayers.Add(new LayerShaderState(layer.Shader, layer.ShaderPrototype));
+
+            sprite.LayerSetShader(layerIndex, state.Shader, ShaderPrototypeId);
+            layerIndex++;
+        }
+
+        if (previousKey is { } oldKey)
+            ReleaseShader(oldKey);
+    }
+
+    private ShaderInstance AcquireShader(PaintShaderKey key)
+    {
+        if (!_shaderCache.TryGetValue(key, out var cached))
+        {
+            var shader = _prototype.Index<ShaderPrototype>(ShaderPrototypeId).InstanceUnique();
+            shader.SetParameter("paintColor", key.Color);
+            shader.SetParameter("protectTransparency", key.ProtectTransparent);
+            shader.SetParameter("opaqueAlphaThreshold", OpaqueAlphaThreshold);
+            shader.MakeImmutable();
+
+            cached = new CachedPaintShader(shader);
+            _shaderCache.Add(key, cached);
+        }
+
+        cached.ReferenceCount++;
+        return cached.Shader;
+    }
+
+    private void ReleaseShader(PaintShaderKey key)
+    {
+        if (!_shaderCache.TryGetValue(key, out var cached))
+            return;
+
+        cached.ReferenceCount--;
+        if (cached.ReferenceCount > 0)
+            return;
+
+        _shaderCache.Remove(key);
+        cached.Shader.Dispose();
+    }
+
+    private void ClearShader(EntityUid uid)
+    {
+        if (!_shaderStates.Remove(uid, out var state))
+            return;
+
+        if (!TerminatingOrDeleted(uid) && TryComp(uid, out SpriteComponent? sprite))
+        {
+            var count = Math.Min(state.PreviousLayers.Count, sprite.AllLayers.Count());
+            for (var i = 0; i < count; i++)
+            {
+                var previous = state.PreviousLayers[i];
+                if (previous.Shader != null)
+                    sprite.LayerSetShader(i, previous.Shader, previous.Prototype?.Id);
+                else if (previous.Prototype is { } prototype)
+                    sprite.LayerSetShader(i, prototype.Id);
+                else
+                    sprite.LayerSetShader(i, null, null);
+            }
+        }
+
+        ReleaseShader(state.Key);
+    }
+
+    private readonly record struct PaintShaderKey(Color Color, bool ProtectTransparent);
+
+    private readonly record struct LayerShaderState(
+        ShaderInstance? Shader,
+        ProtoId<ShaderPrototype>? Prototype);
+
+    private sealed class PaintShaderState
+    {
+        public PaintShaderKey Key;
+        public ShaderInstance Shader;
+        public readonly List<LayerShaderState> PreviousLayers = new();
+
+        public PaintShaderState(PaintShaderKey key, ShaderInstance shader)
+        {
+            Key = key;
+            Shader = shader;
+        }
+    }
+
+    private sealed class CachedPaintShader
+    {
+        public readonly ShaderInstance Shader;
+        public int ReferenceCount;
+
+        public CachedPaintShader(ShaderInstance shader)
+        {
+            Shader = shader;
+        }
+    }
+}
diff --git a/Content.Server/_Forge/WallPaint/FillWallPaintCommand.cs b/Content.Server/_Forge/WallPaint/FillWallPaintCommand.cs
new file mode 100644
index 00000000000..bb61be4e61f
--- /dev/null
+++ b/Content.Server/_Forge/WallPaint/FillWallPaintCommand.cs
@@ -0,0 +1,113 @@
+using Content.Server.Administration;
+using Content.Shared._Forge.WallPaint;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Maths;
+using Robust.Shared.Toolshed;
+
+namespace Content.Server._Forge.WallPaint;
+
+[AdminCommand(AdminFlags.Mapping)]
+public sealed partial class FillWallPaintCommand : IConsoleCommand
+{
+    [Dependency] private IEntityManager _entManager = default!;
+    [Dependency] private IEntitySystemManager _systemManager = default!;
+
+    public string Command => "fpaint";
+    public string Description => "Paints every paintable wall/window on a grid.";
+    public string Help => $"{Command} <grid/entity NetEntity> <#RRGGBB|#RRGGBBAA|clear> - paint all paintable walls/windows on a paused grid, or clear paint.";
+
+    public CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+    {
+        return args.Length switch
+        {
+            1 => CompletionResult.FromHintOptions(CompletionHelper.NetEntities(args[0], _entManager), "<grid/entity NetEntity>"),
+            2 => CompletionResult.FromHint("#RRGGBB, #RRGGBBAA, or clear"),
+            _ => CompletionResult.Empty,
+        };
+    }
+
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length != 2)
+        {
+            shell.WriteError(Help);
+            return;
+        }
+
+        if (!TryGetGrid(args[0], out var gridUid, out var gridTransform, out var error))
+        {
+            shell.WriteError(error);
+            return;
+        }
+
+        var mapSystem = _systemManager.GetEntitySystem<SharedMapSystem>();
+        if (!mapSystem.IsPaused(gridTransform.MapID))
+        {
+            shell.WriteError("Wall paint is only available on paused mapping maps.");
+            return;
+        }
+
+        var remove = args[1].Equals("clear", StringComparison.OrdinalIgnoreCase);
+        var color = Color.White;
+
+        if (!remove)
+        {
+            var parsed = Color.TryFromHex(args[1]);
+            if (parsed == null)
+            {
+                shell.WriteError($"Failed to parse color '{args[1]}'. Expected #RRGGBB or #RRGGBBAA.");
+                return;
+            }
+
+            color = parsed.Value;
+            color = WallPaintColor.Clamp(color);
+        }
+
+        var wallPaint = _systemManager.GetEntitySystem<WallPaintSystem>();
+        var count = wallPaint.PaintGrid(gridUid, color, remove);
+        var action = remove ? "Cleared paint from" : $"Painted with {color.ToHex()}";
+        shell.WriteLine($"{action} {count} walls/windows.");
+    }
+
+    private bool TryGetGrid(
+        string rawId,
+        out EntityUid gridUid,
+        out TransformComponent gridTransform,
+        out string error)
+    {
+        gridUid = default;
+        gridTransform = default!;
+
+        if (!NetEntity.TryParse(rawId, out var netId) ||
+            !_entManager.TryGetEntity(netId, out var uid) ||
+            !_entManager.TryGetComponent(uid.Value, out TransformComponent? transform))
+        {
+            error = $"Failed to parse entity id '{rawId}'. Expected an entity id like n123 or 123.";
+            return false;
+        }
+
+        if (_entManager.HasComponent<MapGridComponent>(uid.Value))
+        {
+            gridUid = uid.Value;
+            gridTransform = transform;
+            error = string.Empty;
+            return true;
+        }
+
+        if (transform.GridUid is { } parentGrid &&
+            _entManager.HasComponent<MapGridComponent>(parentGrid) &&
+            _entManager.TryGetComponent(parentGrid, out TransformComponent? parentGridTransform))
+        {
+            gridUid = parentGrid;
+            gridTransform = parentGridTransform;
+            error = string.Empty;
+            return true;
+        }
+
+        error = $"Entity '{rawId}' is not a grid and is not located on a grid.";
+        return false;
+    }
+}
diff --git a/Content.Server/_Forge/WallPaint/WallPaintSystem.cs b/Content.Server/_Forge/WallPaint/WallPaintSystem.cs
new file mode 100644
index 00000000000..0d20dfa8e92
--- /dev/null
+++ b/Content.Server/_Forge/WallPaint/WallPaintSystem.cs
@@ -0,0 +1,99 @@
+using Content.Server.Administration.Managers;
+using Content.Shared._Forge.WallPaint;
+using Content.Shared.Administration;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Player;
+
+namespace Content.Server._Forge.WallPaint;
+
+public sealed partial class WallPaintSystem : EntitySystem
+{
+    [Dependency] private IAdminManager _admin = default!;
+    [Dependency] private SharedMapSystem _mapSystem = default!;
+
+    public override void Initialize()
+    {
+        SubscribeNetworkEvent<WallPaintRequestEvent>(OnPaintRequest);
+    }
+
+    public bool TrySetPaint(EntityUid uid, Color color, bool remove)
+    {
+        if (!TryGetPaintSettings(uid, out var protectTransparent))
+            return false;
+
+        if (remove)
+            return RemComp<WallPaintComponent>(uid);
+
+        var paint = EnsureComp<WallPaintComponent>(uid);
+        paint.Color = WallPaintColor.Clamp(color);
+        paint.ProtectTransparent = protectTransparent;
+        Dirty(uid, paint);
+        return true;
+    }
+
+    public int PaintGrid(EntityUid gridUid, Color color, bool remove)
+    {
+        var count = 0;
+        var enumerator = Transform(gridUid).ChildEnumerator;
+
+        while (enumerator.MoveNext(out var uid))
+        {
+            if (TrySetPaint(uid, color, remove))
+                count++;
+        }
+
+        return count;
+    }
+
+    public bool CanUseMappingPaint(ICommonSession session, EntityUid target)
+    {
+        if (!_admin.IsAdmin(session, true) ||
+            !_admin.HasAdminFlag(session, AdminFlags.Mapping) ||
+            !TryGetPaintSettings(target, out _))
+        {
+            return false;
+        }
+
+        if (session.AttachedEntity is not { } attached ||
+            !TryComp(attached, out TransformComponent? actorTransform) ||
+            !TryComp(target, out TransformComponent? targetTransform))
+        {
+            return false;
+        }
+
+        var targetMap = targetTransform.MapID;
+        if (targetMap == MapId.Nullspace ||
+            actorTransform.MapID != targetMap ||
+            !_mapSystem.IsPaused(targetMap))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private bool TryGetPaintSettings(EntityUid uid, out bool protectTransparent)
+    {
+        if (TryComp(uid, out PaintableWallComponent? paintable))
+        {
+            protectTransparent = paintable.ProtectTransparent;
+            return true;
+        }
+
+        protectTransparent = false;
+        return false;
+    }
+
+    private void OnPaintRequest(WallPaintRequestEvent ev, EntitySessionEventArgs args)
+    {
+        if (args.SenderSession is not { } session ||
+            !TryGetEntity(ev.Target, out var target) ||
+            !CanUseMappingPaint(session, target.Value))
+        {
+            return;
+        }
+
+        TrySetPaint(target.Value, ev.Color, ev.Remove);
+    }
+}
diff --git a/Content.Shared/_Forge/WallPaint/PaintableWallComponent.cs b/Content.Shared/_Forge/WallPaint/PaintableWallComponent.cs
new file mode 100644
index 00000000000..66b70164a1c
--- /dev/null
+++ b/Content.Shared/_Forge/WallPaint/PaintableWallComponent.cs
@@ -0,0 +1,10 @@
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Shared._Forge.WallPaint;
+
+[RegisterComponent]
+public sealed partial class PaintableWallComponent : Component
+{
+    [DataField]
+    public bool ProtectTransparent;
+}
diff --git a/Content.Shared/_Forge/WallPaint/WallPaintColor.cs b/Content.Shared/_Forge/WallPaint/WallPaintColor.cs
new file mode 100644
index 00000000000..c049ee6f520
--- /dev/null
+++ b/Content.Shared/_Forge/WallPaint/WallPaintColor.cs
@@ -0,0 +1,27 @@
+using System.Numerics;
+using Robust.Shared.Maths;
+
+namespace Content.Shared._Forge.WallPaint;
+
+public static class WallPaintColor
+{
+    public const float MinSaturation = 0f;
+    public const float MaxSaturation = 0.70f;
+    public const float MinValue = 0.10f;
+    public const float MaxValue = 1f;
+
+    public static Color Clamp(Color color)
+    {
+        var hsv = Color.ToHsv(color);
+        var saturation = MathHelper.Clamp(hsv.Y, MinSaturation, MaxSaturation);
+        var value = MathHelper.Clamp(hsv.Z, MinValue, MaxValue);
+
+        if (MathHelper.CloseTo(saturation, hsv.Y) &&
+            MathHelper.CloseTo(value, hsv.Z))
+        {
+            return color;
+        }
+
+        return Color.FromHsv(new Vector4(hsv.X, saturation, value, hsv.W));
+    }
+}
diff --git a/Content.Shared/_Forge/WallPaint/WallPaintComponent.cs b/Content.Shared/_Forge/WallPaint/WallPaintComponent.cs
new file mode 100644
index 00000000000..4a8e7984803
--- /dev/null
+++ b/Content.Shared/_Forge/WallPaint/WallPaintComponent.cs
@@ -0,0 +1,16 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Shared._Forge.WallPaint;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
+public sealed partial class WallPaintComponent : Component
+{
+    [DataField, AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+    public Color Color = Color.White;
+
+    [DataField, AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+    public bool ProtectTransparent;
+}
diff --git a/Content.Shared/_Forge/WallPaint/WallPaintEvents.cs b/Content.Shared/_Forge/WallPaint/WallPaintEvents.cs
new file mode 100644
index 00000000000..1c9b61125de
--- /dev/null
+++ b/Content.Shared/_Forge/WallPaint/WallPaintEvents.cs
@@ -0,0 +1,20 @@
+using Robust.Shared.GameObjects;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Forge.WallPaint;
+
+[Serializable, NetSerializable]
+public sealed class WallPaintRequestEvent : EntityEventArgs
+{
+    public NetEntity Target;
+    public Color Color;
+    public bool Remove;
+
+    public WallPaintRequestEvent(NetEntity target, Color color, bool remove)
+    {
+        Target = target;
+        Color = color;
+        Remove = remove;
+    }
+}
diff --git a/Content.Tests/Shared/_Forge/WallPaint/WallPaintColorTest.cs b/Content.Tests/Shared/_Forge/WallPaint/WallPaintColorTest.cs
new file mode 100644
index 00000000000..73559056b49
--- /dev/null
+++ b/Content.Tests/Shared/_Forge/WallPaint/WallPaintColorTest.cs
@@ -0,0 +1,38 @@
+using Content.Shared._Forge.WallPaint;
+using NUnit.Framework;
+using Robust.Shared.Maths;
+
+namespace Content.Tests.Shared._Forge.WallPaint;
+
+[TestFixture]
+public sealed class WallPaintColorTest
+{
+    [Test]
+    public void ClampLimitsSaturation()
+    {
+        var clamped = WallPaintColor.Clamp(Color.Red);
+        var hsv = Color.ToHsv(clamped);
+
+        Assert.That(hsv.Y, Is.EqualTo(WallPaintColor.MaxSaturation).Within(0.0001f));
+        Assert.That(hsv.Z, Is.EqualTo(1f).Within(0.0001f));
+    }
+
+    [Test]
+    public void ClampLimitsMinimumValue()
+    {
+        var clamped = WallPaintColor.Clamp(Color.Black);
+        var hsv = Color.ToHsv(clamped);
+
+        Assert.That(hsv.Y, Is.EqualTo(0f).Within(0.0001f));
+        Assert.That(hsv.Z, Is.EqualTo(WallPaintColor.MinValue).Within(0.0001f));
+    }
+
+    [Test]
+    public void ClampKeepsValidColor()
+    {
+        var color = Color.FromHsv(new(0.5f, 0.35f, 0.5f, 0.8f));
+        var clamped = WallPaintColor.Clamp(color);
+
+        Assert.That(MathHelper.CloseToPercent(clamped, color));
+    }
+}
diff --git a/Resources/Locale/en-US/_Forge/wall-paint.ftl b/Resources/Locale/en-US/_Forge/wall-paint.ftl
new file mode 100644
index 00000000000..d68448dcc2a
--- /dev/null
+++ b/Resources/Locale/en-US/_Forge/wall-paint.ftl
@@ -0,0 +1,2 @@
+wall-paint-window-title = Wall Paint
+wall-paint-window-erase = Erase paint
diff --git a/Resources/Locale/en-US/sandbox/sandbox-manager.ftl b/Resources/Locale/en-US/sandbox/sandbox-manager.ftl
index cc3c46ff590..28a6fa88307 100644
--- a/Resources/Locale/en-US/sandbox/sandbox-manager.ftl
+++ b/Resources/Locale/en-US/sandbox/sandbox-manager.ftl
@@ -9,6 +9,7 @@ sandbox-window-respawn-button = Respawn
 sandbox-window-spawn-entities-button = Spawn Entities
 sandbox-window-spawn-tiles-button = Spawn Tiles
 sandbox-window-spawn-decals-button = Spawn Decals
+sandbox-window-paint-walls-button = Paint Walls
 sandbox-window-grant-full-access-button = Grant Full Access
 sandbox-window-ghost-button = Ghost
 sandbox-window-toggle-lights-button = Toggle Lights
diff --git a/Resources/Locale/ru-RU/_Forge/wall-paint.ftl b/Resources/Locale/ru-RU/_Forge/wall-paint.ftl
new file mode 100644
index 00000000000..938f4e36fc2
--- /dev/null
+++ b/Resources/Locale/ru-RU/_Forge/wall-paint.ftl
@@ -0,0 +1,2 @@
+wall-paint-window-title = Покраска стен
+wall-paint-window-erase = Стереть покраску
diff --git a/Resources/Locale/ru-RU/sandbox/sandbox-manager.ftl b/Resources/Locale/ru-RU/sandbox/sandbox-manager.ftl
index a42f4c97ef1..d28096b48cf 100644
--- a/Resources/Locale/ru-RU/sandbox/sandbox-manager.ftl
+++ b/Resources/Locale/ru-RU/sandbox/sandbox-manager.ftl
@@ -7,6 +7,7 @@ sandbox-window-respawn-button = Возрождение
 sandbox-window-spawn-entities-button = Спавн сущностей
 sandbox-window-spawn-tiles-button = Спавн тайлов
 sandbox-window-spawn-decals-button = Спавн декалей
+sandbox-window-paint-walls-button = Покраска стен
 sandbox-window-grant-full-access-button = Дать полный доступ
 sandbox-window-ghost-button = Призрак
 sandbox-window-toggle-lights-button = Переключить освещение
diff --git a/Resources/Prototypes/Entities/Structures/Walls/walls.yml b/Resources/Prototypes/Entities/Structures/Walls/walls.yml
index 946d90874ea..310402c6f0f 100644
--- a/Resources/Prototypes/Entities/Structures/Walls/walls.yml
+++ b/Resources/Prototypes/Entities/Structures/Walls/walls.yml
@@ -320,6 +320,7 @@
     - Wall
   - type: Sprite
     sprite: Structures/Walls/plastitanium.rsi
+  - type: PaintableWall # Forge-Change
   - type: Icon
     sprite: Structures/Walls/plastitanium.rsi
   - type: IconSmooth
@@ -401,6 +402,7 @@
     drawdepth: Walls
     sprite: Structures/Walls/plastitanium_diagonal.rsi
     state: state0
+  - type: PaintableWall # Forge-Change
   - type: IconSmooth
     mode: Diagonal
     key: walls
@@ -440,6 +442,7 @@
   components:
   - type: Sprite
     sprite: Structures/Walls/solid.rsi
+  - type: PaintableWall # Forge-Change
   - type: Icon
     sprite: Structures/Walls/solid.rsi
     state: rgeneric
@@ -522,6 +525,7 @@
     drawdepth: Walls
     sprite: Structures/Walls/reinforced_diagonal.rsi
     state: state0
+  - type: PaintableWall # Forge-Change
   - type: IconSmooth
     mode: Diagonal
     key: walls
@@ -645,6 +649,7 @@
     drawdepth: Walls
     sprite: Structures/Walls/shuttle_diagonal.rsi
     state: state0
+  - type: PaintableWall # Forge-Change
   - type: IconSmooth
     mode: Diagonal
     key: walls
@@ -698,6 +703,7 @@
     resistance: 5
   - type: Sprite
     sprite: Structures/Walls/shuttle.rsi
+  - type: PaintableWall # Forge-Change
   - type: Icon
     sprite: Structures/Walls/shuttle.rsi
     state: full
@@ -751,6 +757,7 @@
     fx: EffectRCDDeconstruct8
   - type: Sprite
     sprite: Structures/Walls/shuttleinterior.rsi
+  - type: PaintableWall # Forge-Change
   - type: Icon
     sprite: Structures/Walls/shuttleinterior.rsi
   - type: Construction
diff --git a/Resources/Prototypes/Entities/Structures/Windows/plastitanium.yml b/Resources/Prototypes/Entities/Structures/Windows/plastitanium.yml
index 5ecda6e93ae..0463e67348c 100644
--- a/Resources/Prototypes/Entities/Structures/Windows/plastitanium.yml
+++ b/Resources/Prototypes/Entities/Structures/Windows/plastitanium.yml
@@ -17,6 +17,8 @@
         collection: GlassSmack
   - type: WallMount
     arc: 360 # interact despite grilles
+  - type: PaintableWall # Forge-Change
+    protectTransparent: true
   - type: Tag
     tags:
       - ForceFixRotations
diff --git a/Resources/Prototypes/Entities/Structures/Windows/reinforced.yml b/Resources/Prototypes/Entities/Structures/Windows/reinforced.yml
index a5070ca9723..c06d7c913d5 100644
--- a/Resources/Prototypes/Entities/Structures/Windows/reinforced.yml
+++ b/Resources/Prototypes/Entities/Structures/Windows/reinforced.yml
@@ -6,6 +6,8 @@
   - type: Sprite
     drawdepth: WallTops
     sprite: Structures/Windows/reinforced_window.rsi
+  - type: PaintableWall # Forge-Change
+    protectTransparent: true
   - type: Icon
     sprite: Structures/Windows/reinforced_window.rsi
   - type: Repairable
@@ -76,6 +78,8 @@
   - type: Sprite
     sprite: Structures/Windows/directional.rsi
     state: reinforced_window
+  - type: PaintableWall # Forge-Change
+    protectTransparent: true
   - type: Icon
     sprite: Structures/Windows/directional.rsi
     state: reinforced_window
diff --git a/Resources/Prototypes/Entities/Structures/Windows/shuttle.yml b/Resources/Prototypes/Entities/Structures/Windows/shuttle.yml
index 3763c4fc9d4..5c32edd9edd 100644
--- a/Resources/Prototypes/Entities/Structures/Windows/shuttle.yml
+++ b/Resources/Prototypes/Entities/Structures/Windows/shuttle.yml
@@ -6,6 +6,8 @@
   - type: Sprite
     drawdepth: WallTops
     sprite: Structures/Windows/shuttle_window.rsi
+  - type: PaintableWall # Forge-Change
+    protectTransparent: true
   - type: Icon
     sprite: Structures/Windows/shuttle_window.rsi
   - type: Repairable
diff --git a/Resources/Prototypes/_Forge/Shaders/wall_paint.yml b/Resources/Prototypes/_Forge/Shaders/wall_paint.yml
new file mode 100644
index 00000000000..fa2e4c18df8
--- /dev/null
+++ b/Resources/Prototypes/_Forge/Shaders/wall_paint.yml
@@ -0,0 +1,4 @@
+- type: shader
+  id: WallPaintDarken
+  kind: source
+  path: "/Textures/_Forge/Shaders/wall_paint_darken.swsl"
diff --git a/Resources/Textures/_Forge/Shaders/wall_paint_darken.swsl b/Resources/Textures/_Forge/Shaders/wall_paint_darken.swsl
new file mode 100644
index 00000000000..1f7c73f26f9
--- /dev/null
+++ b/Resources/Textures/_Forge/Shaders/wall_paint_darken.swsl
@@ -0,0 +1,16 @@
+uniform highp vec4 paintColor;
+uniform bool protectTransparency;
+uniform highp float opaqueAlphaThreshold;
+
+void fragment() {
+    highp vec4 base = zTexture(UV);
+    highp float paintAmount = paintColor.a * smoothstep(0.0, opaqueAlphaThreshold, base.a);
+
+    if (protectTransparency && base.a <= 0.0) {
+        paintAmount = 0.0;
+    }
+
+    highp float luma = dot(base.rgb, vec3(0.299, 0.587, 0.114));
+    highp vec3 tinted = paintColor.rgb * luma;
+    COLOR = vec4(mix(base.rgb, tinted, paintAmount), base.a);
+}