diff --git a/Resources/Locale/en-US/custom-controls.ftl b/Resources/Locale/en-US/custom-controls.ftl
index abf04e79d6b..b5aa5f11197 100644
--- a/Resources/Locale/en-US/custom-controls.ftl
+++ b/Resources/Locale/en-US/custom-controls.ftl
@@ -9,6 +9,7 @@ entity-spawn-window-override-menu-tooltip = Override placement
 ## TileSpawnWindow
 
 tile-spawn-window-title = Place Tiles
+tile-spawn-window-mirror-button-text = Mirror Tiles
 
 ## Console
 
diff --git a/Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs b/Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs
index 5c0a3efff5d..8ae101d4256 100644
--- a/Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs
+++ b/Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs
@@ -168,10 +168,50 @@ private void _updateChunkMesh(Entity<MapGridComponent> grid, MapChunk chunk, Map
                     var gy = y + cScaled.Y;
 
                     var vIdx = i * 4;
-                    vertexBuffer[vIdx + 0] = new Vertex2D(gx, gy, region.Left, region.Bottom, Color.White);
-                    vertexBuffer[vIdx + 1] = new Vertex2D(gx + 1, gy, region.Right, region.Bottom, Color.White);
-                    vertexBuffer[vIdx + 2] = new Vertex2D(gx + 1, gy + 1, region.Right, region.Top, Color.White);
-                    vertexBuffer[vIdx + 3] = new Vertex2D(gx, gy + 1, region.Left, region.Top, Color.White);
+
+                    var rLeftBottom = (region.Left, region.Bottom);
+                    var rRightBottom = (region.Right, region.Bottom);
+                    var rRightTop = (region.Right, region.Top);
+                    var rLeftTop = (region.Left, region.Top);
+
+                    // Rotate the tile
+                    for (int r = 0; r < tile.Rotation; r++)
+                    {
+                        (rLeftBottom, rRightBottom, rRightTop, rLeftTop) =
+                            (rLeftTop, rLeftBottom, rRightBottom, rRightTop);
+                    }
+
+                    // Mirror on the x-axis
+                    if (tile.Mirrored)
+                    {
+                        if (tile.Rotation % 2 == 0)
+                        {
+                            rLeftBottom = (rLeftBottom.Item1.Equals(region.Left) ? region.Right : region.Left,
+                                rLeftBottom.Item2);
+                            rRightBottom = (rRightBottom.Item1.Equals(region.Left) ? region.Right : region.Left,
+                                rRightBottom.Item2);
+                            rRightTop = (rRightTop.Item1.Equals(region.Left) ? region.Right : region.Left,
+                                rRightTop.Item2);
+                            rLeftTop = (rLeftTop.Item1.Equals(region.Left) ? region.Right : region.Left,
+                                rLeftTop.Item2);
+                        }
+                        else
+                        {
+                            rLeftBottom = (rLeftBottom.Item1,
+                                rLeftBottom.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                            rRightBottom = (rRightBottom.Item1,
+                                rRightBottom.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                            rRightTop = (rRightTop.Item1,
+                                rRightTop.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                            rLeftTop = (rLeftTop.Item1,
+                                rLeftTop.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                        }
+                    }
+
+                    vertexBuffer[vIdx + 0] = new Vertex2D(gx, gy, rLeftBottom.Item1, rLeftBottom.Item2, Color.White);
+                    vertexBuffer[vIdx + 1] = new Vertex2D(gx + 1, gy, rRightBottom.Item1, rRightBottom.Item2, Color.White);
+                    vertexBuffer[vIdx + 2] = new Vertex2D(gx + 1, gy + 1, rRightTop.Item1, rRightTop.Item2, Color.White);
+                    vertexBuffer[vIdx + 3] = new Vertex2D(gx, gy + 1, rLeftTop.Item1, rLeftTop.Item2, Color.White);
                     var nIdx = i * GetQuadBatchIndexCount();
                     var tIdx = (ushort)(i * 4);
                     QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);
diff --git a/Robust.Client/Placement/IPlacementManager.cs b/Robust.Client/Placement/IPlacementManager.cs
index f93da194194..5a708135002 100644
--- a/Robust.Client/Placement/IPlacementManager.cs
+++ b/Robust.Client/Placement/IPlacementManager.cs
@@ -24,10 +24,20 @@ public interface IPlacementManager
         Direction Direction { get; set; }
 
         /// <summary>
-        /// Gets called when Direction changed (presently for EntitySpawnWindow UI)
+        /// Whether a tile placement should be mirrored or not.
+        /// </summary>
+        bool Mirrored { get; set; }
+
+        /// <summary>
+        /// Gets called when Direction changed (presently for EntitySpawnWindow/TileSpawnWindow UI)
         /// </summary>
         event EventHandler DirectionChanged;
 
+        /// <summary>
+        /// Gets called when Mirrored changed (presently for TileSpawnWindow UI)
+        /// </summary>
+        event EventHandler MirroredChanged;
+
         /// <summary>
         /// Gets called when the PlacementManager changed its build/erase mode or when the hijacks changed
         /// </summary>
diff --git a/Robust.Client/Placement/PlacementManager.cs b/Robust.Client/Placement/PlacementManager.cs
index f48ccda6587..c67a34f6483 100644
--- a/Robust.Client/Placement/PlacementManager.cs
+++ b/Robust.Client/Placement/PlacementManager.cs
@@ -174,6 +174,18 @@ public Box2 ColliderAABB
 
         private Direction _direction = Direction.South;
 
+        private bool _mirrored;
+
+        public bool Mirrored
+        {
+            get => _mirrored;
+            set
+            {
+                _mirrored = value;
+                MirroredChanged?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
         /// <inheritdoc />
         public Direction Direction
         {
@@ -188,6 +200,9 @@ public Direction Direction
         /// <inheritdoc />
         public event EventHandler? DirectionChanged;
 
+        /// <inheritdoc />
+        public event EventHandler? MirroredChanged;
+
         private PlacementOverlay _drawOverlay = default!;
         private bool _isActive;
 
@@ -772,7 +787,10 @@ private void RequestPlacement(EntityCoordinates coordinates)
                     var grid = EntityManager.GetComponent<MapGridComponent>(gridId);
 
                     // no point changing the tile to the same thing.
-                    if (Maps.GetTileRef(gridId, grid, coordinates).Tile.TypeId == CurrentPermission.TileType)
+                    var tileRef = Maps.GetTileRef(gridId, grid, coordinates).Tile;
+                    if (tileRef.TypeId == CurrentPermission.TileType &&
+                        tileRef.Mirrored == Mirrored &&
+                        tileRef.Rotation == Tile.DirectionToByte(Direction))
                         return;
                 }
 
@@ -796,9 +814,14 @@ private void RequestPlacement(EntityCoordinates coordinates)
             };
 
             if (CurrentPermission.IsTile)
+            {
                 message.TileType = CurrentPermission.TileType;
+                message.Mirrored = Mirrored;
+            }
             else
+            {
                 message.EntityTemplateName = CurrentPermission.EntityType;
+            }
 
             // world x and y
             message.NetCoordinates = EntityManager.GetNetCoordinates(coordinates);
diff --git a/Robust.Client/UserInterface/Controllers/Implementations/TileSpawningUIController.cs b/Robust.Client/UserInterface/Controllers/Implementations/TileSpawningUIController.cs
index ef3376eb334..52956dacfd8 100644
--- a/Robust.Client/UserInterface/Controllers/Implementations/TileSpawningUIController.cs
+++ b/Robust.Client/UserInterface/Controllers/Implementations/TileSpawningUIController.cs
@@ -28,12 +28,15 @@ public sealed class TileSpawningUIController : UIController
     private readonly List<ITileDefinition> _shownTiles = new();
     private bool _clearingTileSelections;
     private bool _eraseTile;
+    private bool _mirroredTile;
 
     public override void Initialize()
     {
         DebugTools.Assert(_init == false);
         _init = true;
         _placement.PlacementChanged += ClearTileSelection;
+        _placement.DirectionChanged += OnDirectionChanged;
+        _placement.MirroredChanged += OnMirroredChanged;
     }
 
     private void StartTilePlacement(int tileType)
@@ -67,6 +70,21 @@ private void OnTileEraseToggled(ButtonToggledEventArgs args)
         args.Button.Pressed = args.Pressed;
     }
 
+    private void OnTileMirroredToggled(ButtonToggledEventArgs args)
+    {
+        if (_window == null || _window.Disposed)
+            return;
+
+        if (args.Pressed)
+            _placement.Mirrored = true;
+        else
+            _placement.Mirrored = false;
+
+        _mirroredTile = _placement.Mirrored;
+
+        args.Button.Pressed = args.Pressed;
+    }
+
     public void ToggleWindow()
     {
         EnsureWindow();
@@ -78,6 +96,9 @@ public void ToggleWindow()
         else
         {
             _window.Open();
+            UpdateEntityDirectionLabel();
+            UpdateMirroredButton();
+            _window.SearchBar.GrabKeyboardFocus();
         }
     }
 
@@ -94,6 +115,8 @@ private void EnsureWindow()
         _window.TileList.OnItemDeselected += OnTileItemDeselected;
         _window.EraseButton.Pressed = _eraseTile;
         _window.EraseButton.OnToggled += OnTileEraseToggled;
+        _window.MirroredButton.Pressed = _mirroredTile;
+        _window.MirroredButton.OnToggled += OnTileMirroredToggled;
         BuildTileList();
     }
 
@@ -111,6 +134,7 @@ private void ClearTileSelection(object? sender, EventArgs e)
         _window.TileList.ClearSelected();
         _clearingTileSelections = false;
         _window.EraseButton.Pressed = false;
+        _window.MirroredButton.Pressed = _placement.Mirrored;
     }
 
     private void OnTileClearPressed(ButtonEventArgs args)
@@ -150,6 +174,33 @@ private void OnTileItemDeselected(ItemList.ItemListDeselectedEventArgs args)
         _placement.Clear();
     }
 
+    private void OnDirectionChanged(object? sender, EventArgs e)
+    {
+        UpdateEntityDirectionLabel();
+    }
+
+    private void UpdateEntityDirectionLabel()
+    {
+        if (_window == null || _window.Disposed)
+            return;
+
+        _window.RotationLabel.Text = _placement.Direction.ToString();
+    }
+
+    private void OnMirroredChanged(object? sender, EventArgs e)
+    {
+        UpdateMirroredButton();
+    }
+
+    private void UpdateMirroredButton()
+    {
+        if (_window == null || _window.Disposed)
+            return;
+
+        _mirroredTile = _placement.Mirrored;
+        _window.MirroredButton.Pressed = _mirroredTile;
+    }
+
     private void BuildTileList(string? searchStr = null)
     {
         if (_window == null || _window.Disposed) return;
diff --git a/Robust.Client/UserInterface/CustomControls/TileSpawnWindow.xaml b/Robust.Client/UserInterface/CustomControls/TileSpawnWindow.xaml
index 95dbcdc242e..11f770e7817 100644
--- a/Robust.Client/UserInterface/CustomControls/TileSpawnWindow.xaml
+++ b/Robust.Client/UserInterface/CustomControls/TileSpawnWindow.xaml
@@ -10,7 +10,9 @@
         </BoxContainer>
         <ItemList Name="TileList" Access="Public" VerticalExpand="True"/>
         <BoxContainer Orientation="Horizontal">
+            <Button Name="MirroredButton" Access="Public" ToggleMode="True" Text="{Loc tile-spawn-window-mirror-button-text}"/>
             <Button Name="EraseButton" Access="Public" ToggleMode="True" Text="{Loc window-erase-button-text}"/>
         </BoxContainer>
+        <Label Name="RotationLabel" Access="Public"/>
     </BoxContainer>
 </TileSpawnWindow>
diff --git a/Robust.Server/Maps/MapChunkSerializer.cs b/Robust.Server/Maps/MapChunkSerializer.cs
index cabf4435c23..d4d8a6b4493 100644
--- a/Robust.Server/Maps/MapChunkSerializer.cs
+++ b/Robust.Server/Maps/MapChunkSerializer.cs
@@ -68,19 +68,43 @@ public MapChunk Read(ISerializationManager serializationManager, MappingDataNode
         node.TryGetValue(new ValueDataNode("version"), out var versionNode);
         var version = ((ValueDataNode?) versionNode)?.AsInt() ?? 1;
 
-        for (ushort y = 0; y < chunk.ChunkSize; y++)
+        // Old map files will throw an error if they do not have a rotation/mirror byte stored.
+        if (version >= 7)
         {
-            for (ushort x = 0; x < chunk.ChunkSize; x++)
+            for (ushort y = 0; y < chunk.ChunkSize; y++)
+            {
+                for (ushort x = 0; x < chunk.ChunkSize; x++)
+                {
+                    var id = version < 6 ? reader.ReadUInt16() : reader.ReadInt32();
+                    var flags = (TileRenderFlag)reader.ReadByte();
+                    var variant = reader.ReadByte();
+                    var rotation = reader.ReadByte();
+                    var mirrored = System.Convert.ToBoolean(reader.ReadByte());
+
+                    var defName = tileMap[id];
+                    id = tileDefinitionManager[defName].TileId;
+
+                    var tile = new Tile(id, flags, variant, rotation, mirrored);
+                    chunk.TrySetTile(x, y, tile, out _, out _);
+                }
+            }
+        }
+        else
+        {
+            for (ushort y = 0; y < chunk.ChunkSize; y++)
             {
-                var id = version < 6 ? reader.ReadUInt16() : reader.ReadInt32();
-                var flags = (TileRenderFlag)reader.ReadByte();
-                var variant = reader.ReadByte();
+                for (ushort x = 0; x < chunk.ChunkSize; x++)
+                {
+                    var id = version < 6 ? reader.ReadUInt16() : reader.ReadInt32();
+                    var flags = (TileRenderFlag)reader.ReadByte();
+                    var variant = reader.ReadByte();
 
-                var defName = tileMap[id];
-                id = tileDefinitionManager[defName].TileId;
+                    var defName = tileMap[id];
+                    id = tileDefinitionManager[defName].TileId;
 
-                var tile = new Tile(id, flags, variant);
-                chunk.TrySetTile(x, y, tile, out _, out _);
+                    var tile = new Tile(id, flags, variant);
+                    chunk.TrySetTile(x, y, tile, out _, out _);
+                }
             }
         }
 
@@ -102,7 +126,7 @@ public DataNode Write(ISerializationManager serializationManager, MapChunk value
         var gridNode = new ValueDataNode();
         root.Add("tiles", gridNode);
 
-        root.Add("version", new ValueDataNode("6"));
+        root.Add("version", new ValueDataNode("7"));
 
         Dictionary<int, int>? tileWriteMap = null;
         if (context is MapSerializationContext mapContext)
@@ -116,7 +140,7 @@ public DataNode Write(ISerializationManager serializationManager, MapChunk value
     private static string SerializeTiles(MapChunk chunk, Dictionary<int, int>? tileWriteMap)
     {
         // number of bytes written per tile, because sizeof(Tile) is useless.
-        const int structSize = 6;
+        const int structSize = 8;
 
         var nTiles = chunk.ChunkSize * chunk.ChunkSize * structSize;
         var barr = new byte[nTiles];
@@ -136,6 +160,8 @@ private static string SerializeTiles(MapChunk chunk, Dictionary<int, int>? tileW
                     writer.Write(typeId);
                     writer.Write((byte)tile.Flags);
                     writer.Write(tile.Variant);
+                    writer.Write(tile.Rotation);
+                    writer.Write(System.Convert.ToByte(tile.Mirrored));
                 }
             }
         }
diff --git a/Robust.Server/Placement/PlacementManager.cs b/Robust.Server/Placement/PlacementManager.cs
index 48e13811653..9d40c89e458 100644
--- a/Robust.Server/Placement/PlacementManager.cs
+++ b/Robust.Server/Placement/PlacementManager.cs
@@ -179,11 +179,11 @@ public void HandlePlacementRequest(MsgPlacement msg)
             }
             else
             {
-                PlaceNewTile(tileType, coordinates, msg.MsgChannel.UserId);
+                PlaceNewTile(tileType, coordinates, msg.MsgChannel.UserId, Tile.DirectionToByte(dirRcv), msg.Mirrored);
             }
         }
 
-        private void PlaceNewTile(int tileType, EntityCoordinates coordinates, NetUserId placingUserId)
+        private void PlaceNewTile(int tileType, EntityCoordinates coordinates, NetUserId placingUserId, byte direction, bool mirrored)
         {
             if (!coordinates.IsValid(_entityManager)) return;
 
@@ -193,7 +193,7 @@ private void PlaceNewTile(int tileType, EntityCoordinates coordinates, NetUserId
             if (_entityManager.TryGetComponent(coordinates.EntityId, out grid)
                 || _mapManager.TryFindGridAt(_xformSystem.ToMapCoordinates(coordinates), out gridId, out grid))
             {
-                _maps.SetTile(gridId, grid, coordinates, new Tile(tileType));
+                _maps.SetTile(gridId, grid, coordinates, new Tile(tileType, rotation: direction, mirrored: mirrored));
 
                 var placementEraseEvent = new PlacementTileEvent(tileType, coordinates, placingUserId);
                 _entityManager.EventBus.RaiseEvent(EventSource.Local, placementEraseEvent);
@@ -207,7 +207,7 @@ private void PlaceNewTile(int tileType, EntityCoordinates coordinates, NetUserId
 
                 _xformSystem.SetWorldPosition(newGridXform, coordinates.Position - newGrid.Comp.TileSizeHalfVector); // assume bottom left tile origin
                 var tilePos = _maps.WorldToTile(newGrid.Owner, newGrid.Comp, coordinates.Position);
-                _maps.SetTile(newGrid.Owner, newGrid.Comp, tilePos, new Tile(tileType));
+                _maps.SetTile(newGrid.Owner, newGrid.Comp, tilePos, new Tile(tileType, rotation: direction, mirrored: mirrored));
 
                 var placementEraseEvent = new PlacementTileEvent(tileType, coordinates, placingUserId);
                 _entityManager.EventBus.RaiseEvent(EventSource.Local, placementEraseEvent);
diff --git a/Robust.Shared/Map/Tile.cs b/Robust.Shared/Map/Tile.cs
index 23c6ad9f389..8c546127b5e 100644
--- a/Robust.Shared/Map/Tile.cs
+++ b/Robust.Shared/Map/Tile.cs
@@ -1,5 +1,7 @@
 using System;
+using System.ComponentModel;
 using JetBrains.Annotations;
+using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.Map;
@@ -25,6 +27,16 @@ namespace Robust.Shared.Map;
     /// </summary>
     public readonly byte Variant;
 
+    /// <summary>
+    /// Rotation of this tile to render.
+    /// </summary>
+    public readonly byte Rotation;
+
+    /// <summary>
+    /// Whether the tile should be rendered mirrored.
+    /// </summary>
+    public readonly bool Mirrored;
+
     /// <summary>
     ///     An empty tile that can be compared against.
     /// </summary>
@@ -41,11 +53,35 @@ namespace Robust.Shared.Map;
     /// <param name="typeId">Internal type ID.</param>
     /// <param name="flags">Flags used by toolbox's rendering.</param>
     /// <param name="variant">The visual variant this tile is using.</param>
-    public Tile(int typeId, TileRenderFlag flags = 0, byte variant = 0)
+    /// <param name="rotation">The rotation this tile is using.</param>
+    /// <param name="mirrored">Whether the tile is mirrored.</param>
+    public Tile(int typeId, TileRenderFlag flags = 0, byte variant = 0, byte rotation = 0, bool mirrored = false)
     {
         TypeId = typeId;
         Flags = flags;
         Variant = variant;
+        Rotation = rotation;
+        Mirrored = mirrored;
+    }
+
+    public static byte DirectionToByte(Direction direction, bool throwIfDiagonal = false)
+    {
+        switch (direction)
+        {
+            case Direction.South:
+                return 0;
+            case Direction.East:
+                return 1;
+            case Direction.North:
+                return 2;
+            case Direction.West:
+                return 3;
+            default:
+                if (throwIfDiagonal)
+                    throw new InvalidEnumArgumentException("direction", (int)direction, typeof(Direction));
+                else
+                    return 0;
+        }
     }
 
     /// <summary>
@@ -70,7 +106,7 @@ public Tile(int typeId, TileRenderFlag flags = 0, byte variant = 0)
     /// <returns>String representation of this Tile.</returns>
     public override string ToString()
     {
-        return $"Tile {TypeId}, {Flags}, {Variant}";
+        return $"Tile {TypeId}, {Flags}, {Variant}, {Rotation}, {Mirrored}";
     }
 
     public string ToString(string? format, IFormatProvider? formatProvider)
@@ -93,7 +129,7 @@ public bool TryFormat(
     /// <inheritdoc />
     public bool Equals(Tile other)
     {
-        return TypeId == other.TypeId && Flags == other.Flags && Variant == other.Variant;
+        return TypeId == other.TypeId && Flags == other.Flags && Variant == other.Variant && Rotation == other.Rotation && Mirrored == other.Mirrored;
     }
 
     /// <inheritdoc />
@@ -109,7 +145,7 @@ public override int GetHashCode()
     {
         unchecked
         {
-            return (TypeId.GetHashCode() * 397) ^ Flags.GetHashCode() ^ Variant.GetHashCode();
+            return (TypeId.GetHashCode() * 397) ^ Flags.GetHashCode() ^ Variant.GetHashCode() ^ Rotation.GetHashCode() ^ Mirrored.GetHashCode();
         }
     }
 }
diff --git a/Robust.Shared/Network/Messages/MsgPlacement.cs b/Robust.Shared/Network/Messages/MsgPlacement.cs
index b66e50b7748..b5b8e0e4d77 100644
--- a/Robust.Shared/Network/Messages/MsgPlacement.cs
+++ b/Robust.Shared/Network/Messages/MsgPlacement.cs
@@ -34,6 +34,11 @@ public sealed class MsgPlacement : NetMessage
         public string AlignOption { get; set; }
         public Vector2 RectSize { get; set; }
 
+        /// <summary>
+        /// Used to determine tile sprite mirroring
+        /// </summary>
+        public bool Mirrored { get; set; }
+
         public override void ReadFromBuffer(NetIncomingMessage buffer, IRobustSerializer serializer)
         {
             PlaceType = (PlacementManagerMessage) buffer.ReadByte();
@@ -49,6 +54,7 @@ public override void ReadFromBuffer(NetIncomingMessage buffer, IRobustSerializer
 
                     NetCoordinates = buffer.ReadNetCoordinates();
                     DirRcv = (Direction)buffer.ReadByte();
+                    Mirrored = buffer.ReadBoolean();
                     break;
                 case PlacementManagerMessage.StartPlacement:
                     Range = buffer.ReadInt32();
@@ -84,6 +90,7 @@ public override void WriteToBuffer(NetOutgoingMessage buffer, IRobustSerializer
 
                     buffer.Write(NetCoordinates);
                     buffer.Write((byte)DirRcv);
+                    buffer.Write(Mirrored);
                     break;
                 case PlacementManagerMessage.StartPlacement:
                     buffer.Write(Range);