diff --git a/src/Compositor.cpp b/src/Compositor.cpp
index d4e2db17..a2fe9935 100644
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -834,7 +834,7 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
                     continue;
 
                 const auto BB             = w->getWindowBoxUnified(properties);
-                const auto PWINDOWMONITOR = getMonitorFromID(w->m_iMonitorID);
+                const auto PWINDOWMONITOR = w->m_pMonitor.lock();
 
                 // to avoid focusing windows behind special workspaces from other monitors
                 if (!*PSPECIALFALLTHRU && PWINDOWMONITOR && PWINDOWMONITOR->activeSpecialWorkspace && w->m_pWorkspace != PWINDOWMONITOR->activeSpecialWorkspace &&
@@ -1063,7 +1063,7 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
     if (pWindow->m_bPinned)
         pWindow->m_pWorkspace = m_pLastMonitor->activeWorkspace;
 
-    const auto PMONITOR = getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     if (!isWorkspaceVisible(pWindow->m_pWorkspace)) {
         const auto PWORKSPACE = pWindow->m_pWorkspace;
@@ -1259,7 +1259,7 @@ bool CCompositor::isWorkspaceVisibleNotCovered(PHLWORKSPACE w) {
     if (!valid(w))
         return false;
 
-    const auto PMONITOR = getMonitorFromID(w->m_iMonitorID);
+    const auto PMONITOR = w->m_pMonitor.lock();
     if (PMONITOR->activeSpecialWorkspace)
         return PMONITOR->activeSpecialWorkspace->m_iID == w->m_iID;
 
@@ -1354,7 +1354,7 @@ PHLWINDOW CCompositor::getTopLeftWindowOnWorkspace(const WORKSPACEID& id) {
     if (!PWORKSPACE)
         return nullptr;
 
-    const auto PMONITOR = getMonitorFromID(PWORKSPACE->m_iMonitorID);
+    const auto PMONITOR = PWORKSPACE->m_pMonitor.lock();
 
     for (auto const& w : m_vWindows) {
         if (w->workspaceID() != id || !w->m_bIsMapped || w->isHidden())
@@ -1405,7 +1405,7 @@ void CCompositor::changeWindowZOrder(PHLWINDOW pWindow, bool top) {
         }
 
         if (pw->m_bIsMapped)
-            g_pHyprRenderer->damageMonitor(getMonitorFromID(pw->m_iMonitorID));
+            g_pHyprRenderer->damageMonitor(pw->m_pMonitor.lock());
     };
 
     if (top)
@@ -1444,7 +1444,7 @@ void CCompositor::cleanupFadingOut(const MONITORID& monid) {
 
         auto w = ww.lock();
 
-        if (w->m_iMonitorID != monid)
+        if (w->monitorID() != monid && w->m_pMonitor)
             continue;
 
         if (!w->m_bFadingOut || w->m_fAlpha.value() == 0.f) {
@@ -1474,7 +1474,7 @@ void CCompositor::cleanupFadingOut(const MONITORID& monid) {
             continue;
         }
 
-        if (ls->monitorID != monid)
+        if (ls->monitorID() != monid && ls->monitor)
             continue;
 
         // mark blur for recalc
@@ -1537,7 +1537,7 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
     static auto PMETHOD          = CConfigValue<Hyprlang::INT>("binds:focus_preferred_method");
     static auto PMONITORFALLBACK = CConfigValue<Hyprlang::INT>("binds:window_direction_monitor_fallback");
 
-    const auto  PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto  PMONITOR = pWindow->m_pMonitor.lock();
 
     if (!PMONITOR)
         return nullptr; // ??
@@ -1558,13 +1558,13 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
             if (w == pWindow || !w->m_bIsMapped || w->isHidden() || (!w->isFullscreen() && w->m_bIsFloating) || !isWorkspaceVisible(w->m_pWorkspace))
                 continue;
 
-            if (pWindow->m_iMonitorID == w->m_iMonitorID && pWindow->m_pWorkspace != w->m_pWorkspace)
+            if (pWindow->m_pMonitor == w->m_pMonitor && pWindow->m_pWorkspace != w->m_pWorkspace)
                 continue;
 
             if (PWORKSPACE->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen)
                 continue;
 
-            if (!*PMONITORFALLBACK && pWindow->m_iMonitorID != w->m_iMonitorID)
+            if (!*PMONITORFALLBACK && pWindow->m_pMonitor != w->m_pMonitor)
                 continue;
 
             const auto BWINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
@@ -1650,13 +1650,13 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
             if (w == pWindow || !w->m_bIsMapped || w->isHidden() || (!w->isFullscreen() && !w->m_bIsFloating) || !isWorkspaceVisible(w->m_pWorkspace))
                 continue;
 
-            if (pWindow->m_iMonitorID == w->m_iMonitorID && pWindow->m_pWorkspace != w->m_pWorkspace)
+            if (pWindow->m_pMonitor == w->m_pMonitor && pWindow->m_pWorkspace != w->m_pWorkspace)
                 continue;
 
             if (PWORKSPACE->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen)
                 continue;
 
-            if (!*PMONITORFALLBACK && pWindow->m_iMonitorID != w->m_iMonitorID)
+            if (!*PMONITORFALLBACK && pWindow->m_pMonitor != w->m_pMonitor)
                 continue;
 
             const auto DIST  = w->middle().distance(pWindow->middle());
@@ -1996,7 +1996,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
     const auto PWORKSPACEA = pMonitorA->activeWorkspace;
     const auto PWORKSPACEB = pMonitorB->activeWorkspace;
 
-    PWORKSPACEA->m_iMonitorID = pMonitorB->ID;
+    PWORKSPACEA->m_pMonitor = pMonitorB;
     PWORKSPACEA->moveToMonitor(pMonitorB->ID);
 
     for (auto const& w : m_vWindows) {
@@ -2006,7 +2006,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
                 continue;
             }
 
-            w->m_iMonitorID = pMonitorB->ID;
+            w->m_pMonitor = pMonitorB;
 
             // additionally, move floating and fs windows manually
             if (w->m_bIsFloating)
@@ -2021,7 +2021,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
         }
     }
 
-    PWORKSPACEB->m_iMonitorID = pMonitorA->ID;
+    PWORKSPACEB->m_pMonitor = pMonitorA;
     PWORKSPACEB->moveToMonitor(pMonitorA->ID);
 
     for (auto const& w : m_vWindows) {
@@ -2031,7 +2031,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
                 continue;
             }
 
-            w->m_iMonitorID = pMonitorA->ID;
+            w->m_pMonitor = pMonitorA;
 
             // additionally, move floating and fs windows manually
             if (w->m_bIsFloating)
@@ -2156,12 +2156,12 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
 
     // We trust the monitor to be correct.
 
-    if (pWorkspace->m_iMonitorID == pMonitor->ID)
+    if (pWorkspace->m_pMonitor == pMonitor)
         return;
 
     Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_iID, pMonitor->ID);
 
-    const auto POLDMON = getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto POLDMON = pWorkspace->m_pMonitor.lock();
 
     const bool SWITCHINGISACTIVE = POLDMON ? POLDMON->activeWorkspace == pWorkspace : false;
 
@@ -2171,7 +2171,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
         nextWorkspaceOnMonitorID = pWorkspace->m_iID;
     else {
         for (auto const& w : m_vWorkspaces) {
-            if (w->m_iMonitorID == POLDMON->ID && w->m_iID != pWorkspace->m_iID && !w->m_bIsSpecialWorkspace) {
+            if (w->m_pMonitor == POLDMON && w->m_iID != pWorkspace->m_iID && !w->m_bIsSpecialWorkspace) {
                 nextWorkspaceOnMonitorID = w->m_iID;
                 break;
             }
@@ -2196,7 +2196,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
     }
 
     // move the workspace
-    pWorkspace->m_iMonitorID = pMonitor->ID;
+    pWorkspace->m_pMonitor = pMonitor;
     pWorkspace->moveToMonitor(pMonitor->ID);
 
     for (auto const& w : m_vWindows) {
@@ -2206,7 +2206,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
                 continue;
             }
 
-            w->m_iMonitorID = pMonitor->ID;
+            w->m_pMonitor = pMonitor;
 
             // additionally, move floating and fs windows manually
             if (w->m_bIsMapped && !w->isHidden()) {
@@ -2299,7 +2299,7 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) {
         }
     }
 
-    const auto PMONITOR = getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto PMONITOR = pWorkspace->m_pMonitor.lock();
 
     if (pWorkspace->m_iID == PMONITOR->activeWorkspaceID() || pWorkspace->m_iID == PMONITOR->activeSpecialWorkspaceID()) {
         for (auto const& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
@@ -2342,7 +2342,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, sFullscreenS
     state.internal = std::clamp(state.internal, (eFullscreenMode)0, FSMODE_MAX);
     state.client   = std::clamp(state.client, (eFullscreenMode)0, FSMODE_MAX);
 
-    const auto            PMONITOR   = getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto            PMONITOR   = PWINDOW->m_pMonitor.lock();
     const auto            PWORKSPACE = PWINDOW->m_pWorkspace;
 
     const eFullscreenMode CURRENT_EFFECTIVE_MODE = (eFullscreenMode)std::bit_floor((uint8_t)PWINDOW->m_sFullscreenState.internal);
@@ -2360,7 +2360,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, sFullscreenS
     if (!CHANGEINTERNAL) {
         PWINDOW->updateDynamicRules();
         updateWindowAnimatedDecorationValues(PWINDOW);
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->m_iMonitorID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->monitorID());
         return;
     }
 
@@ -2375,7 +2375,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, sFullscreenS
 
     PWINDOW->updateDynamicRules();
     updateWindowAnimatedDecorationValues(PWINDOW);
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->monitorID());
 
     // make all windows on the same workspace under the fullscreen window
     for (auto const& w : m_vWindows) {
@@ -2663,13 +2663,12 @@ PHLWORKSPACE CCompositor::createNewWorkspace(const WORKSPACEID& id, const MONITO
     auto       monID = monid;
 
     // check if bound
-    if (const auto PMONITOR = g_pConfigManager->getBoundMonitorForWS(NAME); PMONITOR) {
+    if (const auto PMONITOR = g_pConfigManager->getBoundMonitorForWS(NAME); PMONITOR)
         monID = PMONITOR->ID;
-    }
 
     const bool SPECIAL = id >= SPECIAL_WORKSPACE_START && id <= -2;
 
-    const auto PWORKSPACE = m_vWorkspaces.emplace_back(CWorkspace::create(id, monID, NAME, SPECIAL, isEmpty));
+    const auto PWORKSPACE = m_vWorkspaces.emplace_back(CWorkspace::create(id, getMonitorFromID(monID), NAME, SPECIAL, isEmpty));
 
     PWORKSPACE->m_fAlpha.setValueAndWarp(0);
 
@@ -2751,15 +2750,15 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
 
     const PHLWINDOW pFirstWindowOnWorkspace   = g_pCompositor->getFirstWindowOnWorkspace(pWorkspace->m_iID);
     const int       visibleWindowsOnWorkspace = g_pCompositor->getWindowsOnWorkspace(pWorkspace->m_iID, std::nullopt, true);
-    const auto      PWINDOWMONITOR            = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto      PWINDOWMONITOR            = pWindow->m_pMonitor.lock();
     const auto      POSTOMON                  = pWindow->m_vRealPosition.goal() - PWINDOWMONITOR->vecPosition;
-    const auto      PWORKSPACEMONITOR         = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto      PWORKSPACEMONITOR         = pWorkspace->m_pMonitor.lock();
 
     if (!pWindow->m_bIsFloating)
         g_pLayoutManager->getCurrentLayout()->onWindowRemovedTiling(pWindow);
 
     pWindow->moveToWorkspace(pWorkspace);
-    pWindow->m_iMonitorID = pWorkspace->m_iMonitorID;
+    pWindow->m_pMonitor = pWorkspace->m_pMonitor;
 
     static auto PGROUPONMOVETOWORKSPACE = CConfigValue<Hyprlang::INT>("group:group_on_movetoworkspace");
     if (*PGROUPONMOVETOWORKSPACE && visibleWindowsOnWorkspace == 1 && pFirstWindowOnWorkspace && pFirstWindowOnWorkspace != pWindow &&
@@ -3077,7 +3076,7 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
     checkDefaultCursorWarp(PNEWMONITOR);
 
     for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_iMonitorID == PNEWMONITOR->ID) {
+        if (w->m_pMonitor == PNEWMONITOR) {
             w->m_iLastSurfaceMonitorID = MONITOR_INVALID;
             w->updateSurfaceScaleTransformDetails();
         }
diff --git a/src/debug/HyprCtl.cpp b/src/debug/HyprCtl.cpp
index 82290f94..bf3ecfc8 100644
--- a/src/debug/HyprCtl.cpp
+++ b/src/debug/HyprCtl.cpp
@@ -242,7 +242,7 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
             (uintptr_t)w.get(), (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goal().x, (int)w->m_vRealPosition.goal().y,
             (int)w->m_vRealSize.goal().x, (int)w->m_vRealSize.goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID,
             escapeJSONStrings(!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), ((int)w->m_bIsFloating == 1 ? "true" : "false"), (w->m_bIsPseudotiled ? "true" : "false"),
-            (int64_t)w->m_iMonitorID, escapeJSONStrings(w->m_szClass), escapeJSONStrings(w->m_szTitle), escapeJSONStrings(w->m_szInitialClass),
+            (int64_t)w->monitorID(), escapeJSONStrings(w->m_szClass), escapeJSONStrings(w->m_szTitle), escapeJSONStrings(w->m_szInitialClass),
             escapeJSONStrings(w->m_szInitialTitle), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"),
             (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format),
             (uintptr_t)w->m_pSwallowed.lock().get(), getFocusHistoryID(w));
@@ -254,7 +254,7 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
             "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\n",
             (uintptr_t)w.get(), w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goal().x, (int)w->m_vRealPosition.goal().y,
             (int)w->m_vRealSize.goal().x, (int)w->m_vRealSize.goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID, (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName),
-            (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->m_iMonitorID, w->m_szClass, w->m_szTitle, w->m_szInitialClass, w->m_szInitialTitle, w->getPID(),
+            (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->monitorID(), w->m_szClass, w->m_szTitle, w->m_szInitialClass, w->m_szInitialTitle, w->getPID(),
             (int)w->m_bIsX11, (int)w->m_bPinned, (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format),
             (uintptr_t)w->m_pSwallowed.lock().get(), getFocusHistoryID(w));
     }
@@ -288,7 +288,7 @@ std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
 
 std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format) {
     const auto PLASTW   = w->getLastFocusedWindow();
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(w->m_iMonitorID);
+    const auto PMONITOR = w->m_pMonitor.lock();
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         return std::format(R"#({{
     "id": {},
diff --git a/src/desktop/LayerSurface.cpp b/src/desktop/LayerSurface.cpp
index 6c024ee0..f073da82 100644
--- a/src/desktop/LayerSurface.cpp
+++ b/src/desktop/LayerSurface.cpp
@@ -26,7 +26,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
 
     pLS->layer     = resource->current.layer;
     pLS->popupHead = std::make_unique<CPopup>(pLS);
-    pLS->monitorID = pMonitor->ID;
+    pLS->monitor   = pMonitor;
     pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);
 
     pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);
@@ -50,7 +50,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
 void CLayerSurface::registerCallbacks() {
     alpha.setUpdateCallback([this](void*) {
         if (dimAround)
-            g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(monitorID));
+            g_pHyprRenderer->damageMonitor(monitor.lock());
     });
 }
 
@@ -82,9 +82,9 @@ CLayerSurface::~CLayerSurface() {
 void CLayerSurface::onDestroy() {
     Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layerSurface.get());
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
-    if (!g_pCompositor->getMonitorFromID(monitorID))
+    if (!PMONITOR)
         Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
 
     if (!fadingOut) {
@@ -137,7 +137,7 @@ void CLayerSurface::onMap() {
     g_pCompositor->removeFromFadingOutSafe(self.lock());
 
     // fix if it changed its mon
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         return;
@@ -197,7 +197,7 @@ void CLayerSurface::onUnmap() {
 
     std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
 
-    if (!g_pCompositor->getMonitorFromID(monitorID) || g_pCompositor->m_bUnsafeState) {
+    if (!monitor || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
 
         g_pCompositor->addToFadingOutSafe(self.lock());
@@ -221,7 +221,7 @@ void CLayerSurface::onUnmap() {
 
     g_pCompositor->addToFadingOutSafe(self.lock());
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
     const bool WASLASTFOCUS = g_pCompositor->m_pLastFocus == surface->resource();
 
@@ -256,13 +256,13 @@ void CLayerSurface::onCommit() {
         if (layerSurface->surface && !layerSurface->surface->current.texture) {
             fadingOut = false;
             geometry  = {};
-            g_pHyprRenderer->arrangeLayersForMonitor(monitorID);
+            g_pHyprRenderer->arrangeLayersForMonitor(monitorID());
         }
 
         return;
     }
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         return;
@@ -336,7 +336,7 @@ void CLayerSurface::onCommit() {
             // moveMouseUnified won't focus non interactive layers but it won't unfocus them either,
             // so unfocus the surface here.
             g_pCompositor->focusSurface(nullptr);
-            g_pInputManager->refocusLastWindow(g_pCompositor->getMonitorFromID(monitorID));
+            g_pInputManager->refocusLastWindow(monitor.lock());
         } else if (!WASEXCLUSIVE && ISEXCLUSIVE) {
             // if now exclusive and not previously
             g_pSeatManager->setGrab(nullptr);
@@ -545,3 +545,7 @@ int CLayerSurface::popupsCount() {
     popupHead->breadthfirst([](CPopup* p, void* data) { *(int*)data += 1; }, &no);
     return no;
 }
+
+MONITORID CLayerSurface::monitorID() {
+    return monitor ? monitor->ID : MONITOR_INVALID;
+}
diff --git a/src/desktop/LayerSurface.hpp b/src/desktop/LayerSurface.hpp
index e0f17039..6aa8eb81 100644
--- a/src/desktop/LayerSurface.hpp
+++ b/src/desktop/LayerSurface.hpp
@@ -42,7 +42,7 @@ class CLayerSurface {
     bool                       mapped = false;
     uint32_t                   layer  = 0;
 
-    MONITORID                  monitorID = -1;
+    PHLMONITORREF              monitor;
 
     bool                       fadingOut     = false;
     bool                       readyToDelete = false;
@@ -70,6 +70,7 @@ class CLayerSurface {
     void                       onMap();
     void                       onUnmap();
     void                       onCommit();
+    MONITORID                  monitorID();
 
   private:
     struct {
@@ -83,6 +84,6 @@ class CLayerSurface {
 
     // For the list lookup
     bool operator==(const CLayerSurface& rhs) const {
-        return layerSurface == rhs.layerSurface && monitorID == rhs.monitorID;
+        return layerSurface == rhs.layerSurface && monitor == rhs.monitor;
     }
 };
diff --git a/src/desktop/Window.cpp b/src/desktop/Window.cpp
index 0772b676..e4f987eb 100644
--- a/src/desktop/Window.cpp
+++ b/src/desktop/Window.cpp
@@ -113,7 +113,7 @@ SBoxExtents CWindow::getFullWindowExtents() {
     const int BORDERSIZE = getRealBorderSize();
 
     if (m_sWindowData.dimAround.valueOrDefault()) {
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID); PMONITOR)
+        if (const auto PMONITOR = m_pMonitor.lock(); PMONITOR)
             return {{m_vRealPosition.value().x - PMONITOR->vecPosition.x, m_vRealPosition.value().y - PMONITOR->vecPosition.y},
                     {PMONITOR->vecSize.x - (m_vRealPosition.value().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_vRealPosition.value().y - PMONITOR->vecPosition.y)}};
     }
@@ -173,7 +173,7 @@ SBoxExtents CWindow::getFullWindowExtents() {
 
 CBox CWindow::getFullWindowBoundingBox() {
     if (m_sWindowData.dimAround.valueOrDefault()) {
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID); PMONITOR)
+        if (const auto PMONITOR = m_pMonitor.lock(); PMONITOR)
             return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
     }
 
@@ -186,7 +186,7 @@ CBox CWindow::getFullWindowBoundingBox() {
 }
 
 CBox CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+    const auto PMONITOR = m_pMonitor.lock();
 
     if (!PMONITOR)
         return {m_vPosition, m_vSize};
@@ -221,7 +221,7 @@ CBox CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
 
 CBox CWindow::getWindowBoxUnified(uint64_t properties) {
     if (m_sWindowData.dimAround.valueOrDefault()) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR = m_pMonitor.lock();
         if (PMONITOR)
             return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
     }
@@ -352,9 +352,9 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) {
 
     const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(m_iLastSurfaceMonitorID);
 
-    m_iLastSurfaceMonitorID = m_iMonitorID;
+    m_iLastSurfaceMonitorID = monitorID();
 
-    const auto PNEWMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+    const auto PNEWMONITOR = m_pMonitor.lock();
 
     if (!PNEWMONITOR)
         return;
@@ -366,10 +366,10 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) {
         m_pWLSurface->resource()->breadthfirst([PNEWMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->enter(PNEWMONITOR->self.lock()); }, nullptr);
     }
 
-    m_pWLSurface->resource()->breadthfirst(
-        [this](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) {
-            const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+    const auto PMONITOR = m_pMonitor.lock();
 
+    m_pWLSurface->resource()->breadthfirst(
+        [PMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) {
             const auto PSURFACE = CWLSurface::fromResource(s);
             if (PSURFACE && PSURFACE->m_fLastScale == PMONITOR->scale)
                 return;
@@ -404,7 +404,7 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
 
     const auto  OLDWORKSPACE = m_pWorkspace;
 
-    m_iMonitorMovedFrom = OLDWORKSPACE ? OLDWORKSPACE->m_iMonitorID : -1;
+    m_iMonitorMovedFrom = OLDWORKSPACE ? OLDWORKSPACE->monitorID() : -1;
     m_fMovingToWorkspaceAlpha.setValueAndWarp(1.F);
     m_fMovingToWorkspaceAlpha = 0.F;
     m_fMovingToWorkspaceAlpha.setCallbackOnEnd([this](void* thisptr) { m_iMonitorMovedFrom = -1; });
@@ -415,11 +415,11 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
 
     g_pCompositor->updateWorkspaceWindows(OLDWORKSPACE->m_iID);
     g_pCompositor->updateWorkspaceWindowData(OLDWORKSPACE->m_iID);
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(OLDWORKSPACE->m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(OLDWORKSPACE->monitorID());
 
     g_pCompositor->updateWorkspaceWindows(workspaceID());
     g_pCompositor->updateWorkspaceWindowData(workspaceID());
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(monitorID());
 
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
@@ -431,14 +431,14 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
 
     if (const auto SWALLOWED = m_pSwallowed.lock()) {
         SWALLOWED->moveToWorkspace(pWorkspace);
-        SWALLOWED->m_iMonitorID = m_iMonitorID;
+        SWALLOWED->m_pMonitor = m_pMonitor;
     }
 
     // update xwayland coords
     g_pXWaylandManager->setWindowSize(m_pSelf.lock(), m_vRealSize.value());
 
     if (OLDWORKSPACE && g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE->m_iID) && g_pCompositor->getWindowsOnWorkspace(OLDWORKSPACE->m_iID) == 0 && *PCLOSEONLASTSPECIAL) {
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(OLDWORKSPACE->m_iMonitorID); PMONITOR)
+        if (const auto PMONITOR = OLDWORKSPACE->m_pMonitor.lock(); PMONITOR)
             PMONITOR->setSpecialWorkspace(nullptr);
     }
 }
@@ -517,19 +517,19 @@ void CWindow::onUnmap() {
     std::erase_if(g_pCompositor->m_vWindowFocusHistory, [&](const auto& other) { return other.expired() || other.lock().get() == this; });
 
     if (*PCLOSEONLASTSPECIAL && g_pCompositor->getWindowsOnWorkspace(workspaceID()) == 0 && onSpecialWorkspace()) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR = m_pMonitor.lock();
         if (PMONITOR && PMONITOR->activeSpecialWorkspace && PMONITOR->activeSpecialWorkspace == m_pWorkspace)
             PMONITOR->setSpecialWorkspace(nullptr);
     }
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+    const auto PMONITOR = m_pMonitor.lock();
 
     if (PMONITOR && PMONITOR->solitaryClient.lock().get() == this)
         PMONITOR->solitaryClient.reset();
 
     g_pCompositor->updateWorkspaceWindows(workspaceID());
     g_pCompositor->updateWorkspaceWindowData(workspaceID());
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(monitorID());
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
     m_pWorkspace.reset();
@@ -790,7 +790,7 @@ void CWindow::updateDynamicRules() {
 
     EMIT_HOOK_EVENT("windowUpdateRules", m_pSelf.lock());
 
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(monitorID());
 }
 
 // check if the point is "hidden" under a rounded corner of the window
@@ -857,7 +857,7 @@ void CWindow::createGroup() {
 
         g_pCompositor->updateWorkspaceWindows(workspaceID());
         g_pCompositor->updateWorkspaceWindowData(workspaceID());
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(monitorID());
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
         g_pEventManager->postEvent(SHyprIPCEvent{"togglegroup", std::format("1,{:x}", (uintptr_t)this)});
@@ -875,7 +875,7 @@ void CWindow::destroyGroup() {
         updateWindowDecos();
         g_pCompositor->updateWorkspaceWindows(workspaceID());
         g_pCompositor->updateWorkspaceWindowData(workspaceID());
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(monitorID());
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
         g_pEventManager->postEvent(SHyprIPCEvent{"togglegroup", std::format("0,{:x}", (uintptr_t)this)});
@@ -911,7 +911,7 @@ void CWindow::destroyGroup() {
 
     g_pCompositor->updateWorkspaceWindows(workspaceID());
     g_pCompositor->updateWorkspaceWindowData(workspaceID());
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(monitorID());
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
     if (!addresses.empty())
@@ -1087,7 +1087,7 @@ void CWindow::updateGroupOutputs() {
     const auto WS = m_pWorkspace;
 
     while (curr.get() != this) {
-        curr->m_iMonitorID = m_iMonitorID;
+        curr->m_pMonitor = m_pMonitor;
         curr->moveToWorkspace(WS);
 
         curr->m_vRealPosition = m_vRealPosition.goal();
@@ -1209,7 +1209,7 @@ void CWindow::onWorkspaceAnimUpdate() {
     if (!PWORKSPACE)
         return;
 
-    const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+    const auto PWSMON = m_pMonitor.lock();
     if (!PWSMON)
         return;
 
@@ -1275,6 +1275,10 @@ WORKSPACEID CWindow::workspaceID() {
     return m_pWorkspace ? m_pWorkspace->m_iID : m_iLastWorkspace;
 }
 
+MONITORID CWindow::monitorID() {
+    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
+}
+
 bool CWindow::onSpecialWorkspace() {
     return m_pWorkspace ? m_pWorkspace->m_bIsSpecialWorkspace : g_pCompositor->isWorkspaceSpecial(m_iLastWorkspace);
 }
@@ -1461,7 +1465,7 @@ void CWindow::onX11Configure(CBox box) {
         m_pXWaylandSurface->configure(box);
         m_vPendingReportedSize = box.size();
         m_vReportedSize        = box.size();
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID); PMONITOR)
+        if (const auto PMONITOR = m_pMonitor.lock(); PMONITOR)
             m_fX11SurfaceScaledBy = PMONITOR->scale;
         return;
     }
@@ -1487,7 +1491,7 @@ void CWindow::onX11Configure(CBox box) {
 
     static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
     if (*PXWLFORCESCALEZERO) {
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID); PMONITOR) {
+        if (const auto PMONITOR = m_pMonitor.lock(); PMONITOR) {
             m_vRealSize.setValueAndWarp(m_vRealSize.goal() / PMONITOR->scale);
             m_fX11SurfaceScaledBy = PMONITOR->scale;
         }
diff --git a/src/desktop/Window.hpp b/src/desktop/Window.hpp
index 64f39558..825e8ca2 100644
--- a/src/desktop/Window.hpp
+++ b/src/desktop/Window.hpp
@@ -272,12 +272,12 @@ class CWindow {
     bool             m_bDraggingTiled   = false; // for dragging around tiled windows
     bool             m_bWasMaximized    = false;
     sFullscreenState m_sFullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
-    MONITORID        m_iMonitorID       = -1;
     std::string      m_szTitle          = "";
     std::string      m_szClass          = "";
     std::string      m_szInitialTitle   = "";
     std::string      m_szInitialClass   = "";
     PHLWORKSPACE     m_pWorkspace;
+    PHLMONITORREF    m_pMonitor;
 
     bool             m_bIsMapped = false;
 
@@ -429,6 +429,7 @@ class CWindow {
     void                   setSuspended(bool suspend);
     bool                   visibleOnMonitor(PHLMONITOR pMonitor);
     WORKSPACEID            workspaceID();
+    MONITORID              monitorID();
     bool                   onSpecialWorkspace();
     void                   activate(bool force = false);
     int                    surfacesCount();
@@ -559,7 +560,7 @@ struct std::formatter<PHLWINDOW, CharT> : std::formatter<CharT> {
         if (formatWorkspace)
             std::format_to(out, ", workspace: {}", w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID);
         if (formatMonitor)
-            std::format_to(out, ", monitor: {}", w->m_iMonitorID);
+            std::format_to(out, ", monitor: {}", w->monitorID());
         if (formatClass)
             std::format_to(out, ", class: {}", w->m_szClass);
         return std::format_to(out, "]");
diff --git a/src/desktop/Workspace.cpp b/src/desktop/Workspace.cpp
index 2d92659c..2e1e91f2 100644
--- a/src/desktop/Workspace.cpp
+++ b/src/desktop/Workspace.cpp
@@ -5,14 +5,14 @@
 #include <hyprutils/string/String.hpp>
 using namespace Hyprutils::String;
 
-PHLWORKSPACE CWorkspace::create(WORKSPACEID id, MONITORID monitorID, std::string name, bool special, bool isEmpty) {
-    PHLWORKSPACE workspace = makeShared<CWorkspace>(id, monitorID, name, special, isEmpty);
+PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) {
+    PHLWORKSPACE workspace = makeShared<CWorkspace>(id, monitor, name, special, isEmpty);
     workspace->init(workspace);
     return workspace;
 }
 
-CWorkspace::CWorkspace(WORKSPACEID id, MONITORID monitorID, std::string name, bool special, bool isEmpty) {
-    m_iMonitorID          = monitorID;
+CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) {
+    m_pMonitor            = monitor;
     m_iID                 = id;
     m_szName              = name;
     m_bIsSpecialWorkspace = special;
@@ -103,7 +103,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     });
 
     if (ANIMSTYLE.starts_with("slidefade")) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR = m_pMonitor.lock();
         float      movePerc = 100.f;
 
         if (ANIMSTYLE.find("%") != std::string::npos) {
@@ -151,7 +151,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
         }
     } else if (ANIMSTYLE == "slidevert") {
         // fallback is slide
-        const auto PMONITOR  = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR  = m_pMonitor.lock();
         const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
 
         m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
@@ -164,7 +164,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
         }
     } else {
         // fallback is slide
-        const auto PMONITOR  = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR  = m_pMonitor.lock();
         const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
 
         m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
@@ -224,7 +224,7 @@ void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
     m_sPrevWorkspace.id   = prev->m_iID;
     m_sPrevWorkspace.name = prev->m_szName;
 
-    if (prev->m_iMonitorID == m_iMonitorID) {
+    if (prev->m_pMonitor == m_pMonitor) {
         m_sPrevWorkspacePerMonitor.id   = prev->m_iID;
         m_sPrevWorkspacePerMonitor.name = prev->m_szName;
     }
@@ -347,7 +347,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto PMONITOR = g_pCompositor->getMonitorFromString(prop);
 
-                if (!(PMONITOR ? PMONITOR->ID == m_iMonitorID : false))
+                if (!(PMONITOR ? PMONITOR == m_pMonitor : false))
                     return false;
                 continue;
             }
@@ -512,12 +512,16 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 }
 
 void CWorkspace::markInert() {
-    m_bInert     = true;
-    m_iID        = WORKSPACE_INVALID;
-    m_iMonitorID = MONITOR_INVALID;
-    m_bVisible   = false;
+    m_bInert   = true;
+    m_iID      = WORKSPACE_INVALID;
+    m_bVisible = false;
+    m_pMonitor.reset();
 }
 
 bool CWorkspace::inert() {
     return m_bInert;
 }
+
+MONITORID CWorkspace::monitorID() {
+    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
+}
diff --git a/src/desktop/Workspace.hpp b/src/desktop/Workspace.hpp
index 7a32459c..3ed9f50c 100644
--- a/src/desktop/Workspace.hpp
+++ b/src/desktop/Workspace.hpp
@@ -17,16 +17,16 @@ class CWindow;
 
 class CWorkspace {
   public:
-    static PHLWORKSPACE create(WORKSPACEID id, MONITORID monitorID, std::string name, bool special = false, bool isEmpty = true);
+    static PHLWORKSPACE create(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special = false, bool isEmpty = true);
     // use create() don't use this
-    CWorkspace(WORKSPACEID id, MONITORID monitorID, std::string name, bool special = false, bool isEmpty = true);
+    CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special = false, bool isEmpty = true);
     ~CWorkspace();
 
     // Workspaces ID-based have IDs > 0
     // and workspaces name-based have IDs starting with -1337
-    WORKSPACEID m_iID        = WORKSPACE_INVALID;
-    std::string m_szName     = "";
-    MONITORID   m_iMonitorID = MONITOR_INVALID;
+    WORKSPACEID   m_iID    = WORKSPACE_INVALID;
+    std::string   m_szName = "";
+    PHLMONITORREF m_pMonitor;
     // Previous workspace ID and name is stored during a workspace change, allowing travel
     // to the previous workspace.
     SWorkspaceIDName m_sPrevWorkspace, m_sPrevWorkspacePerMonitor;
@@ -68,6 +68,7 @@ class CWorkspace {
     void             setActive(bool on);
 
     void             moveToMonitor(const MONITORID&);
+    MONITORID        monitorID();
 
     PHLWINDOW        getLastFocusedWindow();
     void             rememberPrevWorkspace(const PHLWORKSPACE& prevWorkspace);
diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp
index e8abe30d..30d982fb 100644
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -53,7 +53,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PMONITOR = g_pCompositor->m_pLastMonitor.lock();
     }
     auto PWORKSPACE           = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
-    PWINDOW->m_iMonitorID     = PMONITOR->ID;
+    PWINDOW->m_pMonitor       = PMONITOR;
     PWINDOW->m_pWorkspace     = PWORKSPACE;
     PWINDOW->m_bIsMapped      = true;
     PWINDOW->m_bReadyToDelete = false;
@@ -144,18 +144,18 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 const auto MONITORSTR = trim(r.szRule.substr(r.szRule.find(' ')));
 
                 if (MONITORSTR == "unset") {
-                    PWINDOW->m_iMonitorID = PMONITOR->ID;
+                    PWINDOW->m_pMonitor = PMONITOR;
                 } else {
                     if (isNumber(MONITORSTR)) {
                         const MONITORID MONITOR = std::stoi(MONITORSTR);
-                        if (!g_pCompositor->getMonitorFromID(MONITOR))
-                            PWINDOW->m_iMonitorID = 0;
+                        if (const auto PM = g_pCompositor->getMonitorFromID(MONITOR); PM)
+                            PWINDOW->m_pMonitor = PM;
                         else
-                            PWINDOW->m_iMonitorID = MONITOR;
+                            PWINDOW->m_pMonitor = g_pCompositor->m_vMonitors.at(0);
                     } else {
                         const auto PMONITOR = g_pCompositor->getMonitorFromName(MONITORSTR);
                         if (PMONITOR)
-                            PWINDOW->m_iMonitorID = PMONITOR->ID;
+                            PWINDOW->m_pMonitor = PMONITOR;
                         else {
                             Debug::log(ERR, "No monitor in monitor {} rule", MONITORSTR);
                             continue;
@@ -163,10 +163,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     }
                 }
 
-                const auto PMONITORFROMID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+                const auto PMONITORFROMID = PWINDOW->m_pMonitor.lock();
 
-                if (PWINDOW->m_iMonitorID != PMONITOR->ID) {
-                    g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->m_iMonitorID));
+                if (PWINDOW->m_pMonitor != PMONITOR) {
+                    g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID()));
                     PMONITOR = PMONITORFROMID;
                 }
                 PWINDOW->m_pWorkspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
@@ -296,19 +296,19 @@ void Events::listener_mapWindow(void* owner, void* data) {
             auto pWorkspace = g_pCompositor->getWorkspaceByID(REQUESTEDWORKSPACEID);
 
             if (!pWorkspace)
-                pWorkspace = g_pCompositor->createNewWorkspace(REQUESTEDWORKSPACEID, PWINDOW->m_iMonitorID, requestedWorkspaceName);
+                pWorkspace = g_pCompositor->createNewWorkspace(REQUESTEDWORKSPACEID, PWINDOW->monitorID(), requestedWorkspaceName);
 
             PWORKSPACE = pWorkspace;
 
             PWINDOW->m_pWorkspace = pWorkspace;
-            PWINDOW->m_iMonitorID = pWorkspace->m_iMonitorID;
+            PWINDOW->m_pMonitor   = pWorkspace->m_pMonitor;
 
-            if (g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeSpecialWorkspace && !pWorkspace->m_bIsSpecialWorkspace)
+            if (PWINDOW->m_pMonitor.lock()->activeSpecialWorkspace && !pWorkspace->m_bIsSpecialWorkspace)
                 workspaceSilent = true;
 
             if (!workspaceSilent) {
                 if (pWorkspace->m_bIsSpecialWorkspace)
-                    g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID)->setSpecialWorkspace(pWorkspace);
+                    pWorkspace->m_pMonitor->setSpecialWorkspace(pWorkspace);
                 else if (PMONITOR->activeWorkspaceID() != REQUESTEDWORKSPACEID)
                     g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspaceName);
 
@@ -574,7 +574,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         g_pLayoutManager->getCurrentLayout()->onWindowRemoved(SWALLOWER);
         g_pHyprRenderer->damageWindow(SWALLOWER);
         SWALLOWER->setHidden(true);
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->m_iMonitorID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->monitorID());
     }
 
     PWINDOW->m_bFirstMap = false;
@@ -635,7 +635,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         return;
     }
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto PMONITOR = PWINDOW->m_pMonitor.lock();
     if (PMONITOR) {
         PWINDOW->m_vOriginalClosedPos     = PWINDOW->m_vRealPosition.value() - PMONITOR->vecPosition;
         PWINDOW->m_vOriginalClosedSize    = PWINDOW->m_vRealSize.value();
@@ -773,7 +773,7 @@ void Events::listener_commitWindow(void* owner, void* data) {
     if (!PWINDOW->m_pWorkspace->m_bVisible)
         return;
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto PMONITOR = PWINDOW->m_pMonitor.lock();
 
     if (PMONITOR)
         PMONITOR->debugLastPresentation(g_pSeatManager->isPointerFrameCommit ? "listener_commitWindow skip" : "listener_commitWindow");
@@ -911,7 +911,7 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
             PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_pXWaylandSurface->geometry.size());
 
         if (*PXWLFORCESCALEZERO) {
-            if (const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID); PMONITOR) {
+            if (const auto PMONITOR = PWINDOW->m_pMonitor.lock(); PMONITOR) {
                 PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goal() / PMONITOR->scale);
             }
         }
diff --git a/src/helpers/MiscFunctions.cpp b/src/helpers/MiscFunctions.cpp
index 20c79a2b..29861af7 100644
--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -302,7 +302,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
             // Collect all the workspaces we can't jump to.
             for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-                if (ws->m_bIsSpecialWorkspace || (ws->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID)) {
+                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor)) {
                     // Can't jump to this workspace
                     invalidWSes.insert(ws->m_iID);
                 }
@@ -320,7 +320,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             // Prepare all named workspaces in case when we need them
             std::vector<WORKSPACEID> namedWSes;
             for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-                if (ws->m_bIsSpecialWorkspace || (ws->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID) || ws->m_iID >= 0)
+                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor) || ws->m_iID >= 0)
                     continue;
 
                 namedWSes.push_back(ws->m_iID);
@@ -464,7 +464,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
             std::vector<WORKSPACEID> validWSes;
             for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-                if (ws->m_bIsSpecialWorkspace || (ws->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID && !onAllMonitors))
+                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor && !onAllMonitors))
                     continue;
 
                 validWSes.push_back(ws->m_iID);
diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp
index 41290b7d..9e71bf5f 100644
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -314,9 +314,8 @@ void CMonitor::onDisconnect(bool destroy) {
         // move workspaces
         std::deque<PHLWORKSPACE> wspToMove;
         for (auto const& w : g_pCompositor->m_vWorkspaces) {
-            if (w->m_iMonitorID == ID || !g_pCompositor->getMonitorFromID(w->m_iMonitorID)) {
+            if (w->m_pMonitor == self || !w->m_pMonitor)
                 wspToMove.push_back(w);
-            }
         }
 
         for (auto const& w : wspToMove) {
@@ -464,7 +463,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
         if (newDefaultWorkspaceName == "")
             newDefaultWorkspaceName = std::to_string(wsID);
 
-        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(CWorkspace::create(wsID, ID, newDefaultWorkspaceName));
+        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(CWorkspace::create(wsID, self.lock(), newDefaultWorkspaceName));
     }
 
     activeWorkspace = PNEWWORKSPACE;
@@ -541,9 +540,8 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         // move all the WS
         std::deque<PHLWORKSPACE> wspToMove;
         for (auto const& w : g_pCompositor->m_vWorkspaces) {
-            if (w->m_iMonitorID == ID) {
+            if (w->m_pMonitor == self || !w->m_pMonitor)
                 wspToMove.push_back(w);
-            }
         }
 
         for (auto const& w : wspToMove) {
@@ -626,7 +624,7 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         }
 
         if (!noFocus && !g_pCompositor->m_pLastMonitor->activeSpecialWorkspace &&
-            !(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+            !(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_pMonitor == self)) {
             static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
             auto        pWindow      = pWorkspace->getLastFocusedWindow();
 
@@ -687,7 +685,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-        if (!(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+        if (!(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_pMonitor == self)) {
             if (const auto PLAST = activeWorkspace->getLastFocusedWindow(); PLAST)
                 g_pCompositor->focusWindow(PLAST);
             else
@@ -710,7 +708,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
     bool animate = true;
     //close if open elsewhere
-    const auto PMONITORWORKSPACEOWNER = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto PMONITORWORKSPACEOWNER = pWorkspace->m_pMonitor.lock();
     if (PMONITORWORKSPACEOWNER->activeSpecialWorkspace == pWorkspace) {
         PMONITORWORKSPACEOWNER->activeSpecialWorkspace.reset();
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITORWORKSPACEOWNER->ID);
@@ -723,7 +721,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
     }
 
     // open special
-    pWorkspace->m_iMonitorID           = ID;
+    pWorkspace->m_pMonitor             = self;
     activeSpecialWorkspace             = pWorkspace;
     activeSpecialWorkspace->m_bVisible = true;
     if (animate)
@@ -731,7 +729,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
     for (auto const& w : g_pCompositor->m_vWindows) {
         if (w->m_pWorkspace == pWorkspace) {
-            w->m_iMonitorID = ID;
+            w->m_pMonitor = self;
             w->updateSurfaceScaleTransformDetails();
             w->setAnimationsToMove();
 
@@ -755,7 +753,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-    if (!(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+    if (!(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_pMonitor == self)) {
         if (const auto PLAST = pWorkspace->getLastFocusedWindow(); PLAST)
             g_pCompositor->focusWindow(PLAST);
         else
diff --git a/src/layout/DwindleLayout.cpp b/src/layout/DwindleLayout.cpp
index 0fa57143..059dda99 100644
--- a/src/layout/DwindleLayout.cpp
+++ b/src/layout/DwindleLayout.cpp
@@ -111,7 +111,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
             }
         }
     } else
-        PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
+        PMONITOR = g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_pMonitor.lock();
 
     if (!PMONITOR) {
         Debug::log(ERR, "Orphaned Node {}!!", pNode);
@@ -234,7 +234,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
     m_lDwindleNodesData.push_back(SDwindleNodeData());
     const auto  PNODE = &m_lDwindleNodesData.back();
 
-    const auto  PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto  PMONITOR = pWindow->m_pMonitor.lock();
 
     static auto PUSEACTIVE    = CConfigValue<Hyprlang::INT>("dwindle:use_active_for_splits");
     static auto PDEFAULTSPLIT = CConfigValue<Hyprlang::FLOAT>("dwindle:default_split_ratio");
@@ -446,7 +446,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
 
     NEWPARENT->recalcSizePosRecursive(false, horizontalOverride, verticalOverride);
 
-    recalculateMonitor(pWindow->m_iMonitorID);
+    recalculateMonitor(pWindow->monitorID());
 }
 
 void CHyprDwindleLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
@@ -512,7 +512,7 @@ void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) {
 }
 
 void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto PMONITOR = pWorkspace->m_pMonitor.lock();
 
     if (!PMONITOR)
         return;
@@ -577,7 +577,7 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
     static auto PSMARTRESIZING = CConfigValue<Hyprlang::INT>("dwindle:smart_resizing");
 
     // get some data about our window
-    const auto PMONITOR      = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto PMONITOR      = PWINDOW->m_pMonitor.lock();
     const bool DISPLAYLEFT   = STICKS(PWINDOW->m_vPosition.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
     const bool DISPLAYRIGHT  = STICKS(PWINDOW->m_vPosition.x + PWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
     const bool DISPLAYTOP    = STICKS(PWINDOW->m_vPosition.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
@@ -750,7 +750,7 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
 }
 
 void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFullscreenMode CURRENT_EFFECTIVE_MODE, const eFullscreenMode EFFECTIVE_MODE) {
-    const auto PMONITOR   = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR   = pWindow->m_pMonitor.lock();
     const auto PWORKSPACE = pWindow->m_pWorkspace;
 
     // save position and size if floating
@@ -860,9 +860,9 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
 
     const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint);
 
-    if (PMONITORFOCAL->ID != pWindow->m_iMonitorID) {
+    if (PMONITORFOCAL != pWindow->m_pMonitor) {
         pWindow->moveToWorkspace(PMONITORFOCAL->activeWorkspace);
-        pWindow->m_iMonitorID = PMONITORFOCAL->ID;
+        pWindow->m_pMonitor = PMONITORFOCAL;
     }
 
     onWindowCreatedTiling(pWindow);
@@ -900,7 +900,7 @@ void CHyprDwindleLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) {
     PNODE->pWindow  = pWindow2;
 
     if (PNODE->workspaceID != PNODE2->workspaceID) {
-        std::swap(pWindow2->m_iMonitorID, pWindow->m_iMonitorID);
+        std::swap(pWindow2->m_pMonitor, pWindow->m_pMonitor);
         std::swap(pWindow2->m_pWorkspace, pWindow->m_pWorkspace);
     }
 
diff --git a/src/layout/IHyprLayout.cpp b/src/layout/IHyprLayout.cpp
index 454a6132..a3c14e41 100644
--- a/src/layout/IHyprLayout.cpp
+++ b/src/layout/IHyprLayout.cpp
@@ -13,7 +13,7 @@ void IHyprLayout::onWindowCreated(PHLWINDOW pWindow, eDirection direction) {
     g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
 
     if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
-        const auto PMONITOR          = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+        const auto PMONITOR          = pWindow->m_pMonitor.lock();
         pWindow->m_vLastFloatingSize = PMONITOR->vecSize / 2.f;
     } else
         pWindow->m_vLastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
@@ -88,7 +88,7 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
 
     CBox desiredGeometry = {0};
     g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     if (pWindow->m_bIsX11) {
         Vector2D xy       = {desiredGeometry.x, desiredGeometry.y};
@@ -485,7 +485,7 @@ static void performSnap(Vector2D& pos, Vector2D& size, PHLWINDOW DRAGGINGWINDOW,
     }
 
     if (*SNAPMONITORGAP) {
-        const auto   MON = g_pCompositor->getMonitorFromID(DRAGGINGWINDOW->m_iMonitorID);
+        const auto   MON = DRAGGINGWINDOW->m_pMonitor.lock();
         const CBox   mon = {MON->vecPosition.x, MON->vecPosition.y, MON->vecPosition.x + MON->vecSize.x, MON->vecPosition.y + MON->vecSize.y};
         const double gap = *SNAPMONITORGAP;
 
@@ -677,7 +677,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     const auto PMONITOR = g_pCompositor->getMonitorFromVector(middle);
 
     if (PMONITOR && !SPECIAL) {
-        DRAGGINGWINDOW->m_iMonitorID = PMONITOR->ID;
+        DRAGGINGWINDOW->m_pMonitor = PMONITOR;
         DRAGGINGWINDOW->moveToWorkspace(PMONITOR->activeWorkspace);
         DRAGGINGWINDOW->updateGroupOutputs();
 
@@ -705,8 +705,8 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
     EMIT_HOOK_EVENT("changeFloatingMode", pWindow);
 
     if (!TILED) {
-        const auto PNEWMON    = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.value() + pWindow->m_vRealSize.value() / 2.f);
-        pWindow->m_iMonitorID = PNEWMON->ID;
+        const auto PNEWMON  = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.value() + pWindow->m_vRealSize.value() / 2.f);
+        pWindow->m_pMonitor = PNEWMON;
         pWindow->moveToWorkspace(PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace);
         pWindow->updateGroupOutputs();
 
@@ -734,7 +734,7 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
         pWindow->m_vRealSize.setValue(PSAVEDSIZE);
 
         // fix pseudo leaving artifacts
-        g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
+        g_pHyprRenderer->damageMonitor(pWindow->m_pMonitor.lock());
 
         if (pWindow == g_pCompositor->m_pLastWindow)
             m_pLastTiledWindow = pWindow;
@@ -757,7 +757,7 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
         pWindow->m_vSize     = wb.pos();
         pWindow->m_vPosition = wb.size();
 
-        g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
+        g_pHyprRenderer->damageMonitor(pWindow->m_pMonitor.lock());
 
         pWindow->unsetWindowData(PRIORITY_LAYOUT);
         pWindow->updateWindowData();
@@ -847,7 +847,7 @@ PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) {
         pWindowCandidate = g_pCompositor->getFirstWindowOnWorkspace(pWindow->workspaceID());
 
     if (!pWindowCandidate || pWindow == pWindowCandidate || !pWindowCandidate->m_bIsMapped || pWindowCandidate->isHidden() || pWindowCandidate->m_bX11ShouldntFocus ||
-        pWindowCandidate->isX11OverrideRedirect() || pWindowCandidate->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID)
+        pWindowCandidate->isX11OverrideRedirect() || pWindowCandidate->m_pMonitor != g_pCompositor->m_pLastMonitor)
         return nullptr;
 
     return pWindowCandidate;
diff --git a/src/layout/MasterLayout.cpp b/src/layout/MasterLayout.cpp
index 95b5afdf..a2321a41 100644
--- a/src/layout/MasterLayout.cpp
+++ b/src/layout/MasterLayout.cpp
@@ -80,7 +80,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
     static auto PNEWONTOP    = CConfigValue<Hyprlang::INT>("master:new_on_top");
     static auto PNEWSTATUS   = CConfigValue<std::string>("master:new_status");
 
-    const auto  PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto  PMONITOR = pWindow->m_pMonitor.lock();
 
     const bool  BNEWBEFOREACTIVE = *PNEWONACTIVE == "before";
     const bool  BNEWISMASTER     = *PNEWSTATUS == "master";
@@ -229,7 +229,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
     }
 
     // recalc
-    recalculateMonitor(pWindow->m_iMonitorID);
+    recalculateMonitor(pWindow->monitorID());
 }
 
 void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
@@ -279,7 +279,7 @@ void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
             }
         }
     }
-    recalculateMonitor(pWindow->m_iMonitorID);
+    recalculateMonitor(pWindow->monitorID());
 }
 
 void CHyprMasterLayout::recalculateMonitor(const MONITORID& monid) {
@@ -297,7 +297,7 @@ void CHyprMasterLayout::recalculateMonitor(const MONITORID& monid) {
 }
 
 void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto PMONITOR = pWorkspace->m_pMonitor.lock();
 
     if (!PMONITOR)
         return;
@@ -604,7 +604,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
             }
         }
     } else
-        PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
+        PMONITOR = g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_pMonitor.lock();
 
     if (!PMONITOR) {
         Debug::log(ERR, "Orphaned Node {}!!", pNode);
@@ -711,7 +711,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
         return;
     }
 
-    const auto   PMONITOR       = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto   PMONITOR       = PWINDOW->m_pMonitor.lock();
     static auto  ALWAYSCENTER   = CConfigValue<Hyprlang::INT>("master:always_center_master");
     static auto  PSMARTRESIZING = CConfigValue<Hyprlang::INT>("master:smart_resizing");
 
@@ -840,7 +840,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
 }
 
 void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFullscreenMode CURRENT_EFFECTIVE_MODE, const eFullscreenMode EFFECTIVE_MODE) {
-    const auto PMONITOR   = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR   = pWindow->m_pMonitor.lock();
     const auto PWORKSPACE = pWindow->m_pWorkspace;
 
     // save position and size if floating
@@ -896,7 +896,7 @@ void CHyprMasterLayout::recalculateWindow(PHLWINDOW pWindow) {
     if (!PNODE)
         return;
 
-    recalculateMonitor(pWindow->m_iMonitorID);
+    recalculateMonitor(pWindow->monitorID());
 }
 
 SWindowRenderLayoutHints CHyprMasterLayout::requestRenderHints(PHLWINDOW pWindow) {
@@ -922,9 +922,9 @@ void CHyprMasterLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
         // if different monitors, send to monitor
         onWindowRemovedTiling(pWindow);
         pWindow->moveToWorkspace(PWINDOW2->m_pWorkspace);
-        pWindow->m_iMonitorID = PWINDOW2->m_iMonitorID;
+        pWindow->m_pMonitor = PWINDOW2->m_pMonitor;
         if (!silent) {
-            const auto pMonitor = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+            const auto pMonitor = pWindow->m_pMonitor.lock();
             g_pCompositor->setActiveMonitor(pMonitor);
         }
         onWindowCreatedTiling(pWindow);
@@ -946,7 +946,7 @@ void CHyprMasterLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) {
         return;
 
     if (PNODE->workspaceID != PNODE2->workspaceID) {
-        std::swap(pWindow2->m_iMonitorID, pWindow->m_iMonitorID);
+        std::swap(pWindow2->m_pMonitor, pWindow->m_pMonitor);
         std::swap(pWindow2->m_pWorkspace, pWindow->m_pWorkspace);
     }
 
@@ -957,9 +957,9 @@ void CHyprMasterLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) {
     pWindow->setAnimationsToMove();
     pWindow2->setAnimationsToMove();
 
-    recalculateMonitor(pWindow->m_iMonitorID);
+    recalculateMonitor(pWindow->monitorID());
     if (PNODE2->workspaceID != PNODE->workspaceID)
-        recalculateMonitor(pWindow2->m_iMonitorID);
+        recalculateMonitor(pWindow2->monitorID());
 
     g_pHyprRenderer->damageWindow(pWindow);
     g_pHyprRenderer->damageWindow(pWindow2);
@@ -978,7 +978,7 @@ void CHyprMasterLayout::alterSplitRatio(PHLWINDOW pWindow, float ratio, bool exa
     float      newRatio = exact ? ratio : PMASTER->percMaster + ratio;
     PMASTER->percMaster = std::clamp(newRatio, 0.05f, 0.95f);
 
-    recalculateMonitor(pWindow->m_iMonitorID);
+    recalculateMonitor(pWindow->monitorID());
 }
 
 PHLWINDOW CHyprMasterLayout::getNextWindow(PHLWINDOW pWindow, bool next) {
@@ -1185,7 +1185,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             PNODE->isMaster = true;
         }
 
-        recalculateMonitor(header.pWindow->m_iMonitorID);
+        recalculateMonitor(header.pWindow->monitorID());
 
     } else if (command == "removemaster") {
 
@@ -1217,7 +1217,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             PNODE->isMaster = false;
         }
 
-        recalculateMonitor(header.pWindow->m_iMonitorID);
+        recalculateMonitor(header.pWindow->monitorID());
     } else if (command == "orientationleft" || command == "orientationright" || command == "orientationtop" || command == "orientationbottom" || command == "orientationcenter") {
         const auto PWINDOW = header.pWindow;
 
@@ -1239,7 +1239,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         else if (command == "orientationcenter")
             PWORKSPACEDATA->orientation = ORIENTATION_CENTER;
 
-        recalculateMonitor(header.pWindow->m_iMonitorID);
+        recalculateMonitor(header.pWindow->monitorID());
 
     } else if (command == "orientationnext") {
         runOrientationCycle(header, nullptr, 1);
@@ -1274,7 +1274,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             }
         }
 
-        recalculateMonitor(PWINDOW->m_iMonitorID);
+        recalculateMonitor(PWINDOW->monitorID());
     } else if (command == "rollprev") {
         const auto PWINDOW = header.pWindow;
         const auto PNODE   = getNodeFromWindow(PWINDOW);
@@ -1300,7 +1300,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             }
         }
 
-        recalculateMonitor(PWINDOW->m_iMonitorID);
+        recalculateMonitor(PWINDOW->monitorID());
     }
 
     return 0;
@@ -1338,7 +1338,7 @@ void CHyprMasterLayout::runOrientationCycle(SLayoutMessageHeader& header, CVarLi
         nextOrPrev = cycle.size() + (nextOrPrev % (int)cycle.size());
 
     PWORKSPACEDATA->orientation = cycle.at(nextOrPrev);
-    recalculateMonitor(header.pWindow->m_iMonitorID);
+    recalculateMonitor(header.pWindow->monitorID());
 }
 
 void CHyprMasterLayout::buildOrientationCycleVectorFromEOperation(std::vector<eOrientation>& cycle) {
diff --git a/src/managers/AnimationManager.cpp b/src/managers/AnimationManager.cpp
index 9ff7497d..0bdf5a7a 100644
--- a/src/managers/AnimationManager.cpp
+++ b/src/managers/AnimationManager.cpp
@@ -99,12 +99,12 @@ void CAnimationManager::tick() {
                 PDECO->damageEntire();
             }
 
-            PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+            PMONITOR = PWINDOW->m_pMonitor.lock();
             if (!PMONITOR)
                 continue;
             animationsDisabled = PWINDOW->m_sWindowData.noAnim.valueOr(animationsDisabled);
         } else if (PWORKSPACE) {
-            PMONITOR = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+            PMONITOR = PWORKSPACE->m_pMonitor.lock();
             if (!PMONITOR)
                 continue;
 
@@ -325,7 +325,7 @@ void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, boo
     const auto GOALPOS  = pWindow->m_vRealPosition.goal();
     const auto GOALSIZE = pWindow->m_vRealSize.goal();
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     if (!PMONITOR)
         return; // unsafe state most likely
diff --git a/src/managers/KeybindManager.cpp b/src/managers/KeybindManager.cpp
index 9c22fb93..b54b71ed 100644
--- a/src/managers/KeybindManager.cpp
+++ b/src/managers/KeybindManager.cpp
@@ -349,9 +349,9 @@ void CKeybindManager::switchToWindow(PHLWINDOW PWINDOWTOCHANGETO) {
             g_pInputManager->m_pForcedFocus.reset();
         }
 
-        if (PLASTWINDOW && PLASTWINDOW->m_iMonitorID != PWINDOWTOCHANGETO->m_iMonitorID) {
+        if (PLASTWINDOW && PLASTWINDOW->m_pMonitor != PWINDOWTOCHANGETO->m_pMonitor) {
             // event
-            const auto PNEWMON = g_pCompositor->getMonitorFromID(PWINDOWTOCHANGETO->m_iMonitorID);
+            const auto PNEWMON = PWINDOWTOCHANGETO->m_pMonitor.lock();
 
             g_pCompositor->setActiveMonitor(PNEWMON);
         }
@@ -1011,7 +1011,7 @@ static SDispatchResult toggleActiveFloatingCore(std::string args, std::optional<
     }
     g_pCompositor->updateWorkspaceWindows(PWINDOW->workspaceID());
     g_pCompositor->updateWorkspaceWindowData(PWINDOW->workspaceID());
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->m_iMonitorID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->monitorID());
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
     return {};
@@ -1035,7 +1035,7 @@ SDispatchResult CKeybindManager::centerWindow(std::string args) {
     if (!PWINDOW || !PWINDOW->m_bIsFloating || PWINDOW->isFullscreen())
         return {.success = false, .error = "No floating window found"};
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto PMONITOR = PWINDOW->m_pMonitor.lock();
 
     auto       RESERVEDOFFSET = Vector2D();
     if (args == "1")
@@ -1081,7 +1081,7 @@ SWorkspaceIDName getWorkspaceToChangeFromArgs(std::string args, PHLWORKSPACE PCU
 
     const auto ID = PCURRENTWORKSPACE->m_iID;
     if (const auto PWORKSPACETOCHANGETO = g_pCompositor->getWorkspaceByID(PPREVWS.id); PWORKSPACETOCHANGETO) {
-        if (PER_MON && PCURRENTWORKSPACE->m_iMonitorID != PWORKSPACETOCHANGETO->m_iMonitorID)
+        if (PER_MON && PCURRENTWORKSPACE->m_pMonitor != PWORKSPACETOCHANGETO->m_pMonitor)
             return {WORKSPACE_NOT_CHANGED, ""};
         return {ID, PWORKSPACETOCHANGETO->m_szName};
     }
@@ -1135,7 +1135,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) {
 
     g_pInputManager->releaseAllMouseButtons();
 
-    const auto PMONITORWORKSPACEOWNER = PMONITOR->ID == pWorkspaceToChangeTo->m_iMonitorID ? PMONITOR : g_pCompositor->getMonitorFromID(pWorkspaceToChangeTo->m_iMonitorID);
+    const auto PMONITORWORKSPACEOWNER = PMONITOR == pWorkspaceToChangeTo->m_pMonitor ? PMONITOR : pWorkspaceToChangeTo->m_pMonitor.lock();
 
     if (!PMONITORWORKSPACEOWNER)
         return {.success = false, .error = "Workspace to switch to has no monitor"};
@@ -1270,11 +1270,11 @@ SDispatchResult CKeybindManager::moveActiveToWorkspace(std::string args) {
 
     if (pWorkspace) {
         g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, pWorkspace);
-        pMonitor = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+        pMonitor = pWorkspace->m_pMonitor.lock();
         g_pCompositor->setActiveMonitor(pMonitor);
     } else {
-        pWorkspace = g_pCompositor->createNewWorkspace(WORKSPACEID, PWINDOW->m_iMonitorID, workspaceName, false);
-        pMonitor   = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+        pWorkspace = g_pCompositor->createNewWorkspace(WORKSPACEID, PWINDOW->monitorID(), workspaceName, false);
+        pMonitor   = pWorkspace->m_pMonitor.lock();
         g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, pWorkspace);
     }
 
@@ -1283,7 +1283,7 @@ SDispatchResult CKeybindManager::moveActiveToWorkspace(std::string args) {
     if (pWorkspace->m_bIsSpecialWorkspace)
         pMonitor->setSpecialWorkspace(pWorkspace);
     else if (POLDWS->m_bIsSpecialWorkspace)
-        g_pCompositor->getMonitorFromID(POLDWS->m_iMonitorID)->setSpecialWorkspace(nullptr);
+        POLDWS->m_pMonitor.lock()->setSpecialWorkspace(nullptr);
 
     if (*PALLOWWORKSPACECYCLES)
         pWorkspace->rememberPrevWorkspace(POLDWS);
@@ -1328,7 +1328,7 @@ SDispatchResult CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
     if (pWorkspace) {
         g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, pWorkspace);
     } else {
-        pWorkspace = g_pCompositor->createNewWorkspace(WORKSPACEID, PWINDOW->m_iMonitorID, workspaceName, false);
+        pWorkspace = g_pCompositor->createNewWorkspace(WORKSPACEID, PWINDOW->monitorID(), workspaceName, false);
         g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, pWorkspace);
     }
 
@@ -1475,7 +1475,7 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
 
     if (PLASTWINDOW->m_bIsFloating) {
         std::optional<float> vPosx, vPosy;
-        const auto           PMONITOR   = g_pCompositor->getMonitorFromID(PLASTWINDOW->m_iMonitorID);
+        const auto           PMONITOR   = PLASTWINDOW->m_pMonitor.lock();
         const auto           BORDERSIZE = PLASTWINDOW->getRealBorderSize();
 
         switch (arg) {
@@ -1882,8 +1882,8 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args
         workspaceID = pWorkspace->m_iID;
     }
 
-    if (pWorkspace->m_iMonitorID != PCURRMONITOR->ID) {
-        const auto POLDMONITOR = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    if (pWorkspace->m_pMonitor != PCURRMONITOR) {
+        const auto POLDMONITOR = pWorkspace->m_pMonitor.lock();
         if (!POLDMONITOR) { // wat
             Debug::log(ERR, "focusWorkspaceOnCurrentMonitor old monitor doesn't exist!");
             return {.success = false, .error = "focusWorkspaceOnCurrentMonitor old monitor doesn't exist!"};
@@ -2509,7 +2509,7 @@ SDispatchResult CKeybindManager::pinActive(std::string args) {
 
     PWINDOW->m_bPinned = !PWINDOW->m_bPinned;
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto PMONITOR = PWINDOW->m_pMonitor.lock();
 
     if (!PMONITOR) {
         Debug::log(ERR, "pin: monitor not found");
@@ -2658,9 +2658,9 @@ void CKeybindManager::moveWindowIntoGroup(PHLWINDOW pWindow, PHLWINDOW pWindowIn
 
     g_pLayoutManager->getCurrentLayout()->onWindowRemoved(pWindow); // This removes groupped property!
 
-    if (pWindow->m_iMonitorID != pWindowInDirection->m_iMonitorID) {
+    if (pWindow->m_pMonitor != pWindowInDirection->m_pMonitor) {
         pWindow->moveToWorkspace(pWindowInDirection->m_pWorkspace);
-        pWindow->m_iMonitorID = pWindowInDirection->m_iMonitorID;
+        pWindow->m_pMonitor = pWindowInDirection->m_pMonitor;
     }
 
     static auto USECURRPOS = CConfigValue<Hyprlang::INT>("group:insert_after_current");
diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp
index 7b3081a2..d0dda8e6 100644
--- a/src/managers/XWaylandManager.cpp
+++ b/src/managers/XWaylandManager.cpp
@@ -117,7 +117,7 @@ void CHyprXWaylandManager::setWindowSize(PHLWINDOW pWindow, Vector2D size, bool
 
     static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
 
-    const auto  PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto  PMONITOR = pWindow->m_pMonitor.lock();
 
     size = size.clamp(Vector2D{0, 0}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
 
diff --git a/src/managers/input/Swipe.cpp b/src/managers/input/Swipe.cpp
index 8f95c6c6..ba0783fa 100644
--- a/src/managers/input/Swipe.cpp
+++ b/src/managers/input/Swipe.cpp
@@ -15,9 +15,8 @@ void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) {
 
     int onMonitor = 0;
     for (auto const& w : g_pCompositor->m_vWorkspaces) {
-        if (w->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID && !g_pCompositor->isWorkspaceSpecial(w->m_iID)) {
+        if (w->m_pMonitor == g_pCompositor->m_pLastMonitor && !g_pCompositor->isWorkspaceSpecial(w->m_iID))
             onMonitor++;
-        }
     }
 
     if (onMonitor < 2 && !*PSWIPENEW)
diff --git a/src/managers/input/Touch.cpp b/src/managers/input/Touch.cpp
index 454391af..4e3980aa 100644
--- a/src/managers/input/Touch.cpp
+++ b/src/managers/input/Touch.cpp
@@ -123,7 +123,7 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
         return;
     }
     if (validMapped(m_sTouchData.touchFocusWindow)) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusWindow->m_iMonitorID);
+        const auto PMONITOR = m_sTouchData.touchFocusWindow->m_pMonitor.lock();
 
         g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true);
 
@@ -133,7 +133,7 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
 
         g_pSeatManager->sendTouchMotion(e.timeMs, e.touchID, local);
     } else if (!m_sTouchData.touchFocusLS.expired()) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusLS->monitorID);
+        const auto PMONITOR = m_sTouchData.touchFocusLS->monitor.lock();
 
         g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true);
 
diff --git a/src/protocols/ForeignToplevelWlr.cpp b/src/protocols/ForeignToplevelWlr.cpp
index ffc335c9..06814c88 100644
--- a/src/protocols/ForeignToplevelWlr.cpp
+++ b/src/protocols/ForeignToplevelWlr.cpp
@@ -207,7 +207,7 @@ void CForeignToplevelWlrManager::onMap(PHLWINDOW pWindow) {
     resource->sendToplevel(NEWHANDLE->resource.get());
     NEWHANDLE->resource->sendAppId(pWindow->m_szClass.c_str());
     NEWHANDLE->resource->sendTitle(pWindow->m_szTitle.c_str());
-    if (const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID); PMONITOR)
+    if (const auto PMONITOR = pWindow->m_pMonitor.lock(); PMONITOR)
         NEWHANDLE->sendMonitor(PMONITOR);
     NEWHANDLE->sendState();
     NEWHANDLE->resource->sendDone();
@@ -266,7 +266,7 @@ void CForeignToplevelWlrManager::onMoveMonitor(PHLWINDOW pWindow) {
     if (!H || H->closed)
         return;
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     if (!PMONITOR)
         return;
diff --git a/src/protocols/LinuxDMABUF.cpp b/src/protocols/LinuxDMABUF.cpp
index e81d7e01..7b2bcbf4 100644
--- a/src/protocols/LinuxDMABUF.cpp
+++ b/src/protocols/LinuxDMABUF.cpp
@@ -509,7 +509,7 @@ void CLinuxDMABufV1Protocol::resetFormatTable() {
             PHLMONITOR mon;
             auto       HLSurface = CWLSurface::fromResource(feedback->surface);
             if (auto w = HLSurface->getWindow(); w)
-                if (auto m = g_pCompositor->getMonitorFromID(w->m_iMonitorID); m)
+                if (auto m = w->m_pMonitor.lock(); m)
                     mon = m->self.lock();
 
             if (!mon) {
diff --git a/src/protocols/ToplevelExport.cpp b/src/protocols/ToplevelExport.cpp
index 8b6208be..f2af89db 100644
--- a/src/protocols/ToplevelExport.cpp
+++ b/src/protocols/ToplevelExport.cpp
@@ -97,7 +97,7 @@ CToplevelExportFrame::CToplevelExportFrame(SP<CHyprlandToplevelExportFrameV1> re
     resource->setDestroy([this](CHyprlandToplevelExportFrameV1* pFrame) { PROTO::toplevelExport->destroyResource(this); });
     resource->setCopy([this](CHyprlandToplevelExportFrameV1* pFrame, wl_resource* res, int32_t ignoreDamage) { this->copy(pFrame, res, ignoreDamage); });
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     g_pHyprRenderer->makeEGLCurrent();
 
@@ -239,7 +239,7 @@ bool CToplevelExportFrame::copyShm(timespec* now) {
     auto [pixelData, fmt, bufLen] = buffer->beginDataPtr(0); // no need for end, cuz it's shm
 
     // render the client
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
     CRegion    fakeDamage{0, 0, PMONITOR->vecPixelSize.x * 10, PMONITOR->vecPixelSize.y * 10};
 
     g_pHyprRenderer->makeEGLCurrent();
@@ -296,7 +296,7 @@ bool CToplevelExportFrame::copyShm(timespec* now) {
 }
 
 bool CToplevelExportFrame::copyDmabuf(timespec* now) {
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     CRegion    fakeDamage{0, 0, INT16_MAX, INT16_MAX};
 
@@ -383,7 +383,7 @@ void CToplevelExportProtocol::onOutputCommit(PHLMONITOR pMonitor) {
 
         const auto PWINDOW = f->pWindow;
 
-        if (pMonitor != g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID))
+        if (pMonitor != PWINDOW->m_pMonitor.lock())
             continue;
 
         CBox geometry = {PWINDOW->m_vRealPosition.value().x, PWINDOW->m_vRealPosition.value().y, PWINDOW->m_vRealSize.value().x, PWINDOW->m_vRealSize.value().y};
diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp
index fc2d1012..9e524fa4 100644
--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -693,7 +693,7 @@ bool CHyprOpenGLImpl::passRequiresIntrospection(PHLMONITOR pMonitor) {
 
     if (*PBLURSPECIAL) {
         for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-            if (!ws->m_bIsSpecialWorkspace || ws->m_iMonitorID != pMonitor->ID)
+            if (!ws->m_bIsSpecialWorkspace || ws->m_pMonitor != pMonitor)
                 continue;
 
             if (ws->m_fAlpha.value() == 0)
@@ -2219,7 +2219,7 @@ void CHyprOpenGLImpl::renderBorder(CBox* box, const CGradientValueData& grad, in
 
 void CHyprOpenGLImpl::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFramebuffer) {
     // we trust the window is valid.
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0)
         return;
@@ -2267,7 +2267,7 @@ void CHyprOpenGLImpl::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFr
 
 void CHyprOpenGLImpl::makeWindowSnapshot(PHLWINDOW pWindow) {
     // we trust the window is valid.
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0)
         return;
@@ -2319,7 +2319,7 @@ void CHyprOpenGLImpl::makeWindowSnapshot(PHLWINDOW pWindow) {
 
 void CHyprOpenGLImpl::makeLayerSnapshot(PHLLS pLayer) {
     // we trust the window is valid.
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pLayer->monitorID);
+    const auto PMONITOR = pLayer->monitor.lock();
 
     if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0)
         return;
@@ -2372,7 +2372,7 @@ void CHyprOpenGLImpl::renderSnapshot(PHLWINDOW pWindow) {
     if (!FBDATA->m_cTex->m_iTexID)
         return;
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = pWindow->m_pMonitor.lock();
 
     CBox       windowBox;
     // some mafs to figure out the correct box
@@ -2411,7 +2411,7 @@ void CHyprOpenGLImpl::renderSnapshot(PHLLS pLayer) {
     if (!FBDATA->m_cTex->m_iTexID)
         return;
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pLayer->monitorID);
+    const auto PMONITOR = pLayer->monitor.lock();
 
     CBox       layerBox;
     // some mafs to figure out the correct box
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index c69167c8..1c38eb4e 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -314,7 +314,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
         return true;
 
     const auto PWINDOWWORKSPACE = pWindow->m_pWorkspace;
-    if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_iMonitorID == pMonitor->ID) {
+    if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_pMonitor == pMonitor) {
         if (PWINDOWWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWINDOWWORKSPACE->m_fAlpha.isBeingAnimated() || PWINDOWWORKSPACE->m_bForceRendering)
             return true;
 
@@ -327,10 +327,10 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
             return false;
     }
 
-    if (pWindow->m_iMonitorID == pMonitor->ID)
+    if (pWindow->m_pMonitor == pMonitor)
         return true;
 
-    if (!g_pCompositor->isWorkspaceVisible(pWindow->m_pWorkspace) && pWindow->m_iMonitorID != pMonitor->ID)
+    if (!g_pCompositor->isWorkspaceVisible(pWindow->m_pWorkspace) && pWindow->m_pMonitor != pMonitor)
         return false;
 
     // if not, check if it maybe is active on a different monitor.
@@ -341,7 +341,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
         return true;
 
     // if window is tiled and it's flying in, don't render on other mons (for slide)
-    if (!pWindow->m_bIsFloating && pWindow->m_vRealPosition.isBeingAnimated() && pWindow->m_bAnimatingIn && pWindow->m_iMonitorID != pMonitor->ID)
+    if (!pWindow->m_bIsFloating && pWindow->m_vRealPosition.isBeingAnimated() && pWindow->m_bAnimatingIn && pWindow->m_pMonitor != pMonitor)
         return false;
 
     if (pWindow->m_vRealPosition.isBeingAnimated()) {
@@ -379,7 +379,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow) {
         return true;
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        if (PWORKSPACE && PWORKSPACE->m_iMonitorID == m->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated()))
+        if (PWORKSPACE && PWORKSPACE->m_pMonitor == m && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated()))
             return true;
 
         if (m->activeSpecialWorkspace && pWindow->onSpecialWorkspace())
@@ -422,10 +422,10 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR
         if (w->isFullscreen() || !w->m_bIsFloating)
             continue;
 
-        if (w->m_iMonitorID == pWorkspace->m_iMonitorID && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
+        if (w->m_pMonitor == pWorkspace->m_pMonitor && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
             continue;
 
-        if (pWorkspace->m_bIsSpecialWorkspace && w->m_iMonitorID != pWorkspace->m_iMonitorID)
+        if (pWorkspace->m_bIsSpecialWorkspace && w->m_pMonitor != pWorkspace->m_pMonitor)
             continue; // special on another are rendered as a part of the base pass
 
         renderWindow(w, pMonitor, time, true, RENDER_PASS_ALL);
@@ -439,14 +439,14 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR
             if (!(PWORKSPACE && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated() || PWORKSPACE->m_bForceRendering)))
                 continue;
 
-            if (w->m_iMonitorID != pMonitor->ID)
+            if (w->m_pMonitor != pMonitor)
                 continue;
         }
 
         if (!w->isFullscreen())
             continue;
 
-        if (w->m_iMonitorID == pWorkspace->m_iMonitorID && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
+        if (w->m_pMonitor == pWorkspace->m_pMonitor && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
             continue;
 
         if (shouldRenderWindow(w, pMonitor))
@@ -469,10 +469,10 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR
         if (w->m_pWorkspace != pWorkspaceWindow->m_pWorkspace || (!w->m_bCreatedOverFullscreen && !w->m_bPinned) || (!w->m_bIsMapped && !w->m_bFadingOut) || w->isFullscreen())
             continue;
 
-        if (w->m_iMonitorID == pWorkspace->m_iMonitorID && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
+        if (w->m_pMonitor == pWorkspace->m_pMonitor && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
             continue;
 
-        if (pWorkspace->m_bIsSpecialWorkspace && w->m_iMonitorID != pWorkspace->m_iMonitorID)
+        if (pWorkspace->m_bIsSpecialWorkspace && w->m_pMonitor != pWorkspace->m_pMonitor)
             continue; // special on another are rendered as a part of the base pass
 
         renderWindow(w, pMonitor, time, true, RENDER_PASS_ALL);
@@ -543,7 +543,7 @@ void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWo
         if (pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace())
             continue;
 
-        if (pWorkspace->m_bIsSpecialWorkspace && w->m_iMonitorID != pWorkspace->m_iMonitorID)
+        if (pWorkspace->m_bIsSpecialWorkspace && w->m_pMonitor != pWorkspace->m_pMonitor)
             continue; // special on another are rendered as a part of the base pass
 
         // render the bad boy
@@ -556,7 +556,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, timespe
         return;
 
     if (pWindow->m_bFadingOut) {
-        if (pMonitor->ID == pWindow->m_iMonitorID) // TODO: fix this
+        if (pMonitor == pWindow->m_pMonitor) // TODO: fix this
             g_pHyprOpenGL->renderSnapshot(pWindow);
         return;
     }
@@ -965,7 +965,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
 
     // and then special
     for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-        if (ws->m_iMonitorID == pMonitor->ID && ws->m_fAlpha.value() > 0.f && ws->m_bIsSpecialWorkspace) {
+        if (ws->m_pMonitor == pMonitor && ws->m_fAlpha.value() > 0.f && ws->m_bIsSpecialWorkspace) {
             const auto SPECIALANIMPROGRS = ws->m_vRenderOffset.isBeingAnimated() ? ws->m_vRenderOffset.getCurveValue() : ws->m_fAlpha.getCurveValue();
             const bool ANIMOUT           = !pMonitor->activeSpecialWorkspace;
 
@@ -2533,7 +2533,7 @@ void CHyprRenderer::initiateManualCrash() {
 void CHyprRenderer::setOccludedForMainWorkspace(CRegion& region, PHLWORKSPACE pWorkspace) {
     CRegion    rg;
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto PMONITOR = pWorkspace->m_pMonitor.lock();
 
     if (!PMONITOR->activeSpecialWorkspace)
         return;
@@ -2562,7 +2562,7 @@ void CHyprRenderer::setOccludedForMainWorkspace(CRegion& region, PHLWORKSPACE pW
 void CHyprRenderer::setOccludedForBackLayers(CRegion& region, PHLWORKSPACE pWorkspace) {
     CRegion     rg;
 
-    const auto  PMONITOR = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    const auto  PMONITOR = pWorkspace->m_pMonitor.lock();
 
     static auto PBLUR       = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
     static auto PBLURSIZE   = CConfigValue<Hyprlang::INT>("decoration:blur:size");