diff --git a/Content.Client/_Forge/QuestInstance/QuestBoardBoundUserInterface.cs b/Content.Client/_Forge/QuestInstance/QuestBoardBoundUserInterface.cs
new file mode 100644
index 0000000000..976f82fc6f
--- /dev/null
+++ b/Content.Client/_Forge/QuestInstance/QuestBoardBoundUserInterface.cs
@@ -0,0 +1,38 @@
+using Content.Shared._Forge.QuestInstance;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+
+
+namespace Content.Client._Forge.QuestInstance;
+
+
+[UsedImplicitly]
+public sealed class QuestBoardBoundUserInterface : BoundUserInterface
+{
+    [ViewVariables]
+    private QuestBoardWindow? _window;
+
+    public QuestBoardBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey) { }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<QuestBoardWindow>();
+        _window.OpenCentered();
+
+        _window.OnDifficultySelected += difficulty =>
+        {
+            SendMessage(new QuestBoardSelectDifficultyMessage(difficulty));
+        };
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (state is QuestBoardBoundUserInterfaceState s)
+            _window?.UpdateState(s);
+    }
+}
+
diff --git a/Content.Client/_Forge/QuestInstance/QuestBoardWindow.xaml b/Content.Client/_Forge/QuestInstance/QuestBoardWindow.xaml
new file mode 100644
index 0000000000..dab9f5c8c9
--- /dev/null
+++ b/Content.Client/_Forge/QuestInstance/QuestBoardWindow.xaml
@@ -0,0 +1,81 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                     xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                     xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+                     MinSize="380 320"
+                     Title="{Loc 'quest-board-title'}">
+    <BoxContainer Orientation="Vertical" Margin="12" SeparationOverride="10">
+
+        <PanelContainer>
+            <PanelContainer.PanelOverride>
+                <gfx:StyleBoxFlat BackgroundColor="#1a140d"
+                                  BorderColor="#a88b5e"
+                                  BorderThickness="1 1 1 1" />
+            </PanelContainer.PanelOverride>
+            <BoxContainer Orientation="Vertical" Margin="10 8">
+                <Label Text="{Loc 'quest-board-title'}"
+                       StyleClasses="LabelHeading" FontColorOverride="#e3c88f"
+                       HorizontalAlignment="Center" />
+                <Label Name="StatusLabel"
+                       Text=""
+                       HorizontalAlignment="Center"
+                       Margin="0 4 0 0" />
+            </BoxContainer>
+        </PanelContainer>
+
+        <controls:HLine Color="#6f5636" Thickness="1" Margin="0 0 0 2" />
+
+        <PanelContainer Name="CreateBox">
+            <PanelContainer.PanelOverride>
+                <gfx:StyleBoxFlat BackgroundColor="#17120d"
+                                  BorderColor="#8f6a33"
+                                  BorderThickness="1 1 1 1" />
+            </PanelContainer.PanelOverride>
+            <BoxContainer Orientation="Vertical" Margin="10" SeparationOverride="6">
+                <Label Text="{Loc 'quest-board-select-difficulty'}"
+                       StyleClasses="StatusFieldTitle"
+                       HorizontalAlignment="Center"
+                       Margin="0 0 0 6" />
+                <Button Name="EasyButton"
+                        Text="{Loc 'quest-board-easy'}"
+                        StyleClasses="Caution"
+                        HorizontalExpand="True"
+                        Margin="0 1"
+                        MinSize="0 30" />
+                <Button Name="MediumButton"
+                        Text="{Loc 'quest-board-medium'}"
+                        StyleClasses="Caution"
+                        HorizontalExpand="True"
+                        Margin="0 1"
+                        MinSize="0 30" />
+                <Button Name="HardButton"
+                        Text="{Loc 'quest-board-hard'}"
+                        StyleClasses="Caution"
+                        HorizontalExpand="True"
+                        Margin="0 1"
+                        MinSize="0 30" />
+            </BoxContainer>
+        </PanelContainer>
+
+        <PanelContainer Name="JoinBox" Visible="False">
+            <PanelContainer.PanelOverride>
+                <gfx:StyleBoxFlat BackgroundColor="#18120e"
+                                  BorderColor="#a88b5e"
+                                  BorderThickness="1 1 1 1" />
+            </PanelContainer.PanelOverride>
+            <BoxContainer Orientation="Vertical" Margin="10" SeparationOverride="6">
+                <Label Text="{Loc 'quest-board-instance-active'}"
+                       StyleClasses="StatusFieldTitle"
+                       HorizontalAlignment="Center"
+                       Margin="0 0 0 6" />
+                <Button Name="JoinButton"
+                        Text="{Loc 'quest-board-join'}"
+                        StyleClasses="Caution"
+                        HorizontalExpand="True"
+                        Margin="0 1"
+                        MinSize="0 30" />
+            </BoxContainer>
+        </PanelContainer>
+
+    </BoxContainer>
+</controls:FancyWindow>
+
diff --git a/Content.Client/_Forge/QuestInstance/QuestBoardWindow.xaml.cs b/Content.Client/_Forge/QuestInstance/QuestBoardWindow.xaml.cs
new file mode 100644
index 0000000000..0359107983
--- /dev/null
+++ b/Content.Client/_Forge/QuestInstance/QuestBoardWindow.xaml.cs
@@ -0,0 +1,51 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._Forge.QuestInstance;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+
+
+namespace Content.Client._Forge.QuestInstance;
+
+
+[GenerateTypedNameReferences]
+public sealed partial class QuestBoardWindow : FancyWindow
+{
+    public QuestBoardWindow()
+    {
+        RobustXamlLoader.Load(this);
+
+        EasyButton.OnPressed += _ => OnDifficultySelected?.Invoke(QuestDifficulty.Easy);
+        MediumButton.OnPressed += _ => OnDifficultySelected?.Invoke(QuestDifficulty.Medium);
+        HardButton.OnPressed += _ => OnDifficultySelected?.Invoke(QuestDifficulty.Hard);
+        JoinButton.OnPressed += _ => OnDifficultySelected?.Invoke(QuestDifficulty.Easy);
+    }
+
+    public event Action<QuestDifficulty>? OnDifficultySelected;
+
+    public void UpdateState(QuestBoardBoundUserInterfaceState state)
+    {
+        if (state.HasActiveInstance)
+        {
+            CreateBox.Visible = false;
+            JoinBox.Visible = true;
+            StatusLabel.FontColorOverride = Color.FromHex("#ead2a2");
+
+            var minutes = state.RemainingSeconds / 60;
+            var seconds = state.RemainingSeconds % 60;
+            StatusLabel.Text = Loc.GetString(
+                "quest-board-status-active",
+                ("players", state.ParticipantCount),
+                ("minutes", minutes),
+                ("seconds", seconds));
+        }
+        else
+        {
+            CreateBox.Visible = true;
+            JoinBox.Visible = false;
+            StatusLabel.FontColorOverride = Color.FromHex("#c7ae81");
+            StatusLabel.Text = Loc.GetString("quest-board-status-idle");
+        }
+    }
+}
+
+
diff --git a/Content.Client/_Forge/Weather/WeatherAudioCleanupSystem.cs b/Content.Client/_Forge/Weather/WeatherAudioCleanupSystem.cs
new file mode 100644
index 0000000000..3c70a31b4f
--- /dev/null
+++ b/Content.Client/_Forge/Weather/WeatherAudioCleanupSystem.cs
@@ -0,0 +1,84 @@
+using Content.Shared._Forge.QuestInstance;
+using Content.Shared.Weather;
+using Robust.Client.Player;
+using Robust.Shared.Audio.Components;
+using Robust.Shared.Audio.Systems;
+
+namespace Content.Client.Weather;
+
+public sealed class WeatherAudioCleanupSystem : EntitySystem
+{
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<WeatherComponent, ComponentShutdown>(OnWeatherShutdown);
+        SubscribeNetworkEvent<QuestInstanceWeatherAudioCleanupEvent>(OnQuestInstanceWeatherCleanup);
+    }
+
+    private void OnQuestInstanceWeatherCleanup(QuestInstanceWeatherAudioCleanupEvent ev)
+    {
+        var keepMapUid = ResolveKeepMapUid(ev.KeepMapUid);
+        CleanupWeatherAudio(keepMapUid);
+    }
+
+    private EntityUid? ResolveKeepMapUid(NetEntity? keepMapNetUid)
+    {
+        if (keepMapNetUid is { } keepNet && TryGetEntity(keepNet, out var keepMapUid) && !Deleted(keepMapUid))
+            return keepMapUid;
+
+        if (_player.LocalEntity is { } playerUid && !Deleted(playerUid))
+            return Transform(playerUid).MapUid;
+
+        return null;
+    }
+
+    private void OnWeatherShutdown(EntityUid uid, WeatherComponent component, ComponentShutdown args)
+    {
+        StopAllStreams(component);
+    }
+
+    private void CleanupWeatherAudio(EntityUid? keepMapUid)
+    {
+        var query = EntityQueryEnumerator<WeatherComponent, TransformComponent>();
+        while (query.MoveNext(out _, out var weather, out var xform))
+        {
+            if (!HasActiveStreams(weather))
+                continue;
+
+            if (keepMapUid != null && xform.MapUid == keepMapUid)
+                continue;
+
+            StopAllStreams(weather);
+        }
+    }
+
+    private static bool HasActiveStreams(WeatherComponent component)
+    {
+        foreach (var data in component.Weather.Values)
+        {
+            if (data.Stream != null)
+                return true;
+        }
+
+        return false;
+    }
+
+    private void StopAllStreams(WeatherComponent component)
+    {
+        foreach (var data in component.Weather.Values)
+        {
+            if (data.Stream is not { } streamUid)
+                continue;
+
+            if (TryComp(streamUid, out AudioComponent? audioComp))
+                _audio.SetState(streamUid, AudioState.Stopped, true, audioComp);
+
+            _audio.Stop(streamUid);
+            data.Stream = null;
+        }
+    }
+}
diff --git a/Content.Server/_Forge/QuestInstance/QuestBoardComponent.cs b/Content.Server/_Forge/QuestInstance/QuestBoardComponent.cs
new file mode 100644
index 0000000000..37ea021881
--- /dev/null
+++ b/Content.Server/_Forge/QuestInstance/QuestBoardComponent.cs
@@ -0,0 +1,50 @@
+using Robust.Shared.Map;
+using Robust.Shared.Network;
+
+
+namespace Content.Server._Forge.QuestInstance;
+
+[RegisterComponent]
+public sealed partial class QuestBoardComponent : Component
+{
+    [DataField]
+    public bool HasActiveInstance;
+
+    [DataField]
+    public HashSet<NetUserId> Participants = new();
+
+    [DataField]
+    public HashSet<EntityUid> PresentPlayers = new();
+
+    [DataField]
+    public Dictionary<EntityUid, EntityCoordinates> ReturnCoords = new();
+
+    [DataField]
+    public HashSet<int> SentWarnings = new();
+
+    [DataField]
+    public List<EntityCoordinates> PendingBarrierCoords = new();
+
+    [DataField]
+    public string BarrierProto = "QuestInvisibleWall";
+
+    [DataField]
+    public TimeSpan EndAt;
+
+    [DataField]
+    public TimeSpan JoinUntil;
+
+    [DataField]
+    public int JoinWindowSeconds;
+
+    public TimeSpan NextMaintenanceAt;
+
+    [DataField]
+    public EntityUid MapUid = EntityUid.Invalid;
+
+    [DataField]
+    public EntityCoordinates SpawnCoords = EntityCoordinates.Invalid;
+
+    [DataField]
+    public int[] WarningThresholdsSeconds = Array.Empty<int>();
+}
diff --git a/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.InstanceFlow.cs b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.InstanceFlow.cs
new file mode 100644
index 0000000000..61852b9293
--- /dev/null
+++ b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.InstanceFlow.cs
@@ -0,0 +1,386 @@
+using System.Linq;
+using Content.Shared._Forge.QuestInstance;
+using Content.Shared.Weather;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
+using Robust.Shared.Utility;
+
+
+namespace Content.Server._Forge.QuestInstance;
+
+
+public sealed partial class QuestInstanceSystem
+{
+    public void StartOrJoinInstance(EntityUid boardUid, ICommonSession session, QuestDifficulty difficulty)
+    {
+        if (!TryComp<QuestBoardComponent>(boardUid, out var board))
+            return;
+
+        if (board.HasActiveInstance)
+        {
+            var curTime = _timing.CurTime;
+            var alreadyParticipant = board.Participants.Contains(session.UserId);
+
+            if (curTime >= board.EndAt)
+            {
+                _popup.PopupEntity(
+                    Robust.Shared.Localization.Loc.GetString("quest-instance-expired"),
+                    session.AttachedEntity ?? boardUid,
+                    session);
+                return;
+            }
+
+            if (!alreadyParticipant && curTime > board.JoinUntil)
+            {
+                _popup.PopupEntity(
+                    Robust.Shared.Localization.Loc.GetString(
+                        "quest-instance-join-closed",
+                        ("seconds", board.JoinWindowSeconds)),
+                    session.AttachedEntity ?? boardUid,
+                    session);
+                return;
+            }
+
+            // Guard: player already on the instance map.
+            if (alreadyParticipant && session.AttachedEntity is { } attachedEnt)
+            {
+                if (Transform(attachedEnt).MapUid == board.MapUid)
+                    return;
+            }
+
+            JoinInstance(board, session);
+            return;
+        }
+
+        var presetId = DifficultyToPresetId(difficulty);
+        if (!_proto.TryIndex<QuestInstancePresetPrototype>(presetId, out var preset))
+        {
+            Log.Error($"QuestInstanceSystem: preset '{presetId}' not found.");
+            return;
+        }
+
+        if (!CreateInstance(boardUid, board, preset))
+            return;
+
+        JoinInstance(board, session);
+    }
+
+    private bool CreateInstance(EntityUid boardUid, QuestBoardComponent board, QuestInstancePresetPrototype preset)
+    {
+        ClearInstanceState(board);
+
+        var selectedMapEntry = PickMapEntry(preset);
+
+        ResPath? mapPath;
+        if (selectedMapEntry != null)
+            mapPath = selectedMapEntry.MapPath;
+        else if (preset.MapPaths.Count > 0)
+            mapPath = _random.Pick(preset.MapPaths);
+        else
+            mapPath = preset.OptionalMapPath;
+
+        var biomeTemplateId = selectedMapEntry?.BiomeTemplateId ?? preset.BiomeTemplateId;
+        var atmosphereTemperatureCelsius =
+            selectedMapEntry?.AtmosphereTemperatureCelsius ?? preset.AtmosphereTemperatureCelsius;
+
+        // Always create a dedicated map so biome + loaded grid can coexist.
+        var mapUid = _mapSystem.CreateMap(out var mapId, false);
+
+        // Atmosphere and gravity are enabled immediately to avoid vacuum spikes while content is spawning.
+        ForceMapEnvironment(mapUid);
+        ApplyBreathableMapAtmosphere(mapUid, atmosphereTemperatureCelsius);
+
+        if (biomeTemplateId is { } biomeId && !ApplyBiome(mapUid, biomeId))
+        {
+            _mapSystem.DeleteMap(mapId);
+            return false;
+        }
+
+        EntityUid gridUid;
+
+        if (mapPath != null)
+        {
+            // Load salvage grid into this map.
+            if (!_mapLoader.TryLoadGrid(mapId, mapPath.Value, out var loadedGrid))
+            {
+                Log.Error($"QuestInstanceSystem: failed to load grid '{mapPath}'.");
+                _mapSystem.DeleteMap(mapId);
+                return false;
+            }
+
+            gridUid = loadedGrid.Value;
+        }
+        else
+        {
+            // Biome-only instance.
+            if (biomeTemplateId == null)
+            {
+                Log.Error(
+                    $"QuestInstanceSystem: preset '{preset.ID}' has no MapEntries, MapPaths, OptionalMapPath, or BiomeTemplateId.");
+                _mapSystem.DeleteMap(mapId);
+                return false;
+            }
+
+            gridUid = mapUid;
+        }
+
+        ForceGridEnvironment(gridUid);
+        ForceGridBreathableAtmosphere(gridUid, atmosphereTemperatureCelsius);
+
+        _mapSystem.InitializeMap(mapId);
+
+        // Re-apply map atmosphere after init so map-atmos tiles keep the selected profile.
+        ApplyBreathableMapAtmosphere(mapUid, atmosphereTemperatureCelsius);
+
+        var signpostCoords = ComputeSpawnCoordinates(mapUid, gridUid, preset);
+        var playerSpawnCoords = OffsetCoordinates(signpostCoords, new(1.25f, 0f));
+
+        var now = _timing.CurTime;
+        board.HasActiveInstance = true;
+        board.MapUid = mapUid;
+        board.SpawnCoords = playerSpawnCoords;
+        board.JoinWindowSeconds = preset.JoinWindowSeconds;
+        board.WarningThresholdsSeconds = preset.WarningThresholdsSeconds.ToArray();
+        board.JoinUntil = now + TimeSpan.FromSeconds(preset.JoinWindowSeconds);
+        board.EndAt = now + TimeSpan.FromSeconds(preset.TimeLimitSeconds);
+        board.NextMaintenanceAt = now;
+
+        var signpost = Spawn(preset.ExitSignpostProto, signpostCoords);
+        var signpostComp = EnsureComp<QuestSignpostComponent>(signpost);
+        signpostComp.BoardUid = boardUid;
+
+        var barrierRadius = Math.Clamp(
+            ComputeBarrierRadius(gridUid, preset),
+            1,
+            Math.Max(1, preset.MaxBarrierRadius));
+        QueueSquareBarrier(board, gridUid, preset, barrierRadius);
+        ProcessPendingBarrier(board);
+
+        ApplyMapEnvironmentOverrides(mapUid, mapId, selectedMapEntry);
+        return true;
+    }
+
+    private void JoinInstance(QuestBoardComponent board, ICommonSession session)
+    {
+        if (session.AttachedEntity is not { } playerEnt)
+            return;
+
+        var playerXform = Transform(playerEnt);
+
+        // Save latest return point when joining from outside the instance map.
+        if (playerXform.MapUid != board.MapUid)
+            board.ReturnCoords[playerEnt] = playerXform.Coordinates;
+
+        board.Participants.Add(session.UserId);
+        board.PresentPlayers.Add(playerEnt);
+        TeleportWithPulledEntity(playerEnt, board.SpawnCoords);
+
+        RaiseNetworkEvent(new QuestInstanceWeatherAudioCleanupEvent(GetNetEntity(board.MapUid)), session);
+    }
+
+    private void ExitPlayer(EntityUid boardUid, ICommonSession session, QuestBoardComponent board)
+    {
+        if (session.AttachedEntity is not { } playerEnt)
+            return;
+
+        if (!ExitEntity(playerEnt, boardUid, board, session.UserId.ToString()))
+            return;
+
+        var keepMapUid = Deleted(playerEnt) ? null : Transform(playerEnt).MapUid;
+        NetEntity? keepMapNetUid = keepMapUid != null ? GetNetEntity(keepMapUid.Value) : null;
+        RaiseNetworkEvent(new QuestInstanceWeatherAudioCleanupEvent(keepMapNetUid), session);
+    }
+
+    private bool ExitEntity(EntityUid playerEnt, EntityUid boardUid, QuestBoardComponent board, string debugLabel)
+    {
+        if (board.ReturnCoords.Remove(playerEnt, out var returnCoords))
+        {
+            TeleportWithPulledEntity(playerEnt, returnCoords);
+            board.PresentPlayers.Remove(playerEnt);
+            return true;
+        }
+
+        var fallback = GetBoardFallbackCoordinates(boardUid);
+        if (fallback == EntityCoordinates.Invalid)
+        {
+            Log.Warning($"QuestInstanceSystem: no ReturnCoords and no valid board fallback for {debugLabel}.");
+            return false;
+        }
+
+        Log.Warning($"QuestInstanceSystem: no ReturnCoords for {debugLabel}, using board fallback.");
+        TeleportWithPulledEntity(playerEnt, fallback);
+        board.PresentPlayers.Remove(playerEnt);
+        return true;
+    }
+
+    private void PruneReturnCoords(QuestBoardComponent board)
+    {
+        List<EntityUid>? stale = null;
+
+        foreach (var (uid, _) in board.ReturnCoords)
+            if (Deleted(uid) || Transform(uid).MapUid != board.MapUid)
+            {
+                stale ??= new();
+                stale.Add(uid);
+            }
+
+        if (stale == null)
+            return;
+
+        foreach (var uid in stale)
+            board.ReturnCoords.Remove(uid);
+    }
+
+    private void PrunePresentPlayers(QuestBoardComponent board)
+    {
+        List<EntityUid>? stale = null;
+
+        foreach (var uid in board.PresentPlayers)
+            if (Deleted(uid) || Transform(uid).MapUid != board.MapUid)
+            {
+                stale ??= new();
+                stale.Add(uid);
+            }
+
+        if (stale == null)
+            return;
+
+        foreach (var uid in stale)
+            board.PresentPlayers.Remove(uid);
+    }
+
+    private void TryCleanupIfEmpty(EntityUid boardUid, QuestBoardComponent board)
+    {
+        PrunePresentPlayers(board);
+        if (board.PresentPlayers.Count > 0)
+            return;
+
+        PruneReturnCoords(board);
+        if (board.ReturnCoords.Count > 0)
+            return;
+
+        CleanupInstance(boardUid, board);
+    }
+
+    private void ForceCloseInstance(EntityUid boardUid, QuestBoardComponent board)
+    {
+        var everyoneEvacuated = true;
+
+        PrunePresentPlayers(board);
+        PruneReturnCoords(board);
+
+        var toEvacuate = new HashSet<EntityUid>(board.ReturnCoords.Keys);
+        toEvacuate.UnionWith(board.PresentPlayers);
+
+        foreach (var uid in toEvacuate)
+        {
+            var evacuated = ExitEntity(uid, boardUid, board, uid.ToString());
+            everyoneEvacuated &= evacuated;
+
+            if (evacuated && TryComp<ActorComponent>(uid, out var actor))
+            {
+                var keepMapUid = Deleted(uid) ? null : Transform(uid).MapUid;
+                NetEntity? keepMapNetUid = keepMapUid != null ? GetNetEntity(keepMapUid.Value) : null;
+                RaiseNetworkEvent(new QuestInstanceWeatherAudioCleanupEvent(keepMapNetUid), actor.PlayerSession);
+            }
+        }
+
+        if (!everyoneEvacuated)
+        {
+            Log.Warning(
+                $"QuestInstanceSystem: aborting cleanup for board {boardUid} because not all players could be evacuated.");
+            return;
+        }
+
+        CleanupInstance(boardUid, board);
+    }
+
+    private void CleanupInstance(EntityUid boardUid, QuestBoardComponent board)
+    {
+        if (!Deleted(board.MapUid))
+        {
+            var mapId = Transform(board.MapUid).MapID;
+            if (mapId != MapId.Nullspace)
+            {
+                if (TryComp<WeatherComponent>(board.MapUid, out var weatherComp))
+                {
+                    weatherComp.Weather.Clear();
+                    Dirty(board.MapUid, weatherComp);
+                }
+
+                _mapSystem.DeleteMap(mapId);
+            }
+        }
+
+        ClearInstanceState(board);
+
+        if (!Deleted(boardUid) && !Terminating(boardUid))
+            SendBoardState(boardUid, board);
+    }
+
+    private static void ClearInstanceState(QuestBoardComponent board)
+    {
+        board.HasActiveInstance = false;
+        board.Participants.Clear();
+        board.PresentPlayers.Clear();
+        board.ReturnCoords.Clear();
+        board.SentWarnings.Clear();
+        board.PendingBarrierCoords.Clear();
+
+        board.BarrierProto = "QuestInvisibleWall";
+        board.EndAt = TimeSpan.Zero;
+        board.JoinUntil = TimeSpan.Zero;
+        board.JoinWindowSeconds = 0;
+        board.NextMaintenanceAt = TimeSpan.Zero;
+        board.MapUid = EntityUid.Invalid;
+        board.SpawnCoords = EntityCoordinates.Invalid;
+        board.WarningThresholdsSeconds = Array.Empty<int>();
+    }
+
+    public override void Update(float frameTime)
+    {
+        var curTime = _timing.CurTime;
+        List<EntityUid>? toClose = null;
+
+        var query = EntityQueryEnumerator<QuestBoardComponent>();
+        while (query.MoveNext(out var boardUid, out var board))
+        {
+            if (!board.HasActiveInstance)
+                continue;
+
+            if (board.PendingBarrierCoords.Count > 0)
+                ProcessPendingBarrier(board);
+
+            if (curTime >= board.NextMaintenanceAt)
+            {
+                board.NextMaintenanceAt = curTime + TimeSpan.FromSeconds(1);
+                PrunePresentPlayers(board);
+                PruneReturnCoords(board);
+            }
+
+            var remaining = board.EndAt - curTime;
+
+            if (board.PresentPlayers.Count > 0 &&
+                board.WarningThresholdsSeconds.Length > board.SentWarnings.Count)
+                SendWarningPopups(board, remaining);
+
+            if (remaining <= TimeSpan.Zero)
+            {
+                toClose ??= new();
+                toClose.Add(boardUid);
+            }
+        }
+
+        if (toClose == null)
+            return;
+
+        foreach (var boardUid in toClose)
+        {
+            if (!TryComp<QuestBoardComponent>(boardUid, out var board) || !board.HasActiveInstance)
+                continue;
+
+            ForceCloseInstance(boardUid, board);
+        }
+    }
+}
diff --git a/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.Interaction.cs b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.Interaction.cs
new file mode 100644
index 0000000000..80b53342e4
--- /dev/null
+++ b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.Interaction.cs
@@ -0,0 +1,123 @@
+using Content.Shared._Forge.QuestInstance;
+using Content.Shared.Interaction;
+using Content.Shared.Movement.Pulling.Components;
+using Content.Shared.Popups;
+using Content.Shared.UserInterface;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
+
+
+namespace Content.Server._Forge.QuestInstance;
+
+
+public sealed partial class QuestInstanceSystem
+{
+    private void TeleportWithPulledEntity(EntityUid user, EntityCoordinates destination)
+    {
+        if (TryComp<PullerComponent>(user, out var puller)
+            && puller.Pulling is { } pulled
+            && TryComp<PullableComponent>(pulled, out var pullable))
+        {
+            _transform.SetCoordinates(pulled, destination);
+            _transform.AttachToGridOrMap(pulled);
+            _transform.SetCoordinates(user, destination);
+            _transform.AttachToGridOrMap(user);
+
+            if (pullable.Puller != user)
+                _pulling.TryStartPull(user, pulled, puller, pullable);
+
+            return;
+        }
+
+        _transform.SetCoordinates(user, destination);
+        _transform.AttachToGridOrMap(user);
+    }
+
+    private void SendWarningPopups(QuestBoardComponent board, TimeSpan remaining)
+    {
+        if (board.PresentPlayers.Count == 0)
+            return;
+
+        List<EntityUid>? players = null;
+
+        foreach (var threshold in board.WarningThresholdsSeconds)
+        {
+            if (remaining.TotalSeconds > threshold)
+                continue;
+
+            if (!board.SentWarnings.Add(threshold))
+                continue;
+
+            var msg = Robust.Shared.Localization.Loc.GetString("quest-instance-warning", ("seconds", threshold));
+            players ??= [..board.PresentPlayers,];
+
+            foreach (var uid in players)
+            {
+                if (!TryComp<ActorComponent>(uid, out var actor))
+                    continue;
+
+                _popup.PopupEntity(msg, uid, actor.PlayerSession, PopupType.LargeCaution);
+            }
+        }
+    }
+
+    private void OnSignpostUsed(EntityUid uid, QuestSignpostComponent comp, InteractHandEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (!TryComp<ActorComponent>(args.User, out var actor))
+            return;
+
+        if (!TryComp<QuestBoardComponent>(comp.BoardUid, out var board) || !board.HasActiveInstance)
+            return;
+
+        args.Handled = true;
+
+        ExitPlayer(comp.BoardUid, actor.PlayerSession, board);
+        TryCleanupIfEmpty(comp.BoardUid, board);
+        SendBoardState(comp.BoardUid, board);
+    }
+
+    private void OnBoardTerminating(EntityUid uid, QuestBoardComponent comp, EntityTerminatingEvent args)
+    {
+        if (!comp.HasActiveInstance)
+            return;
+
+        ForceCloseInstance(uid, comp);
+    }
+
+    private void OnBoardUiOpened(EntityUid uid, QuestBoardComponent comp, AfterActivatableUIOpenEvent args) =>
+        SendBoardState(uid, comp);
+
+    private void OnBoardSelectDifficulty(EntityUid uid, QuestBoardComponent comp, QuestBoardSelectDifficultyMessage msg)
+    {
+        if (!TryComp<ActorComponent>(msg.Actor, out var actor))
+            return;
+
+        StartOrJoinInstance(uid, actor.PlayerSession, msg.Difficulty);
+        SendBoardState(uid, comp);
+    }
+
+    private void SendBoardState(EntityUid boardUid, QuestBoardComponent? board = null)
+    {
+        if (!Resolve(boardUid, ref board, false))
+            return;
+
+        QuestBoardBoundUserInterfaceState state;
+
+        if (board.HasActiveInstance)
+        {
+            PrunePresentPlayers(board);
+            var remaining = board.EndAt - _timing.CurTime;
+            state = new(
+                true,
+                Math.Max(0, (int) remaining.TotalSeconds),
+                board.PresentPlayers.Count);
+        }
+        else
+            state = new(false, 0, 0);
+
+        _ui.SetUiState(boardUid, QuestBoardUiKey.Key, state);
+    }
+}
diff --git a/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.MapSetup.cs b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.MapSetup.cs
new file mode 100644
index 0000000000..714c92967b
--- /dev/null
+++ b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.MapSetup.cs
@@ -0,0 +1,240 @@
+using Content.Shared._Forge.QuestInstance;
+using System.Numerics;
+using Content.Shared.Atmos;
+using Content.Shared.Gravity;
+using Content.Shared.Parallax.Biomes;
+using Content.Shared.TimeCycle;
+using Content.Shared.Weather;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+
+namespace Content.Server._Forge.QuestInstance;
+
+
+public sealed partial class QuestInstanceSystem
+{
+    private QuestInstanceMapEntry? PickMapEntry(QuestInstancePresetPrototype preset)
+    {
+        if (!preset.HasMapEntries)
+            return null;
+
+        var totalWeight = 0f;
+        foreach (var entry in preset.MapEntries)
+            totalWeight += entry.EffectiveWeight;
+
+        if (totalWeight <= 0f)
+        {
+            Log.Warning(
+                $"QuestInstanceSystem: preset '{preset.ID}' has mapEntries with non-positive total weight. Using uniform pick.");
+            return _random.Pick(preset.MapEntries);
+        }
+
+        var roll = _random.NextFloat(totalWeight);
+
+        foreach (var entry in preset.MapEntries)
+        {
+            var weight = entry.EffectiveWeight;
+            if (weight <= 0f)
+                continue;
+
+            if (roll < weight)
+                return entry;
+
+            roll -= weight;
+        }
+
+        return preset.MapEntries[^1];
+    }
+
+    private bool ApplyBiome(EntityUid mapUid, ProtoId<BiomeTemplatePrototype> biomeTemplateId)
+    {
+        if (!_proto.TryIndex(biomeTemplateId, out var template))
+        {
+            Log.Error($"QuestInstanceSystem: biome template '{biomeTemplateId}' not found.");
+            return false;
+        }
+
+        _biome.EnsurePlanet(mapUid, template, _random.Next());
+        return true;
+    }
+
+    private void ApplyMapEnvironmentOverrides(EntityUid mapUid, MapId mapId, QuestInstanceMapEntry? mapEntry)
+    {
+        if (mapEntry == null)
+            return;
+
+        if (mapEntry.MapLightColor is { } ambientColor)
+        {
+            var mapLight = EnsureComp<MapLightComponent>(mapUid);
+            mapLight.AmbientLightColor = ambientColor;
+            Dirty(mapUid, mapLight);
+        }
+
+        if (mapEntry.TimeCyclePaletteId is { } paletteId)
+        {
+            EnsureComp<MapLightComponent>(mapUid);
+
+            var cycle = EnsureComp<TimeCycleComponent>(mapUid);
+            cycle.PalettePrototype = paletteId.ToString();
+            cycle.Paused = false;
+            Dirty(mapUid, cycle);
+        }
+
+        if (mapEntry.WeatherPrototypeId is not { } weatherId)
+            return;
+
+        if (!_proto.TryIndex(weatherId, out WeatherPrototype? weather))
+        {
+            Log.Error($"QuestInstanceSystem: weather prototype '{weatherId}' not found.");
+            return;
+        }
+
+        _weather.SetWeather(mapId, weather, null);
+    }
+
+    private EntityCoordinates ComputeSpawnCoordinates(
+        EntityUid mapUid,
+        EntityUid gridUid,
+        QuestInstancePresetPrototype preset
+    )
+    {
+        if (!TryComp<MapGridComponent>(gridUid, out var gridComp) || gridComp.LocalAABB.IsEmpty())
+            return new(mapUid, new(0.5f, 0.5f));
+
+        var aabb = gridComp.LocalAABB;
+        var offset = MathF.Max(1f, preset.SpawnDistanceFromGrid);
+        var nearEdge = new EntityCoordinates(gridUid, new(aabb.Right + offset, aabb.Center.Y));
+        var mapCoords = _transform.ToMapCoordinates(nearEdge);
+        return new(mapUid, mapCoords.Position);
+    }
+
+    private static EntityCoordinates OffsetCoordinates(EntityCoordinates origin, Vector2 offset)
+    {
+        if (origin == EntityCoordinates.Invalid)
+            return origin;
+
+        return new(origin.EntityId, origin.Position + offset);
+    }
+
+    private EntityCoordinates GetBoardFallbackCoordinates(EntityUid boardUid)
+    {
+        if (Deleted(boardUid))
+            return EntityCoordinates.Invalid;
+
+        var boardXform = Transform(boardUid);
+        if (boardXform.MapUid == null)
+            return EntityCoordinates.Invalid;
+
+        return new(boardUid, new(1.25f, 0f));
+    }
+
+    private void ForceMapEnvironment(EntityUid mapUid)
+    {
+        var mapGravity = EnsureComp<GravityComponent>(mapUid);
+        mapGravity.Enabled = true;
+        mapGravity.Inherent = true;
+        Dirty(mapUid, mapGravity);
+    }
+
+    private void ForceGridEnvironment(EntityUid gridUid)
+    {
+        var gridGravity = EnsureComp<GravityComponent>(gridUid);
+        gridGravity.Enabled = true;
+        gridGravity.Inherent = true;
+        Dirty(gridUid, gridGravity);
+    }
+
+    private void ApplyBreathableMapAtmosphere(EntityUid mapUid, float temperatureCelsius)
+    {
+        var moles = new float[Atmospherics.AdjustedNumberOfGases];
+        moles[(int) Gas.Oxygen] = 21.824779f;
+        moles[(int) Gas.Nitrogen] = 82.10312f;
+
+        var temperatureKelvin = MathF.Max(Atmospherics.TCMB, Atmospherics.T0C + temperatureCelsius);
+        _atmos.SetMapAtmosphere(mapUid, false, new(moles, temperatureKelvin));
+    }
+
+    private void ForceGridBreathableAtmosphere(EntityUid gridUid, float temperatureCelsius)
+    {
+        var temperatureKelvin = MathF.Max(Atmospherics.TCMB, Atmospherics.T0C + temperatureCelsius);
+
+        foreach (var mixture in _atmos.GetAllMixtures(gridUid, true))
+        {
+            if (mixture.Immutable)
+                continue;
+
+            mixture.Clear();
+            mixture.SetMoles(Gas.Oxygen, 21.824779f);
+            mixture.SetMoles(Gas.Nitrogen, 82.10312f);
+            mixture.Temperature = temperatureKelvin;
+        }
+    }
+
+    private int ComputeBarrierRadius(EntityUid gridUid, QuestInstancePresetPrototype preset)
+    {
+        var padding = Math.Max(0, preset.BarrierPadding);
+
+        if (!TryComp<MapGridComponent>(gridUid, out var grid))
+            return 1 + padding;
+
+        var aabb = grid.LocalAABB;
+        var tileSize = (float) grid.TileSize;
+
+        if (aabb.Width <= tileSize && aabb.Height <= tileSize)
+            return 1 + padding;
+
+        var minX = (int) MathF.Floor(aabb.Left / tileSize);
+        var maxX = (int) MathF.Ceiling(aabb.Right / tileSize) - 1;
+        var minY = (int) MathF.Floor(aabb.Bottom / tileSize);
+        var maxY = (int) MathF.Ceiling(aabb.Top / tileSize) - 1;
+
+        var baseRadius = Math.Max(
+            Math.Max(Math.Abs(minX), Math.Abs(maxX)),
+            Math.Max(Math.Abs(minY), Math.Abs(maxY)));
+
+        if (baseRadius < 1)
+            baseRadius = 1;
+
+        return baseRadius + padding;
+    }
+
+    private void QueueSquareBarrier(
+        QuestBoardComponent board,
+        EntityUid gridUid,
+        QuestInstancePresetPrototype preset,
+        int r
+    )
+    {
+        board.BarrierProto = preset.BarrierProto;
+
+        var required = Math.Max(0, 8 * r);
+        if (board.PendingBarrierCoords.Capacity < required)
+            board.PendingBarrierCoords.Capacity = required;
+
+        for (var x = -r; x <= r; x++)
+        {
+            board.PendingBarrierCoords.Add(new(gridUid, new(x + 0.5f, -r + 0.5f)));
+            board.PendingBarrierCoords.Add(new(gridUid, new(x + 0.5f, r + 0.5f)));
+        }
+
+        for (var y = -r + 1; y <= r - 1; y++)
+        {
+            board.PendingBarrierCoords.Add(new(gridUid, new(-r + 0.5f, y + 0.5f)));
+            board.PendingBarrierCoords.Add(new(gridUid, new(r + 0.5f, y + 0.5f)));
+        }
+    }
+
+    private void ProcessPendingBarrier(QuestBoardComponent board, int spawnBudget = 16)
+    {
+        for (var i = 0; i < spawnBudget && board.PendingBarrierCoords.Count > 0; i++)
+        {
+            var idx = board.PendingBarrierCoords.Count - 1;
+            var coords = board.PendingBarrierCoords[idx];
+            board.PendingBarrierCoords.RemoveAt(idx);
+            Spawn(board.BarrierProto, coords);
+        }
+    }
+}
diff --git a/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.cs b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.cs
new file mode 100644
index 0000000000..08e503ae2f
--- /dev/null
+++ b/Content.Server/_Forge/QuestInstance/QuestInstanceSystem.cs
@@ -0,0 +1,51 @@
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Parallax;
+using Content.Server.Weather;
+using Content.Shared._Forge.QuestInstance;
+using Content.Shared.Interaction;
+using Content.Shared.Movement.Pulling.Systems;
+using Content.Shared.Popups;
+using Content.Shared.UserInterface;
+using Robust.Server.GameObjects;
+using Robust.Shared.EntitySerialization.Systems;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+
+namespace Content.Server._Forge.QuestInstance;
+
+
+public sealed partial class QuestInstanceSystem : EntitySystem
+{
+    [Dependency] private readonly AtmosphereSystem _atmos = default!;
+    [Dependency] private readonly BiomeSystem _biome = default!;
+    [Dependency] private readonly MapLoaderSystem _mapLoader = default!;
+    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly PullingSystem _pulling = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+    [Dependency] private readonly WeatherSystem _weather = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<QuestBoardComponent, EntityTerminatingEvent>(OnBoardTerminating);
+        SubscribeLocalEvent<QuestBoardComponent, AfterActivatableUIOpenEvent>(OnBoardUiOpened);
+        SubscribeLocalEvent<QuestBoardComponent, QuestBoardSelectDifficultyMessage>(OnBoardSelectDifficulty);
+        SubscribeLocalEvent<QuestSignpostComponent, InteractHandEvent>(OnSignpostUsed);
+    }
+
+    private static string DifficultyToPresetId(QuestDifficulty difficulty) =>
+        difficulty switch
+        {
+            QuestDifficulty.Easy => "QuestInstanceEasy",
+            QuestDifficulty.Medium => "QuestInstanceMedium",
+            QuestDifficulty.Hard => "QuestInstanceHard",
+            _ => "QuestInstanceEasy"
+        };
+}
diff --git a/Content.Server/_Forge/QuestInstance/QuestSignpostComponent.cs b/Content.Server/_Forge/QuestInstance/QuestSignpostComponent.cs
new file mode 100644
index 0000000000..8bddc9c3c3
--- /dev/null
+++ b/Content.Server/_Forge/QuestInstance/QuestSignpostComponent.cs
@@ -0,0 +1,8 @@
+namespace Content.Server._Forge.QuestInstance;
+
+[RegisterComponent]
+public sealed partial class QuestSignpostComponent : Component
+{
+    [DataField]
+    public EntityUid BoardUid;
+}
diff --git a/Content.Shared/_Forge/QuestInstance/QuestBoardUi.cs b/Content.Shared/_Forge/QuestInstance/QuestBoardUi.cs
new file mode 100644
index 0000000000..5ce72a3707
--- /dev/null
+++ b/Content.Shared/_Forge/QuestInstance/QuestBoardUi.cs
@@ -0,0 +1,62 @@
+using Robust.Shared.Serialization;
+
+
+namespace Content.Shared._Forge.QuestInstance;
+
+
+/// <summary>Difficulty tiers for quest instances.</summary>
+[Serializable, NetSerializable,]
+public enum QuestDifficulty
+{
+    Easy,
+    Medium,
+    Hard
+}
+
+/// <summary>BUI key for QuestBoard UI.</summary>
+[Serializable, NetSerializable,]
+public enum QuestBoardUiKey
+{
+    Key
+}
+
+/// <summary>
+///     Sent from server to client whenever board state changes.
+/// </summary>
+[Serializable, NetSerializable,]
+public sealed class QuestBoardBoundUserInterfaceState : BoundUserInterfaceState
+{
+    /// <summary>True when an instance is active for this board.</summary>
+    public bool HasActiveInstance;
+
+    /// <summary>Number of players physically present in the instance.</summary>
+    public int ParticipantCount;
+
+    /// <summary>Seconds until force-close. Meaningful only when active.</summary>
+    public int RemainingSeconds;
+
+    public QuestBoardBoundUserInterfaceState(bool hasActiveInstance, int remainingSeconds, int participantCount)
+    {
+        HasActiveInstance = hasActiveInstance;
+        RemainingSeconds = remainingSeconds;
+        ParticipantCount = participantCount;
+    }
+}
+
+/// <summary>
+///     Sent from client when selecting difficulty or joining an active instance.
+///     Difficulty is ignored by server when an instance is already active.
+/// </summary>
+[Serializable, NetSerializable,]
+public sealed class QuestBoardSelectDifficultyMessage : BoundUserInterfaceMessage
+{
+    public QuestDifficulty Difficulty;
+
+    public QuestBoardSelectDifficultyMessage(QuestDifficulty difficulty)
+    {
+        Difficulty = difficulty;
+    }
+}
+
+[RegisterComponent]
+public sealed partial class WeatherAudioListenerComponent : Component { }
diff --git a/Content.Shared/_Forge/QuestInstance/QuestInstancePresetPrototype.cs b/Content.Shared/_Forge/QuestInstance/QuestInstancePresetPrototype.cs
new file mode 100644
index 0000000000..768fc33238
--- /dev/null
+++ b/Content.Shared/_Forge/QuestInstance/QuestInstancePresetPrototype.cs
@@ -0,0 +1,83 @@
+using Content.Shared.Parallax.Biomes;
+using Content.Shared.TimeCycle;
+using Content.Shared.Weather;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+
+namespace Content.Shared._Forge.QuestInstance;
+
+[Prototype("questInstancePreset")]
+public sealed partial class QuestInstancePresetPrototype : IPrototype
+{
+    [IdDataField]
+    public string ID { get; set; } = default!;
+
+    [DataField]
+    public ProtoId<BiomeTemplatePrototype>? BiomeTemplateId;
+
+    [DataField]
+    public int TimeLimitSeconds = 900;
+
+    [DataField]
+    public int BarrierPadding = 100;
+
+    [DataField]
+    public int MaxBarrierRadius = 256;
+
+    [DataField]
+    public List<QuestInstanceMapEntry> MapEntries = new();
+
+    [DataField]
+    public List<ResPath> MapPaths = new();
+
+    [DataField]
+    public ResPath? OptionalMapPath;
+
+    [DataField]
+    public string ExitSignpostProto = "QuestSignpost";
+
+    [DataField]
+    public string BarrierProto = "QuestInvisibleWall";
+
+    [DataField]
+    public float SpawnDistanceFromGrid = 3f;
+
+    [DataField]
+    public int[] WarningThresholdsSeconds = [60, 30, 10];
+
+    [DataField]
+    public int JoinWindowSeconds = 120;
+
+    [DataField]
+    public float AtmosphereTemperatureCelsius = 20f;
+
+    public bool HasMapEntries => MapEntries.Count > 0;
+}
+
+[DataDefinition]
+public sealed partial class QuestInstanceMapEntry
+{
+    [DataField(required: true)]
+    public ResPath MapPath = default!;
+
+    [DataField]
+    public float Weight = 1f;
+
+    [DataField]
+    public ProtoId<BiomeTemplatePrototype>? BiomeTemplateId;
+
+    [DataField]
+    public Color? MapLightColor;
+
+    [DataField]
+    public ProtoId<WeatherPrototype>? WeatherPrototypeId;
+
+    [DataField]
+    public ProtoId<TimeCyclePalettePrototype>? TimeCyclePaletteId;
+
+    [DataField]
+    public float? AtmosphereTemperatureCelsius;
+
+    public float EffectiveWeight => MathF.Max(0f, Weight);
+}
diff --git a/Content.Shared/_Forge/QuestInstance/QuestInstanceWeatherAudioCleanupEvent.cs b/Content.Shared/_Forge/QuestInstance/QuestInstanceWeatherAudioCleanupEvent.cs
new file mode 100644
index 0000000000..c49305c222
--- /dev/null
+++ b/Content.Shared/_Forge/QuestInstance/QuestInstanceWeatherAudioCleanupEvent.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._Forge.QuestInstance;
+
+[Serializable, NetSerializable]
+public sealed class QuestInstanceWeatherAudioCleanupEvent(NetEntity? keepMapUid) : EntityEventArgs
+{
+    public readonly NetEntity? KeepMapUid = keepMapUid;
+}
diff --git a/Resources/Locale/ru-RU/_Nuclear14/Magnits/quest-instance.ftl b/Resources/Locale/ru-RU/_Nuclear14/Magnits/quest-instance.ftl
new file mode 100644
index 0000000000..69e850e34a
--- /dev/null
+++ b/Resources/Locale/ru-RU/_Nuclear14/Magnits/quest-instance.ftl
@@ -0,0 +1,36 @@
+## Quest Instance System
+
+# Popup when join window has expired and new player tries to enter
+quest-instance-join-closed = Вход в зону закрыт — окно входа ({ $seconds } сек.) уже истекло.
+
+# Popup when instance reached time limit and is being closed
+quest-instance-expired = Зона уже закрывается. Подождите открытия нового задания.
+
+# Warning popups sent before force-close
+quest-instance-warning = Зона закроется через { $seconds } секунд. Найдите указатель выхода!
+
+## Quest Board BUI (QuestBoardWindow)
+
+quest-board-title = Доска заданий
+
+# Status line at the top of the window
+quest-board-status-idle = Активных заданий нет. Выберите сложность.
+quest-board-status-active =
+    Активная зона • { $players ->
+        [one]   { $players } игрок
+        [few]   { $players } игрока
+        [many]  { $players } игроков
+       *[other] { $players } игроков
+    } • осталось { $minutes }:{ NUMBER($seconds, minimumIntegerDigits: 2) }
+
+# Section header above difficulty buttons
+quest-board-select-difficulty = Выберите сложность:
+
+# Difficulty buttons
+quest-board-easy   = Лёгкое  (15 мин)
+quest-board-medium = Среднее (20 мин)
+quest-board-hard   = Тяжёлое (25 мин)
+
+# Label and button shown when an instance is already active
+quest-board-instance-active = Зона уже открыта — присоединиться?
+quest-board-join = Войти в зону
diff --git a/Resources/Prototypes/_Forge/Quest/quest_entities.yml b/Resources/Prototypes/_Forge/Quest/quest_entities.yml
new file mode 100644
index 0000000000..b5e75dfc0e
--- /dev/null
+++ b/Resources/Prototypes/_Forge/Quest/quest_entities.yml
@@ -0,0 +1,122 @@
+- type: entity
+  id: QuestBoard
+  name: доска заданий
+  description: Объявления о работе и заданиях в округе. Может быть что-то интересное?
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Physics
+    bodyType: Static
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeAabb
+          bounds: "-0.45,-0.45,0.45,0.45"
+        density: 60
+        mask:
+        - MachineMask
+        layer:
+        - MidImpassable
+        - LowImpassable
+  - type: Sprite
+    drawdepth: Overdoors
+    sprite: _Nuclear14/Structures/Wallmounts/noticeboard.rsi
+    layers:
+    - state: noticeboard
+  - type: Damageable
+    damageContainer: Inorganic
+    damageModifierSet: Metallic
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 150
+      behaviors:
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+      - !type:SpawnEntitiesBehavior
+        spawn:
+          SheetSteel1:
+            min: 1
+            max: 2
+      - !type:PlaySoundBehavior
+        sound:
+          collection: MetalBreak
+  - type: Tag
+    tags:
+    - Structure
+  - type: QuestBoard
+  - type: ActivatableUI
+    key: enum.QuestBoardUiKey.Key
+  - type: UserInterface
+    interfaces:
+      enum.QuestBoardUiKey.Key:
+        type: QuestBoardBoundUserInterface
+
+- type: entity
+  id: QuestSignpost
+  name: указатель выхода
+  description: Светящийся знак. Что-то подсказывает, что нужно идти именно туда.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+    noRot: true
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Physics
+    bodyType: Static
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeAabb
+          bounds: "-0.20,-0.45,0.20,0.45"
+        density: 20
+        mask:
+        - MachineMask
+        layer:
+        - MidImpassable
+  - type: Sprite
+    drawdepth: Overdoors
+    sprite: _Nuclear14/Structures/Wallmounts/noticeboard.rsi
+    layers:
+    - state: noticeboard
+  - type: PointLight
+    radius: 3.0
+    energy: 2.0
+    color: "#00ff88"
+    enabled: true
+  - type: QuestSignpost
+
+- type: entity
+  id: QuestInvisibleWall
+  name: невидимая стена
+  description: Ты не должен это видеть.
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Transform
+    anchored: true
+  - type: Physics
+    bodyType: Static
+    canCollide: true
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeAabb
+          bounds: "-0.5,-0.5,0.5,0.5"
+        density: 100
+        hard: true
+        mask:
+        - FullTileMask
+        layer:
+        - WallLayer
+  - type: Airtight
\ No newline at end of file
diff --git a/Resources/Prototypes/_Forge/Quest/quest_instance_presets.yml b/Resources/Prototypes/_Forge/Quest/quest_instance_presets.yml
new file mode 100644
index 0000000000..60d3f26a38
--- /dev/null
+++ b/Resources/Prototypes/_Forge/Quest/quest_instance_presets.yml
@@ -0,0 +1,231 @@
+# Quest Instance Presets - Easy / Medium / Hard
+# mapEntries supports per-map overrides:
+#   mapPath: /Maps/Salvage/example.yml
+#   weight: 3
+#   biomeTemplateId: Wastes
+#   weatherPrototypeId: Rain
+#   atmosphereTemperatureCelsius: 20
+#   timeCyclePaletteId: QuestDay
+#
+# Quest palettes:
+#   Day: QuestDay
+#   Morning: QuestMorning
+#   Dusk: QuestDusk
+#   Night: QuestNight
+
+- type: questInstancePreset
+  id: QuestInstanceEasy
+  biomeTemplateId: Wastes
+  timeLimitSeconds: 900          # 15 minutes
+  barrierPadding: 60
+  maxBarrierRadius: 200
+  spawnDistanceFromGrid: 4
+  warningThresholdsSeconds:
+    - 60
+    - 30
+    - 10
+  joinWindowSeconds: 120
+  mapEntries:
+    - mapPath: /Maps/Salvage/small-1.yml
+      weight: 8
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/small-2.yml
+      weight: 6
+      weatherPrototypeId: SnowfallHeavyExtreme
+      atmosphereTemperatureCelsius: -24
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/small-3.yml
+      weight: 5
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/small-4.yml
+      weight: 4
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/small-a-1.yml
+      weight: 5
+      weatherPrototypeId: NCRadioactiveParticles
+      atmosphereTemperatureCelsius: 34
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/small-cargo.yml
+      weight: 4
+      weatherPrototypeId: NCRadioactiveRain
+      atmosphereTemperatureCelsius: 30
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/small-ai-survey-drone.yml
+      weight: 3
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/small-chapel.yml
+      weight: 4
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/small-chef.yml
+      weight: 3
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/small-party.yml
+      weight: 2
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/small-ship-1.yml
+      weight: 5
+      weatherPrototypeId: SnowfallHeavyExtreme
+      atmosphereTemperatureCelsius: -24
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/hauling-shuttle.yml
+      weight: 3
+      weatherPrototypeId: NCRadioactiveStorm
+      atmosphereTemperatureCelsius: 38
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/cargo-1.yml
+      weight: 4
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestDay
+
+- type: questInstancePreset
+  id: QuestInstanceMedium
+  biomeTemplateId: Wastes
+  timeLimitSeconds: 1200         # 20 minutes
+  barrierPadding: 100
+  maxBarrierRadius: 220
+  spawnDistanceFromGrid: 4
+  warningThresholdsSeconds:
+    - 60
+    - 30
+    - 10
+  joinWindowSeconds: 120
+  mapEntries:
+    - mapPath: /Maps/Salvage/medium-1.yml
+      weight: 6
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/medium-dock.yml
+      weight: 5
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/medium-library.yml
+      weight: 4
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/medium-crashed-shuttle.yml
+      weight: 4
+      weatherPrototypeId: NCRadioactiveRain
+      atmosphereTemperatureCelsius: 30
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/medium-pet-hospital.yml
+      weight: 3
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/medium-ruined-emergency-shuttle.yml
+      weight: 3
+      weatherPrototypeId: NCRadioactiveParticles
+      atmosphereTemperatureCelsius: 34
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/medium-silent-orchestra.yml
+      weight: 3
+      weatherPrototypeId: SnowfallHeavyExtreme
+      atmosphereTemperatureCelsius: -24
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/medium-template.yml
+      weight: 2
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/ruin-cargo-salvage.yml
+      weight: 4
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/wh-salvage.yml
+      weight: 2
+      weatherPrototypeId: NCRadioactiveStorm
+      atmosphereTemperatureCelsius: 38
+      timeCyclePaletteId: QuestDusk
+
+- type: questInstancePreset
+  id: QuestInstanceHard
+  biomeTemplateId: Wastes
+  timeLimitSeconds: 1500         # 25 minutes
+  barrierPadding: 150
+  maxBarrierRadius: 240
+  spawnDistanceFromGrid: 5
+  warningThresholdsSeconds:
+    - 60
+    - 30
+    - 10
+  joinWindowSeconds: 120
+  mapEntries:
+    - mapPath: /Maps/Salvage/asteroid-base.yml
+      weight: 5
+      weatherPrototypeId: SnowfallHeavyExtreme
+      atmosphereTemperatureCelsius: -24
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/engineering-chunk.yml
+      weight: 4
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/outpost-arm.yml
+      weight: 4
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/security-chunk.yml
+      weight: 3
+      weatherPrototypeId: NCRadioactiveRain
+      atmosphereTemperatureCelsius: 30
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/medium-pirate.yml
+      weight: 4
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/medium-vault-1.yml
+      weight: 3
+      weatherPrototypeId: NCRadioactiveParticles
+      atmosphereTemperatureCelsius: 34
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/meatball.yml
+      weight: 2
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/vegan-meatball.yml
+      weight: 2
+      weatherPrototypeId: Rain
+      atmosphereTemperatureCelsius: 12
+      timeCyclePaletteId: QuestDusk
+    - mapPath: /Maps/Salvage/small-syndicate.yml
+      weight: 3
+      weatherPrototypeId: NCRadioactiveStorm
+      atmosphereTemperatureCelsius: 38
+      timeCyclePaletteId: QuestNight
+    - mapPath: /Maps/Salvage/small-tesla.yml
+      weight: 2
+      weatherPrototypeId: Storm
+      atmosphereTemperatureCelsius: 6
+      timeCyclePaletteId: QuestDay
+    - mapPath: /Maps/Salvage/stationstation.yml
+      weight: 2
+      weatherPrototypeId: Default
+      atmosphereTemperatureCelsius: 20
+      timeCyclePaletteId: QuestMorning
+    - mapPath: /Maps/Salvage/tick-colony.yml
+      weight: 3
+      weatherPrototypeId: NCRadioactiveRain
+      atmosphereTemperatureCelsius: 30
+      timeCyclePaletteId: QuestDusk
diff --git a/Resources/Prototypes/_Forge/Quest/quest_time_cycle_palettes.yml b/Resources/Prototypes/_Forge/Quest/quest_time_cycle_palettes.yml
new file mode 100644
index 0000000000..8b3f72360d
--- /dev/null
+++ b/Resources/Prototypes/_Forge/Quest/quest_time_cycle_palettes.yml
@@ -0,0 +1,27 @@
+# Quest-specific static palettes.
+# Use these IDs in questInstancePreset.mapEntries.timeCyclePaletteId:
+#   QuestDay, QuestMorning, QuestDusk, QuestNight
+
+- type: timeCyclePalette
+  id: QuestDay
+  timeEntries:
+    0: "#D8B059"
+    24: "#D8B059"
+
+- type: timeCyclePalette
+  id: QuestMorning
+  timeEntries:
+    0: "#A88F73"
+    24: "#A88F73"
+
+- type: timeCyclePalette
+  id: QuestDusk
+  timeEntries:
+    0: "#8A6A45"
+    24: "#8A6A45"
+
+- type: timeCyclePalette
+  id: QuestNight
+  timeEntries:
+    0: "#2B3143"
+    24: "#2B3143"