diff --git a/src/Compositor.cpp b/src/Compositor.cpp
index ca27f17a..b23b3194 100644
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -412,8 +412,8 @@ void CCompositor::initAllSignals() {
                     m_bSessionActive = true;
 
                     for (auto const& m : m_vMonitors) {
-                        scheduleFrameForMonitor(m.get());
-                        g_pHyprRenderer->applyMonitorRule(m.get(), &m->activeMonitorRule, true);
+                        scheduleFrameForMonitor(m);
+                        g_pHyprRenderer->applyMonitorRule(m, &m->activeMonitorRule, true);
                     }
 
                     g_pConfigManager->m_bWantsMonitorReload = true;
@@ -498,7 +498,7 @@ void CCompositor::cleanup() {
     m_vWindows.clear();
 
     for (auto const& m : m_vMonitors) {
-        g_pHyprOpenGL->destroyMonitorResources(m.get());
+        g_pHyprOpenGL->destroyMonitorResources(m);
 
         m->output->state->setEnabled(false);
         m->state.commit();
@@ -717,38 +717,38 @@ void CCompositor::startCompositor() {
     g_pEventLoopManager->enterLoop();
 }
 
-CMonitor* CCompositor::getMonitorFromID(const MONITORID& id) {
+PHLMONITOR CCompositor::getMonitorFromID(const MONITORID& id) {
     for (auto const& m : m_vMonitors) {
         if (m->ID == id) {
-            return m.get();
+            return m;
         }
     }
 
     return nullptr;
 }
 
-CMonitor* CCompositor::getMonitorFromName(const std::string& name) {
+PHLMONITOR CCompositor::getMonitorFromName(const std::string& name) {
     for (auto const& m : m_vMonitors) {
         if (m->szName == name) {
-            return m.get();
+            return m;
         }
     }
     return nullptr;
 }
 
-CMonitor* CCompositor::getMonitorFromDesc(const std::string& desc) {
+PHLMONITOR CCompositor::getMonitorFromDesc(const std::string& desc) {
     for (auto const& m : m_vMonitors) {
         if (m->szDescription.starts_with(desc))
-            return m.get();
+            return m;
     }
     return nullptr;
 }
 
-CMonitor* CCompositor::getMonitorFromCursor() {
+PHLMONITOR CCompositor::getMonitorFromCursor() {
     return getMonitorFromVector(g_pPointerManager->position());
 }
 
-CMonitor* CCompositor::getMonitorFromVector(const Vector2D& point) {
+PHLMONITOR CCompositor::getMonitorFromVector(const Vector2D& point) {
     SP<CMonitor> mon;
     for (auto const& m : m_vMonitors) {
         if (CBox{m->vecPosition, m->vecSize}.containsPoint(point)) {
@@ -772,13 +772,13 @@ CMonitor* CCompositor::getMonitorFromVector(const Vector2D& point) {
 
         if (!pBestMon) { // ?????
             Debug::log(WARN, "getMonitorFromVector no close mon???");
-            return m_vMonitors.front().get();
+            return m_vMonitors.front();
         }
 
-        return pBestMon.get();
+        return pBestMon;
     }
 
-    return mon.get();
+    return mon;
 }
 
 void CCompositor::removeWindowFromVectorSafe(PHLWINDOW pWindow) {
@@ -790,9 +790,9 @@ void CCompositor::removeWindowFromVectorSafe(PHLWINDOW pWindow) {
     }
 }
 
-bool CCompositor::monitorExists(CMonitor* pMonitor) {
+bool CCompositor::monitorExists(PHLMONITOR pMonitor) {
     for (auto const& m : m_vRealMonitors) {
-        if (m.get() == pMonitor)
+        if (m == pMonitor)
             return true;
     }
 
@@ -982,20 +982,20 @@ Vector2D CCompositor::vectorToSurfaceLocal(const Vector2D& vec, PHLWINDOW pWindo
     return vec - pWindow->m_vRealPosition.goal() - std::get<1>(iterData) + Vector2D{geom.x, geom.y};
 }
 
-CMonitor* CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
+PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
     for (auto const& m : m_vMonitors) {
         if (m->output == out) {
-            return m.get();
+            return m;
         }
     }
 
     return nullptr;
 }
 
-CMonitor* CCompositor::getRealMonitorFromOutput(SP<Aquamarine::IOutput> out) {
+PHLMONITOR CCompositor::getRealMonitorFromOutput(SP<Aquamarine::IOutput> out) {
     for (auto const& m : m_vRealMonitors) {
         if (m->output == out) {
-            return m.get();
+            return m;
         }
     }
 
@@ -1183,7 +1183,7 @@ void CCompositor::focusSurface(SP<CWLSurfaceResource> pSurface, PHLWINDOW pWindo
         SURF->constraint()->activate();
 }
 
-SP<CWLSurfaceResource> CCompositor::vectorToLayerPopupSurface(const Vector2D& pos, CMonitor* monitor, Vector2D* sCoords, PHLLS* ppLayerSurfaceFound) {
+SP<CWLSurfaceResource> CCompositor::vectorToLayerPopupSurface(const Vector2D& pos, PHLMONITOR monitor, Vector2D* sCoords, PHLLS* ppLayerSurfaceFound) {
     for (auto const& lsl : monitor->m_aLayerSurfaceLayers | std::views::reverse) {
         for (auto const& ls : lsl | std::views::reverse) {
             if (ls->fadingOut || !ls->layerSurface || (ls->layerSurface && !ls->layerSurface->mapped) || ls->alpha.value() == 0.f)
@@ -1779,7 +1779,7 @@ bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
     return false;
 }
 
-bool CCompositor::isPointOnReservedArea(const Vector2D& point, const CMonitor* pMonitor) {
+bool CCompositor::isPointOnReservedArea(const Vector2D& point, const PHLMONITOR pMonitor) {
     const auto PMONITOR = pMonitor ? pMonitor : getMonitorFromVector(point);
 
     const auto XY1 = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
@@ -1788,11 +1788,11 @@ bool CCompositor::isPointOnReservedArea(const Vector2D& point, const CMonitor* p
     return !VECINRECT(point, XY1.x, XY1.y, XY2.x, XY2.y);
 }
 
-CMonitor* CCompositor::getMonitorInDirection(const char& dir) {
-    return this->getMonitorInDirection(m_pLastMonitor.get(), dir);
+PHLMONITOR CCompositor::getMonitorInDirection(const char& dir) {
+    return getMonitorInDirection(m_pLastMonitor.lock(), dir);
 }
 
-CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const char& dir) {
+PHLMONITOR CCompositor::getMonitorInDirection(PHLMONITOR pSourceMonitor, const char& dir) {
     if (!pSourceMonitor)
         return nullptr;
 
@@ -1800,7 +1800,7 @@ CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const cha
     const auto SIZEA = pSourceMonitor->vecSize;
 
     auto       longestIntersect        = -1;
-    CMonitor*  longestIntersectMonitor = nullptr;
+    PHLMONITOR longestIntersectMonitor = nullptr;
 
     for (auto const& m : m_vMonitors) {
         if (m == m_pLastMonitor)
@@ -1814,7 +1814,7 @@ CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const cha
                     const auto INTERSECTLEN = std::max(0.0, std::min(POSA.y + SIZEA.y, POSB.y + SIZEB.y) - std::max(POSA.y, POSB.y));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect        = INTERSECTLEN;
-                        longestIntersectMonitor = m.get();
+                        longestIntersectMonitor = m;
                     }
                 }
                 break;
@@ -1823,7 +1823,7 @@ CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const cha
                     const auto INTERSECTLEN = std::max(0.0, std::min(POSA.y + SIZEA.y, POSB.y + SIZEB.y) - std::max(POSA.y, POSB.y));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect        = INTERSECTLEN;
-                        longestIntersectMonitor = m.get();
+                        longestIntersectMonitor = m;
                     }
                 }
                 break;
@@ -1833,7 +1833,7 @@ CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const cha
                     const auto INTERSECTLEN = std::max(0.0, std::min(POSA.x + SIZEA.x, POSB.x + SIZEB.x) - std::max(POSA.x, POSB.x));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect        = INTERSECTLEN;
-                        longestIntersectMonitor = m.get();
+                        longestIntersectMonitor = m;
                     }
                 }
                 break;
@@ -1843,7 +1843,7 @@ CMonitor* CCompositor::getMonitorInDirection(CMonitor* pSourceMonitor, const cha
                     const auto INTERSECTLEN = std::max(0.0, std::min(POSA.x + SIZEA.x, POSB.x + SIZEB.x) - std::max(POSA.x, POSB.x));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect        = INTERSECTLEN;
-                        longestIntersectMonitor = m.get();
+                        longestIntersectMonitor = m;
                     }
                 }
                 break;
@@ -1990,7 +1990,7 @@ MONITORID CCompositor::getNextAvailableMonitorID(std::string const& name) {
     return nextID;
 }
 
-void CCompositor::swapActiveWorkspaces(CMonitor* pMonitorA, CMonitor* pMonitorB) {
+void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitorB) {
 
     const auto PWORKSPACEA = pMonitorA->activeWorkspace;
     const auto PWORKSPACEB = pMonitorB->activeWorkspace;
@@ -2077,16 +2077,16 @@ void CCompositor::swapActiveWorkspaces(CMonitor* pMonitorA, CMonitor* pMonitorB)
     EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEB, pMonitorA}));
 }
 
-CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
+PHLMONITOR CCompositor::getMonitorFromString(const std::string& name) {
     if (name == "current")
-        return g_pCompositor->m_pLastMonitor.get();
+        return g_pCompositor->m_pLastMonitor.lock();
     else if (isDirection(name))
         return getMonitorInDirection(name[0]);
     else if (name[0] == '+' || name[0] == '-') {
         // relative
 
         if (m_vMonitors.size() == 1)
-            return m_vMonitors.begin()->get();
+            return *m_vMonitors.begin();
 
         const auto OFFSET = name[0] == '-' ? name : name.substr(1);
 
@@ -2119,7 +2119,7 @@ CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
             currentPlace = std::clamp(currentPlace, 0, (int)m_vMonitors.size() - 1);
         }
 
-        return m_vMonitors[currentPlace].get();
+        return m_vMonitors[currentPlace];
     } else if (isNumber(name)) {
         // change by ID
         MONITORID monID = MONITOR_INVALID;
@@ -2143,7 +2143,7 @@ CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
                 continue;
 
             if (m->matchesStaticSelector(name)) {
-                return m.get();
+                return m;
             }
         }
     }
@@ -2151,7 +2151,7 @@ CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
     return nullptr;
 }
 
-void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, CMonitor* pMonitor, bool noWarpCursor) {
+void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMonitor, bool noWarpCursor) {
 
     // We trust the monitor to be correct.
 
@@ -2226,7 +2226,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, CMonitor* pMon
         }
     }
 
-    if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_pLastMonitor.get()) { // if it was active, preserve its' status. If it wasn't, don't.
+    if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_pLastMonitor) { // if it was active, preserve its' status. If it wasn't, don't.
         Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_iID);
 
         if (valid(pMonitor->activeWorkspace)) {
@@ -2438,7 +2438,7 @@ void CCompositor::updateWorkspaceWindowData(const WORKSPACEID& id) {
     }
 }
 
-void CCompositor::scheduleFrameForMonitor(CMonitor* pMonitor, IOutput::scheduleFrameReason reason) {
+void CCompositor::scheduleFrameForMonitor(PHLMONITOR pMonitor, IOutput::scheduleFrameReason reason) {
     if ((m_pAqBackend->hasSession() && !m_pAqBackend->session->active) || !m_bSessionActive)
         return;
 
@@ -2555,7 +2555,7 @@ void CCompositor::warpCursorTo(const Vector2D& pos, bool force) {
 
     if (*PNOWARPS && !force) {
         const auto PMONITORNEW = getMonitorFromVector(pos);
-        if (PMONITORNEW != m_pLastMonitor.get())
+        if (PMONITORNEW != m_pLastMonitor)
             setActiveMonitor(PMONITORNEW);
         return;
     }
@@ -2563,7 +2563,7 @@ void CCompositor::warpCursorTo(const Vector2D& pos, bool force) {
     g_pPointerManager->warpTo(pos);
 
     const auto PMONITORNEW = getMonitorFromVector(pos);
-    if (PMONITORNEW != m_pLastMonitor.get())
+    if (PMONITORNEW != m_pLastMonitor)
         setActiveMonitor(PMONITORNEW);
 }
 
@@ -2690,8 +2690,8 @@ void CCompositor::renameWorkspace(const WORKSPACEID& id, const std::string& name
     g_pEventManager->postEvent({"renameworkspace", std::to_string(PWORKSPACE->m_iID) + "," + PWORKSPACE->m_szName});
 }
 
-void CCompositor::setActiveMonitor(CMonitor* pMonitor) {
-    if (m_pLastMonitor.get() == pMonitor)
+void CCompositor::setActiveMonitor(PHLMONITOR pMonitor) {
+    if (m_pLastMonitor == pMonitor)
         return;
 
     if (!pMonitor) {
@@ -2801,13 +2801,13 @@ PHLWINDOW CCompositor::getForceFocus() {
 }
 
 void CCompositor::arrangeMonitors() {
-    static auto* const     PXWLFORCESCALEZERO = (Hyprlang::INT* const*)g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling");
+    static auto* const      PXWLFORCESCALEZERO = (Hyprlang::INT* const*)g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling");
 
-    std::vector<CMonitor*> toArrange;
-    std::vector<CMonitor*> arranged;
+    std::vector<PHLMONITOR> toArrange;
+    std::vector<PHLMONITOR> arranged;
 
     for (auto const& m : m_vMonitors)
-        toArrange.push_back(m.get());
+        toArrange.push_back(m);
 
     Debug::log(LOG, "arrangeMonitors: {} to arrange", toArrange.size());
 
@@ -2906,7 +2906,7 @@ void CCompositor::enterUnsafeState() {
 
     m_bUnsafeState = true;
 
-    setActiveMonitor(m_pUnsafeOutput);
+    setActiveMonitor(m_pUnsafeOutput.lock());
 }
 
 void CCompositor::leaveUnsafeState() {
@@ -2917,10 +2917,10 @@ void CCompositor::leaveUnsafeState() {
 
     m_bUnsafeState = false;
 
-    CMonitor* pNewMonitor = nullptr;
+    PHLMONITOR pNewMonitor = nullptr;
     for (auto const& pMonitor : m_vMonitors) {
         if (pMonitor->output != m_pUnsafeOutput->output) {
-            pNewMonitor = pMonitor.get();
+            pNewMonitor = pMonitor;
             break;
         }
     }
@@ -2931,7 +2931,7 @@ void CCompositor::leaveUnsafeState() {
         m_pUnsafeOutput->onDisconnect();
 
     for (auto const& m : m_vMonitors) {
-        scheduleFrameForMonitor(m.get());
+        scheduleFrameForMonitor(m);
     }
 }
 
@@ -3007,7 +3007,7 @@ static void checkDefaultCursorWarp(SP<CMonitor> monitor) {
     }
 
     // modechange happend check if cursor is on that monitor and warp it to middle to not place it out of bounds if resolution changed.
-    if (g_pCompositor->getMonitorFromCursor() == monitor.get()) {
+    if (g_pCompositor->getMonitorFromCursor() == monitor) {
         g_pCompositor->warpCursorTo(POS, true);
         g_pInputManager->refocus();
     }
@@ -3017,7 +3017,7 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
     // add it to real
     auto PNEWMONITOR = g_pCompositor->m_vRealMonitors.emplace_back(makeShared<CMonitor>(output));
     if (std::string("HEADLESS-1") == output->name) {
-        g_pCompositor->m_pUnsafeOutput = PNEWMONITOR.get();
+        g_pCompositor->m_pUnsafeOutput = PNEWMONITOR;
         output->name                   = "FALLBACK"; // we are allowed to do this :)
     }
 
@@ -3040,12 +3040,12 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
     // ready to process if we have a real monitor
 
     if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->refreshRate > g_pHyprRenderer->m_pMostHzMonitor->refreshRate) && PNEWMONITOR->m_bEnabled)
-        g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR.get();
+        g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR;
 
     g_pCompositor->m_bReadyToProcess = true;
 
     g_pConfigManager->m_bWantsMonitorReload = true;
-    g_pCompositor->scheduleFrameForMonitor(PNEWMONITOR.get(), IOutput::AQ_SCHEDULE_NEW_MONITOR);
+    g_pCompositor->scheduleFrameForMonitor(PNEWMONITOR, IOutput::AQ_SCHEDULE_NEW_MONITOR);
 
     checkDefaultCursorWarp(PNEWMONITOR);
 
@@ -3056,6 +3056,6 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
         }
     }
 
-    g_pHyprRenderer->damageMonitor(PNEWMONITOR.get());
+    g_pHyprRenderer->damageMonitor(PNEWMONITOR);
     PNEWMONITOR->onMonitorFrame();
 }
diff --git a/src/Compositor.hpp b/src/Compositor.hpp
index a57450f1..7fbd32e8 100644
--- a/src/Compositor.hpp
+++ b/src/Compositor.hpp
@@ -89,7 +89,7 @@ class CCompositor {
     bool                                       m_bDPMSStateON    = true;
     bool                                       m_bUnsafeState    = false; // unsafe state is when there is no monitors.
     bool                                       m_bNextIsUnsafe   = false;
-    CMonitor*                                  m_pUnsafeOutput   = nullptr; // fallback output for the unsafe state
+    PHLMONITORREF                              m_pUnsafeOutput; // fallback output for the unsafe state
     bool                                       m_bIsShuttingDown = false;
     bool                                       m_bFinalRequests  = false;
     bool                                       m_bDesktopEnvSet  = false;
@@ -97,22 +97,22 @@ class CCompositor {
 
     // ------------------------------------------------- //
 
-    CMonitor*              getMonitorFromID(const MONITORID&);
-    CMonitor*              getMonitorFromName(const std::string&);
-    CMonitor*              getMonitorFromDesc(const std::string&);
-    CMonitor*              getMonitorFromCursor();
-    CMonitor*              getMonitorFromVector(const Vector2D&);
+    PHLMONITOR             getMonitorFromID(const MONITORID&);
+    PHLMONITOR             getMonitorFromName(const std::string&);
+    PHLMONITOR             getMonitorFromDesc(const std::string&);
+    PHLMONITOR             getMonitorFromCursor();
+    PHLMONITOR             getMonitorFromVector(const Vector2D&);
     void                   removeWindowFromVectorSafe(PHLWINDOW);
     void                   focusWindow(PHLWINDOW, SP<CWLSurfaceResource> pSurface = nullptr);
     void                   focusSurface(SP<CWLSurfaceResource>, PHLWINDOW pWindowOwner = nullptr);
-    bool                   monitorExists(CMonitor*);
+    bool                   monitorExists(PHLMONITOR);
     PHLWINDOW              vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
     SP<CWLSurfaceResource> vectorToLayerSurface(const Vector2D&, std::vector<PHLLSREF>*, Vector2D*, PHLLS*);
-    SP<CWLSurfaceResource> vectorToLayerPopupSurface(const Vector2D&, CMonitor* monitor, Vector2D*, PHLLS*);
+    SP<CWLSurfaceResource> vectorToLayerPopupSurface(const Vector2D&, PHLMONITOR monitor, Vector2D*, PHLLS*);
     SP<CWLSurfaceResource> vectorWindowToSurface(const Vector2D&, PHLWINDOW, Vector2D& sl);
     Vector2D               vectorToSurfaceLocal(const Vector2D&, PHLWINDOW, SP<CWLSurfaceResource>);
-    CMonitor*              getMonitorFromOutput(SP<Aquamarine::IOutput>);
-    CMonitor*              getRealMonitorFromOutput(SP<Aquamarine::IOutput>);
+    PHLMONITOR             getMonitorFromOutput(SP<Aquamarine::IOutput>);
+    PHLMONITOR             getRealMonitorFromOutput(SP<Aquamarine::IOutput>);
     PHLWINDOW              getWindowFromSurface(SP<CWLSurfaceResource>);
     PHLWINDOW              getWindowFromHandle(uint32_t);
     bool                   isWorkspaceVisible(PHLWORKSPACE);
@@ -138,16 +138,16 @@ class CCompositor {
     PHLWINDOW              getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
     WORKSPACEID            getNextAvailableNamedWorkspace();
     bool                   isPointOnAnyMonitor(const Vector2D&);
-    bool                   isPointOnReservedArea(const Vector2D& point, const CMonitor* monitor = nullptr);
-    CMonitor*              getMonitorInDirection(const char&);
-    CMonitor*              getMonitorInDirection(CMonitor*, const char&);
+    bool                   isPointOnReservedArea(const Vector2D& point, const PHLMONITOR monitor = nullptr);
+    PHLMONITOR             getMonitorInDirection(const char&);
+    PHLMONITOR             getMonitorInDirection(PHLMONITOR, const char&);
     void                   updateAllWindowsAnimatedDecorationValues();
     void                   updateWorkspaceWindows(const WORKSPACEID& id);
     void                   updateWindowAnimatedDecorationValues(PHLWINDOW);
     MONITORID              getNextAvailableMonitorID(std::string const& name);
-    void                   moveWorkspaceToMonitor(PHLWORKSPACE, CMonitor*, bool noWarpCursor = false);
-    void                   swapActiveWorkspaces(CMonitor*, CMonitor*);
-    CMonitor*              getMonitorFromString(const std::string&);
+    void                   moveWorkspaceToMonitor(PHLWORKSPACE, PHLMONITOR, bool noWarpCursor = false);
+    void                   swapActiveWorkspaces(PHLMONITOR, PHLMONITOR);
+    PHLMONITOR             getMonitorFromString(const std::string&);
     bool                   workspaceIDOutOfBounds(const WORKSPACEID&);
     void                   setWindowFullscreenInternal(const PHLWINDOW PWINDOW, const eFullscreenMode MODE);
     void                   setWindowFullscreenClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE);
@@ -156,7 +156,7 @@ class CCompositor {
     void                   changeWindowFullscreenModeClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON);
     void                   updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
     PHLWINDOW              getX11Parent(PHLWINDOW);
-    void                   scheduleFrameForMonitor(CMonitor*, Aquamarine::IOutput::scheduleFrameReason reason = Aquamarine::IOutput::AQ_SCHEDULE_CLIENT_UNKNOWN);
+    void                   scheduleFrameForMonitor(PHLMONITOR, Aquamarine::IOutput::scheduleFrameReason reason = Aquamarine::IOutput::AQ_SCHEDULE_CLIENT_UNKNOWN);
     void                   addToFadingOutSafe(PHLLS);
     void                   removeFromFadingOutSafe(PHLLS);
     void                   addToFadingOutSafe(PHLWINDOW);
@@ -169,7 +169,7 @@ class CCompositor {
     PHLWORKSPACE           createNewWorkspace(const WORKSPACEID&, const MONITORID&, const std::string& name = "",
                                               bool isEmpty = true); // will be deleted next frame if left empty and unfocused!
     void                   renameWorkspace(const WORKSPACEID&, const std::string& name = "");
-    void                   setActiveMonitor(CMonitor*);
+    void                   setActiveMonitor(PHLMONITOR);
     bool                   isWorkspaceSpecial(const WORKSPACEID&);
     WORKSPACEID            getNewSpecialID();
     void                   performUserChecks();
diff --git a/src/config/ConfigManager.cpp b/src/config/ConfigManager.cpp
index 432b7faf..f16ebe46 100644
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
@@ -943,9 +943,9 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
         // mark blur dirty
-        g_pHyprOpenGL->markBlurDirtyForMonitor(m.get());
+        g_pHyprOpenGL->markBlurDirtyForMonitor(m);
 
-        g_pCompositor->scheduleFrameForMonitor(m.get());
+        g_pCompositor->scheduleFrameForMonitor(m);
 
         // Force the compositor to fully re-render all monitors
         m->forceFullFrames = 2;
@@ -1506,7 +1506,7 @@ void CConfigManager::performMonitorReload() {
 
         auto rule = getMonitorRuleFor(m);
 
-        if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule)) {
+        if (!g_pHyprRenderer->applyMonitorRule(m, &rule)) {
             overAgain = true;
             break;
         }
@@ -1564,14 +1564,14 @@ void CConfigManager::ensureMonitorStatus() {
         auto rule = getMonitorRuleFor(rm);
 
         if (rule.disabled == rm->m_bEnabled)
-            g_pHyprRenderer->applyMonitorRule(rm.get(), &rule);
+            g_pHyprRenderer->applyMonitorRule(rm, &rule);
     }
 }
 
-void CConfigManager::ensureVRR(CMonitor* pMonitor) {
+void CConfigManager::ensureVRR(PHLMONITOR pMonitor) {
     static auto PVRR = reinterpret_cast<Hyprlang::INT* const*>(getConfigValuePtr("misc:vrr"));
 
-    static auto ensureVRRForDisplay = [&](CMonitor* m) -> void {
+    static auto ensureVRRForDisplay = [&](PHLMONITOR m) -> void {
         if (!m->output || m->createdByUser)
             return;
 
@@ -1641,7 +1641,7 @@ void CConfigManager::ensureVRR(CMonitor* pMonitor) {
     }
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        ensureVRRForDisplay(m.get());
+        ensureVRRForDisplay(m);
     }
 }
 
@@ -1653,7 +1653,7 @@ void CConfigManager::addParseError(const std::string& err) {
     g_pHyprError->queueCreate(err + "\nHyprland may not work correctly.", CColor(1.0, 50.0 / 255.0, 50.0 / 255.0, 1.0));
 }
 
-CMonitor* CConfigManager::getBoundMonitorForWS(const std::string& wsname) {
+PHLMONITOR CConfigManager::getBoundMonitorForWS(const std::string& wsname) {
     auto monitor = getBoundMonitorStringForWS(wsname);
     if (monitor.substr(0, 5) == "desc:")
         return g_pCompositor->getMonitorFromDesc(monitor.substr(5));
diff --git a/src/config/ConfigManager.hpp b/src/config/ConfigManager.hpp
index 2134acf4..e9ed2d64 100644
--- a/src/config/ConfigManager.hpp
+++ b/src/config/ConfigManager.hpp
@@ -173,7 +173,7 @@ class CConfigManager {
     SWorkspaceRule                                                  getWorkspaceRuleFor(PHLWORKSPACE workspace);
     std::string                                                     getDefaultWorkspaceFor(const std::string&);
 
-    CMonitor*                                                       getBoundMonitorForWS(const std::string&);
+    PHLMONITOR                                                      getBoundMonitorForWS(const std::string&);
     std::string                                                     getBoundMonitorStringForWS(const std::string&);
     const std::deque<SWorkspaceRule>&                               getAllWorkspaceRules();
 
@@ -198,7 +198,7 @@ class CConfigManager {
     void                      appendMonitorRule(const SMonitorRule&);
     bool                      replaceMonitorRule(const SMonitorRule&);
     void                      ensureMonitorStatus();
-    void                      ensureVRR(CMonitor* pMonitor = nullptr);
+    void                      ensureVRR(PHLMONITOR pMonitor = nullptr);
 
     std::string               parseKeyword(const std::string&, const std::string&);
 
diff --git a/src/debug/HyprCtl.cpp b/src/debug/HyprCtl.cpp
index e0bb2b83..e09fb529 100644
--- a/src/debug/HyprCtl.cpp
+++ b/src/debug/HyprCtl.cpp
@@ -54,7 +54,7 @@ static std::string formatToString(uint32_t drmFormat) {
     return "Invalid";
 }
 
-static std::string availableModesForOutput(CMonitor* pMonitor, eHyprCtlOutputFormat format) {
+static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFormat format) {
     std::string result;
 
     for (auto const& m : pMonitor->output->modes) {
@@ -117,7 +117,7 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
             (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_pLastMonitor ? "true" : "false"),
             (m->dpmsStatus ? "true" : "false"), (m->output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->solitaryClient.get(),
             (m->tearingState.activelyTearing ? "true" : "false"), (m->m_bEnabled ? "false" : "true"), formatToString(m->output->state->state().drmFormat),
-            availableModesForOutput(m.get(), format));
+            availableModesForOutput(m, format));
 
     } else {
         result += std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t"
@@ -128,7 +128,7 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
                               m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x,
                               (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform,
                               (m == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(),
-                              m->tearingState.activelyTearing, !m->m_bEnabled, formatToString(m->output->state->state().drmFormat), availableModesForOutput(m.get(), format));
+                              m->tearingState.activelyTearing, !m->m_bEnabled, formatToString(m->output->state->state().drmFormat), availableModesForOutput(m, format));
     }
 
     return result;
@@ -1030,7 +1030,7 @@ std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
     // decorations will probably need a repaint
     if (COMMAND.contains("decoration:") || COMMAND.contains("border") || COMMAND == "workspace" || COMMAND.contains("zoom_factor") || COMMAND == "source") {
         for (auto const& m : g_pCompositor->m_vMonitors) {
-            g_pHyprRenderer->damageMonitor(m.get());
+            g_pHyprRenderer->damageMonitor(m);
             g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
         }
     }
@@ -1779,7 +1779,7 @@ std::string CHyprCtl::getReply(std::string request) {
         }
 
         for (auto const& m : g_pCompositor->m_vMonitors) {
-            g_pHyprRenderer->damageMonitor(m.get());
+            g_pHyprRenderer->damageMonitor(m);
             g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
         }
     }
diff --git a/src/debug/HyprDebugOverlay.cpp b/src/debug/HyprDebugOverlay.cpp
index 2da64e63..9326cfe0 100644
--- a/src/debug/HyprDebugOverlay.cpp
+++ b/src/debug/HyprDebugOverlay.cpp
@@ -7,7 +7,7 @@ CHyprDebugOverlay::CHyprDebugOverlay() {
     m_pTexture = makeShared<CTexture>();
 }
 
-void CHyprMonitorDebugOverlay::renderData(CMonitor* pMonitor, float durationUs) {
+void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
     m_dLastRenderTimes.push_back(durationUs / 1000.f);
 
     if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
@@ -17,7 +17,7 @@ void CHyprMonitorDebugOverlay::renderData(CMonitor* pMonitor, float durationUs)
         m_pMonitor = pMonitor;
 }
 
-void CHyprMonitorDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float durationUs) {
+void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
     m_dLastRenderTimesNoOverlay.push_back(durationUs / 1000.f);
 
     if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
@@ -27,7 +27,7 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float dur
         m_pMonitor = pMonitor;
 }
 
-void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
+void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
     m_dLastFrametimes.push_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
 
     if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
@@ -39,7 +39,7 @@ void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
         m_pMonitor = pMonitor;
 
     // anim data too
-    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor : g_pCompositor->m_pLastMonitor.get();
+    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_pLastMonitor.lock();
     if (PMONITORFORTICKS) {
         if (m_dLastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
             m_dLastAnimationTicks.pop_front();
@@ -188,21 +188,21 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     return posY - offset;
 }
 
-void CHyprDebugOverlay::renderData(CMonitor* pMonitor, float durationUs) {
+void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
     m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs);
 }
 
-void CHyprDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float durationUs) {
+void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
     m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
 }
 
-void CHyprDebugOverlay::frameData(CMonitor* pMonitor) {
+void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
     m_mMonitorOverlays[pMonitor].frameData(pMonitor);
 }
 
 void CHyprDebugOverlay::draw() {
 
-    const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
+    const auto PMONITOR = g_pCompositor->m_vMonitors.front();
 
     if (!m_pCairoSurface || !m_pCairo) {
         m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
@@ -218,7 +218,7 @@ void CHyprDebugOverlay::draw() {
     // draw the things
     int offsetY = 0;
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        offsetY += m_mMonitorOverlays[m.get()].draw(offsetY);
+        offsetY += m_mMonitorOverlays[m].draw(offsetY);
         offsetY += 5; // for padding between mons
     }
 
diff --git a/src/debug/HyprDebugOverlay.hpp b/src/debug/HyprDebugOverlay.hpp
index e7742b35..19b9120a 100644
--- a/src/debug/HyprDebugOverlay.hpp
+++ b/src/debug/HyprDebugOverlay.hpp
@@ -5,7 +5,7 @@
 #include "../render/Texture.hpp"
 #include <deque>
 #include <cairo/cairo.h>
-#include <unordered_map>
+#include <map>
 
 class CHyprRenderer;
 
@@ -13,9 +13,9 @@ class CHyprMonitorDebugOverlay {
   public:
     int  draw(int offset);
 
-    void renderData(CMonitor* pMonitor, float durationUs);
-    void renderDataNoOverlay(CMonitor* pMonitor, float durationUs);
-    void frameData(CMonitor* pMonitor);
+    void renderData(PHLMONITOR pMonitor, float durationUs);
+    void renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs);
+    void frameData(PHLMONITOR pMonitor);
 
   private:
     std::deque<float>                              m_dLastFrametimes;
@@ -23,7 +23,7 @@ class CHyprMonitorDebugOverlay {
     std::deque<float>                              m_dLastRenderTimesNoOverlay;
     std::deque<float>                              m_dLastAnimationTicks;
     std::chrono::high_resolution_clock::time_point m_tpLastFrame;
-    CMonitor*                                      m_pMonitor = nullptr;
+    PHLMONITORREF                                  m_pMonitor;
     CBox                                           m_wbLastDrawnBox;
 
     friend class CHyprRenderer;
@@ -33,17 +33,17 @@ class CHyprDebugOverlay {
   public:
     CHyprDebugOverlay();
     void draw();
-    void renderData(CMonitor*, float durationUs);
-    void renderDataNoOverlay(CMonitor*, float durationUs);
-    void frameData(CMonitor*);
+    void renderData(PHLMONITOR, float durationUs);
+    void renderDataNoOverlay(PHLMONITOR, float durationUs);
+    void frameData(PHLMONITOR);
 
   private:
-    std::unordered_map<CMonitor*, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
+    std::map<PHLMONITOR, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
 
-    cairo_surface_t*                                        m_pCairoSurface = nullptr;
-    cairo_t*                                                m_pCairo        = nullptr;
+    cairo_surface_t*                               m_pCairoSurface = nullptr;
+    cairo_t*                                       m_pCairo        = nullptr;
 
-    SP<CTexture>                                            m_pTexture;
+    SP<CTexture>                                   m_pTexture;
 
     friend class CHyprMonitorDebugOverlay;
     friend class CHyprRenderer;
diff --git a/src/debug/HyprNotificationOverlay.cpp b/src/debug/HyprNotificationOverlay.cpp
index 16f80ab6..e46999e6 100644
--- a/src/debug/HyprNotificationOverlay.cpp
+++ b/src/debug/HyprNotificationOverlay.cpp
@@ -45,7 +45,7 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CC
     PNOTIF->fontSize = fontSize;
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        g_pCompositor->scheduleFrameForMonitor(m.get());
+        g_pCompositor->scheduleFrameForMonitor(m);
     }
 }
 
@@ -61,7 +61,7 @@ void CHyprNotificationOverlay::dismissNotifications(const int amount) {
     }
 }
 
-CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
+CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     static constexpr auto ANIM_DURATION_MS   = 600.0;
     static constexpr auto ANIM_LAG_MS        = 100.0;
     static constexpr auto NOTIF_LEFTBAR_SIZE = 5.0;
@@ -187,7 +187,7 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
     return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
 }
 
-void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
+void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
 
     const auto MONSIZE = pMonitor->vecTransformedSize;
 
diff --git a/src/debug/HyprNotificationOverlay.hpp b/src/debug/HyprNotificationOverlay.hpp
index 352c44c9..0bba8b04 100644
--- a/src/debug/HyprNotificationOverlay.hpp
+++ b/src/debug/HyprNotificationOverlay.hpp
@@ -41,13 +41,13 @@ class CHyprNotificationOverlay {
     CHyprNotificationOverlay();
     ~CHyprNotificationOverlay();
 
-    void draw(CMonitor* pMonitor);
+    void draw(PHLMONITOR pMonitor);
     void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
     void dismissNotifications(const int amount);
     bool hasAny();
 
   private:
-    CBox                                       drawNotifications(CMonitor* pMonitor);
+    CBox                                       drawNotifications(PHLMONITOR pMonitor);
     CBox                                       m_bLastDamage;
 
     std::deque<std::unique_ptr<SNotification>> m_dNotifications;
@@ -55,8 +55,8 @@ class CHyprNotificationOverlay {
     cairo_surface_t*                           m_pCairoSurface = nullptr;
     cairo_t*                                   m_pCairo        = nullptr;
 
-    CMonitor*                                  m_pLastMonitor = nullptr;
-    Vector2D                                   m_vecLastSize  = Vector2D(-1, -1);
+    PHLMONITORREF                              m_pLastMonitor;
+    Vector2D                                   m_vecLastSize = Vector2D(-1, -1);
 
     SP<CTexture>                               m_pTexture;
 };
diff --git a/src/desktop/DesktopTypes.hpp b/src/desktop/DesktopTypes.hpp
index 4e40c4e0..7f812cc1 100644
--- a/src/desktop/DesktopTypes.hpp
+++ b/src/desktop/DesktopTypes.hpp
@@ -3,6 +3,7 @@
 class CWorkspace;
 class CWindow;
 class CLayerSurface;
+class CMonitor;
 
 /* Shared pointer to a workspace */
 typedef SP<CWorkspace> PHLWORKSPACE;
@@ -18,3 +19,8 @@ typedef WP<CWindow> PHLWINDOWREF;
 typedef SP<CLayerSurface> PHLLS;
 /* Weak pointer to a layer surface */
 typedef WP<CLayerSurface> PHLLSREF;
+
+/* Shared pointer to a monitor */
+typedef SP<CMonitor> PHLMONITOR;
+/* Weak pointer to a monitor */
+typedef WP<CMonitor> PHLMONITORREF;
diff --git a/src/desktop/LayerSurface.cpp b/src/desktop/LayerSurface.cpp
index 0e7e71b6..6c024ee0 100644
--- a/src/desktop/LayerSurface.cpp
+++ b/src/desktop/LayerSurface.cpp
@@ -6,9 +6,9 @@
 #include "../managers/SeatManager.hpp"
 
 PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
-    PHLLS     pLS = SP<CLayerSurface>(new CLayerSurface(resource));
+    PHLLS pLS = SP<CLayerSurface>(new CLayerSurface(resource));
 
-    CMonitor* pMonitor = resource->monitor.empty() ? g_pCompositor->getMonitorFromCursor() : g_pCompositor->getMonitorFromName(resource->monitor);
+    auto  pMonitor = resource->monitor.empty() ? g_pCompositor->getMonitorFromCursor() : g_pCompositor->getMonitorFromName(resource->monitor);
 
     pLS->surface->assign(resource->surface.lock(), pLS);
 
@@ -18,7 +18,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
     }
 
     if (pMonitor->pMirrorOf)
-        pMonitor = g_pCompositor->m_vMonitors.front().get();
+        pMonitor = g_pCompositor->m_vMonitors.front();
 
     pLS->self = pLS;
 
diff --git a/src/desktop/Window.cpp b/src/desktop/Window.cpp
index a393f361..1297bb83 100644
--- a/src/desktop/Window.cpp
+++ b/src/desktop/Window.cpp
@@ -1188,7 +1188,7 @@ void CWindow::setSuspended(bool suspend) {
     m_bSuspended = suspend;
 }
 
-bool CWindow::visibleOnMonitor(CMonitor* pMonitor) {
+bool CWindow::visibleOnMonitor(PHLMONITOR pMonitor) {
     CBox wbox = {m_vRealPosition.value(), m_vRealSize.value()};
 
     return !wbox.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty();
diff --git a/src/desktop/Window.hpp b/src/desktop/Window.hpp
index 9baf57c4..b2a8e763 100644
--- a/src/desktop/Window.hpp
+++ b/src/desktop/Window.hpp
@@ -424,7 +424,7 @@ class CWindow {
     float                  rounding();
     bool                   canBeTorn();
     void                   setSuspended(bool suspend);
-    bool                   visibleOnMonitor(CMonitor* pMonitor);
+    bool                   visibleOnMonitor(PHLMONITOR pMonitor);
     WORKSPACEID            workspaceID();
     bool                   onSpecialWorkspace();
     void                   activate(bool force = false);
diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp
index 37e5406c..21055f79 100644
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -49,10 +49,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
     static auto PNEWTAKESOVERFS    = CConfigValue<Hyprlang::INT>("misc:new_window_takes_over_fullscreen");
     static auto PINITIALWSTRACKING = CConfigValue<Hyprlang::INT>("misc:initial_workspace_tracking");
 
-    auto        PMONITOR = g_pCompositor->m_pLastMonitor.get();
+    auto        PMONITOR = g_pCompositor->m_pLastMonitor.lock();
     if (!g_pCompositor->m_pLastMonitor) {
         g_pCompositor->setActiveMonitor(g_pCompositor->getMonitorFromVector({}));
-        PMONITOR = g_pCompositor->m_pLastMonitor.get();
+        PMONITOR = g_pCompositor->m_pLastMonitor.lock();
     }
     auto PWORKSPACE           = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
     PWINDOW->m_iMonitorID     = PMONITOR->ID;
@@ -314,7 +314,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 else if (PMONITOR->activeWorkspaceID() != REQUESTEDWORKSPACEID)
                     g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspaceName);
 
-                PMONITOR = g_pCompositor->m_pLastMonitor.get();
+                PMONITOR = g_pCompositor->m_pLastMonitor.lock();
             }
         } else
             workspaceSilent = false;
diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp
index 74471f62..6ded5ea4 100644
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -25,7 +25,7 @@ using namespace Hyprutils::String;
 using namespace Hyprutils::Utils;
 
 int ratHandler(void* data) {
-    g_pHyprRenderer->renderMonitor((CMonitor*)data);
+    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->self.lock());
 
     return 1;
 }
@@ -49,12 +49,12 @@ void CMonitor::onConnect(bool noRule) {
     listeners.frame  = output->events.frame.registerListener([this](std::any d) { onMonitorFrame(); });
     listeners.commit = output->events.commit.registerListener([this](std::any d) {
         if (true) { // FIXME: E->state->committed & WLR_OUTPUT_STATE_BUFFER
-            PROTO::screencopy->onOutputCommit(this);
-            PROTO::toplevelExport->onOutputCommit(this);
+            PROTO::screencopy->onOutputCommit(self.lock());
+            PROTO::toplevelExport->onOutputCommit(self.lock());
         }
     });
     listeners.needsFrame =
-        output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
+        output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
 
     listeners.presented = output->events.present.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IOutput::SPresentEvent>(d);
@@ -84,7 +84,7 @@ void CMonitor::onConnect(bool noRule) {
                 return;
 
             Debug::log(LOG, "Reapplying monitor rule for {} from a state request", szName);
-            g_pHyprRenderer->applyMonitorRule(this, &activeMonitorRule, true);
+            g_pHyprRenderer->applyMonitorRule(self.lock(), &activeMonitorRule, true);
             return;
         }
 
@@ -98,7 +98,7 @@ void CMonitor::onConnect(bool noRule) {
         SMonitorRule rule = activeMonitorRule;
         rule.resolution   = SIZE;
 
-        g_pHyprRenderer->applyMonitorRule(this, &rule);
+        g_pHyprRenderer->applyMonitorRule(self.lock(), &rule);
     });
 
     tearingState.canTear = output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
@@ -171,7 +171,7 @@ void CMonitor::onConnect(bool noRule) {
 
     // set mode, also applies
     if (!noRule)
-        g_pHyprRenderer->applyMonitorRule(this, &monitorRule, true);
+        g_pHyprRenderer->applyMonitorRule(self.lock(), &monitorRule, true);
 
     if (!state.commit())
         Debug::log(WARN, "state.commit() failed in CMonitor::onCommit");
@@ -187,7 +187,7 @@ void CMonitor::onConnect(bool noRule) {
             continue;
 
         if (ws->m_szLastMonitor == szName || g_pCompositor->m_vMonitors.size() == 1 /* avoid lost workspaces on recover */) {
-            g_pCompositor->moveWorkspaceToMonitor(ws, this);
+            g_pCompositor->moveWorkspaceToMonitor(ws, self.lock());
             ws->startAnim(true, true, true);
             ws->m_szLastMonitor = "";
         }
@@ -204,13 +204,13 @@ void CMonitor::onConnect(bool noRule) {
         setMirror(activeMonitorRule.mirrorOf);
 
     if (!g_pCompositor->m_pLastMonitor) // set the last monitor if it isnt set yet
-        g_pCompositor->setActiveMonitor(this);
+        g_pCompositor->setActiveMonitor(self.lock());
 
     g_pHyprRenderer->arrangeLayersForMonitor(ID);
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
     // ensure VRR (will enable if necessary)
-    g_pConfigManager->ensureVRR(this);
+    g_pConfigManager->ensureVRR(self.lock());
 
     // verify last mon valid
     bool found = false;
@@ -222,19 +222,19 @@ void CMonitor::onConnect(bool noRule) {
     }
 
     if (!found)
-        g_pCompositor->setActiveMonitor(this);
+        g_pCompositor->setActiveMonitor(self.lock());
 
     renderTimer = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, ratHandler, this);
 
-    g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::AQ_SCHEDULE_NEW_MONITOR);
+    g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEW_MONITOR);
 
-    PROTO::gamma->applyGammaToState(this);
+    PROTO::gamma->applyGammaToState(self.lock());
 
     events.connect.emit();
 
     g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
     g_pEventManager->postEvent(SHyprIPCEvent{"monitoraddedv2", std::format("{},{},{}", ID, szName, szShortDescription)});
-    EMIT_HOOK_EVENT("monitorAdded", this);
+    EMIT_HOOK_EVENT("monitorAdded", self.lock());
 }
 
 void CMonitor::onDisconnect(bool destroy) {
@@ -242,7 +242,7 @@ void CMonitor::onDisconnect(bool destroy) {
         if (g_pCompositor->m_bIsShuttingDown)
             return;
         g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
-        EMIT_HOOK_EVENT("monitorRemoved", this);
+        EMIT_HOOK_EVENT("monitorRemoved", self.lock());
         g_pCompositor->arrangeMonitors();
     }};
 
@@ -259,21 +259,21 @@ void CMonitor::onDisconnect(bool destroy) {
     events.disconnect.emit();
 
     // Cleanup everything. Move windows back, snap cursor, shit.
-    CMonitor* BACKUPMON = nullptr;
+    PHLMONITOR BACKUPMON = nullptr;
     for (auto const& m : g_pCompositor->m_vMonitors) {
         if (m.get() != this) {
-            BACKUPMON = m.get();
+            BACKUPMON = m;
             break;
         }
     }
 
     // remove mirror
     if (pMirrorOf) {
-        pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == this; }));
+        pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == self; }));
 
         // unlock software for mirrored monitor
-        g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf);
-        pMirrorOf = nullptr;
+        g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf.lock());
+        pMirrorOf.reset();
     }
 
     if (!mirrors.empty()) {
@@ -340,16 +340,16 @@ void CMonitor::onDisconnect(bool destroy) {
     if (!state.commit())
         Debug::log(WARN, "state.commit() failed in CMonitor::onDisconnect");
 
-    if (g_pCompositor->m_pLastMonitor.get() == this)
-        g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_pUnsafeOutput);
+    if (g_pCompositor->m_pLastMonitor == self)
+        g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_pUnsafeOutput.lock());
 
-    if (g_pHyprRenderer->m_pMostHzMonitor == this) {
-        int       mostHz         = 0;
-        CMonitor* pMonitorMostHz = nullptr;
+    if (g_pHyprRenderer->m_pMostHzMonitor == self) {
+        int        mostHz         = 0;
+        PHLMONITOR pMonitorMostHz = nullptr;
 
         for (auto const& m : g_pCompositor->m_vMonitors) {
-            if (m->refreshRate > mostHz && m.get() != this) {
-                pMonitorMostHz = m.get();
+            if (m->refreshRate > mostHz && m != self) {
+                pMonitorMostHz = m;
                 mostHz         = m->refreshRate;
             }
         }
@@ -361,11 +361,11 @@ void CMonitor::onDisconnect(bool destroy) {
 
 void CMonitor::addDamage(const pixman_region32_t* rg) {
     static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
-    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == this) {
+    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
         damage.damageEntire();
-        g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
     } else if (damage.damage(rg))
-        g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }
 
 void CMonitor::addDamage(const CRegion* rg) {
@@ -374,13 +374,13 @@ void CMonitor::addDamage(const CRegion* rg) {
 
 void CMonitor::addDamage(const CBox* box) {
     static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
-    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == this) {
+    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
         damage.damageEntire();
-        g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
     }
 
     if (damage.damage(*box))
-        g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }
 
 bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
@@ -456,7 +456,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
 
     if (PNEWWORKSPACE) {
         // workspace exists, move it to the newly connected monitor
-        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, this);
+        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, self.lock());
         activeWorkspace = PNEWWORKSPACE;
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
         PNEWWORKSPACE->startAnim(true, true, true);
@@ -485,7 +485,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         return;
     }
 
-    if (PMIRRORMON == this) {
+    if (PMIRRORMON == self) {
         Debug::log(ERR, "Cannot mirror self!");
         return;
     }
@@ -494,13 +494,13 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         // disable mirroring
 
         if (pMirrorOf) {
-            pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == this; }));
+            pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == self; }));
 
             // unlock software for mirrored monitor
-            g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf);
+            g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf.lock());
         }
 
-        pMirrorOf = nullptr;
+        pMirrorOf.reset();
 
         // set rule
         const auto RULE = g_pConfigManager->getMonitorRuleFor(self.lock());
@@ -528,12 +528,12 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
 
         setupDefaultWS(RULE);
 
-        g_pHyprRenderer->applyMonitorRule(this, (SMonitorRule*)&RULE, true); // will apply the offset and stuff
+        g_pHyprRenderer->applyMonitorRule(self.lock(), (SMonitorRule*)&RULE, true); // will apply the offset and stuff
     } else {
-        CMonitor* BACKUPMON = nullptr;
+        PHLMONITOR BACKUPMON = nullptr;
         for (auto const& m : g_pCompositor->m_vMonitors) {
             if (m.get() != this) {
-                BACKUPMON = m.get();
+                BACKUPMON = m;
                 break;
             }
         }
@@ -557,14 +557,14 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
 
         pMirrorOf = PMIRRORMON;
 
-        pMirrorOf->mirrors.push_back(this);
+        pMirrorOf->mirrors.push_back(self);
 
         // remove from mvmonitors
-        std::erase_if(g_pCompositor->m_vMonitors, [&](const auto& other) { return other.get() == this; });
+        std::erase_if(g_pCompositor->m_vMonitors, [&](const auto& other) { return other == self; });
 
         g_pCompositor->arrangeMonitors();
 
-        g_pCompositor->setActiveMonitor(g_pCompositor->m_vMonitors.front().get());
+        g_pCompositor->setActiveMonitor(g_pCompositor->m_vMonitors.front());
 
         g_pCompositor->sanityCheckWorkspaces();
 
@@ -654,11 +654,11 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         EMIT_HOOK_EVENT("workspace", pWorkspace);
     }
 
-    g_pHyprRenderer->damageMonitor(this);
+    g_pHyprRenderer->damageMonitor(self.lock());
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
 
-    g_pConfigManager->ensureVRR(this);
+    g_pConfigManager->ensureVRR(self.lock());
 
     g_pCompositor->updateSuspendedStates();
 
@@ -674,7 +674,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
     if (activeSpecialWorkspace == pWorkspace)
         return;
 
-    g_pHyprRenderer->damageMonitor(this);
+    g_pHyprRenderer->damageMonitor(self.lock());
 
     if (!pWorkspace) {
         // remove special if exists
@@ -696,7 +696,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
         g_pCompositor->updateFullscreenFadeOnWorkspace(activeWorkspace);
 
-        g_pConfigManager->ensureVRR(this);
+        g_pConfigManager->ensureVRR(self.lock());
 
         g_pCompositor->updateSuspendedStates();
 
@@ -764,11 +764,11 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
     g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_szName + "," + szName});
 
-    g_pHyprRenderer->damageMonitor(this);
+    g_pHyprRenderer->damageMonitor(self.lock());
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
 
-    g_pConfigManager->ensureVRR(this);
+    g_pConfigManager->ensureVRR(self.lock());
 
     g_pCompositor->updateSuspendedStates();
 }
@@ -824,7 +824,7 @@ void CMonitor::scheduleDone() {
 void CMonitor::setCTM(const Mat3x3& ctm_) {
     ctm        = ctm_;
     ctmUpdated = true;
-    g_pCompositor->scheduleFrameForMonitor(this, Aquamarine::IOutput::scheduleFrameReason::AQ_SCHEDULE_NEEDS_FRAME);
+    g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::scheduleFrameReason::AQ_SCHEDULE_NEEDS_FRAME);
 }
 
 bool CMonitor::attemptDirectScanout() {
@@ -963,7 +963,7 @@ void CMonitor::onMonitorFrame() {
     if (!m_bEnabled)
         return;
 
-    g_pHyprRenderer->recheckSolitaryForMonitor(this);
+    g_pHyprRenderer->recheckSolitaryForMonitor(self.lock());
 
     tearingState.busy = false;
 
@@ -984,12 +984,12 @@ void CMonitor::onMonitorFrame() {
     if (*PENABLERAT && !tearingState.nextRenderTorn) {
         if (!RATScheduled) {
             // render
-            g_pHyprRenderer->renderMonitor(this);
+            g_pHyprRenderer->renderMonitor(self.lock());
         }
 
         RATScheduled = false;
 
-        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(this);
+        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(self.lock());
 
         if (max + *PRATSAFE > 1000.0 / refreshRate)
             return;
@@ -1002,11 +1002,11 @@ void CMonitor::onMonitorFrame() {
         const auto TIMETOSLEEP   = std::floor(MSLEFT - ESTRENDERTIME);
 
         if (MSLEFT < 1 || MSLEFT < ESTRENDERTIME || TIMETOSLEEP < 1)
-            g_pHyprRenderer->renderMonitor(this);
+            g_pHyprRenderer->renderMonitor(self.lock());
         else
             wl_event_source_timer_update(renderTimer, TIMETOSLEEP);
     } else
-        g_pHyprRenderer->renderMonitor(this);
+        g_pHyprRenderer->renderMonitor(self.lock());
 }
 
 CMonitorState::CMonitorState(CMonitor* owner) {
@@ -1040,7 +1040,7 @@ bool CMonitorState::commit() {
     if (!updateSwapchain())
         return false;
 
-    EMIT_HOOK_EVENT("preMonitorCommit", m_pOwner);
+    EMIT_HOOK_EVENT("preMonitorCommit", m_pOwner->self.lock());
 
     ensureBufferPresent();
 
diff --git a/src/helpers/Monitor.hpp b/src/helpers/Monitor.hpp
index ceb90232..f3d6d647 100644
--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -54,7 +54,7 @@ class CMonitorState {
   private:
     void      ensureBufferPresent();
 
-    CMonitor* m_pOwner;
+    CMonitor* m_pOwner = nullptr;
 };
 
 class CMonitor {
@@ -128,8 +128,8 @@ class CMonitor {
     WP<CMonitor>      self;
 
     // mirroring
-    CMonitor*              pMirrorOf = nullptr;
-    std::vector<CMonitor*> mirrors;
+    PHLMONITORREF              pMirrorOf;
+    std::vector<PHLMONITORREF> mirrors;
 
     // ctm
     Mat3x3 ctm        = Mat3x3::identity();
diff --git a/src/helpers/WLClasses.hpp b/src/helpers/WLClasses.hpp
index 51f90166..9f2836e7 100644
--- a/src/helpers/WLClasses.hpp
+++ b/src/helpers/WLClasses.hpp
@@ -18,9 +18,9 @@ class CWLSurfaceResource;
 AQUAMARINE_FORWARD(ISwitch);
 
 struct SRenderData {
-    CMonitor* pMonitor;
-    timespec* when;
-    double    x, y;
+    PHLMONITORREF pMonitor;
+    timespec*     when;
+    double        x, y;
 
     // for iters
     void*                  data    = nullptr;
@@ -59,16 +59,16 @@ struct SRenderData {
 };
 
 struct SSwipeGesture {
-    PHLWORKSPACE pWorkspaceBegin = nullptr;
+    PHLWORKSPACE  pWorkspaceBegin = nullptr;
 
-    double       delta = 0;
+    double        delta = 0;
 
-    int          initialDirection = 0;
-    float        avgSpeed         = 0;
-    int          speedPoints      = 0;
-    int          touch_id         = 0;
+    int           initialDirection = 0;
+    float         avgSpeed         = 0;
+    int           speedPoints      = 0;
+    int           touch_id         = 0;
 
-    CMonitor*    pMonitor = nullptr;
+    PHLMONITORREF pMonitor;
 };
 
 struct SSwitchDevice {
diff --git a/src/hyprerror/HyprError.cpp b/src/hyprerror/HyprError.cpp
index 4044bcc9..4761346e 100644
--- a/src/hyprerror/HyprError.cpp
+++ b/src/hyprerror/HyprError.cpp
@@ -14,7 +14,7 @@ CHyprError::CHyprError() {
         if (!m_bIsCreated)
             return;
 
-        g_pHyprRenderer->damageMonitor(g_pCompositor->m_pLastMonitor.get());
+        g_pHyprRenderer->damageMonitor(g_pCompositor->m_pLastMonitor.lock());
         m_bMonitorChanged = true;
     });
 
@@ -47,7 +47,7 @@ void CHyprError::createQueued() {
     m_fFadeOpacity.setValueAndWarp(0.f);
     m_fFadeOpacity = 1.f;
 
-    const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
+    const auto PMONITOR = g_pCompositor->m_vMonitors.front();
 
     const auto SCALE = PMONITOR->scale;
 
diff --git a/src/layout/DwindleLayout.cpp b/src/layout/DwindleLayout.cpp
index 8a7426eb..0fa57143 100644
--- a/src/layout/DwindleLayout.cpp
+++ b/src/layout/DwindleLayout.cpp
@@ -101,18 +101,17 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     if (pNode->isNode)
         return;
 
-    CMonitor* PMONITOR = nullptr;
+    PHLMONITOR PMONITOR = nullptr;
 
     if (g_pCompositor->isWorkspaceSpecial(pNode->workspaceID)) {
         for (auto const& m : g_pCompositor->m_vMonitors) {
             if (m->activeSpecialWorkspaceID() == pNode->workspaceID) {
-                PMONITOR = m.get();
+                PMONITOR = m;
                 break;
             }
         }
-    } else {
+    } else
         PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
-    }
 
     if (!PMONITOR) {
         Debug::log(ERR, "Orphaned Node {}!!", pNode);
diff --git a/src/layout/MasterLayout.cpp b/src/layout/MasterLayout.cpp
index f983770b..95b5afdf 100644
--- a/src/layout/MasterLayout.cpp
+++ b/src/layout/MasterLayout.cpp
@@ -594,18 +594,17 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
 }
 
 void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
-    CMonitor* PMONITOR = nullptr;
+    PHLMONITOR PMONITOR = nullptr;
 
     if (g_pCompositor->isWorkspaceSpecial(pNode->workspaceID)) {
         for (auto const& m : g_pCompositor->m_vMonitors) {
             if (m->activeSpecialWorkspaceID() == pNode->workspaceID) {
-                PMONITOR = m.get();
+                PMONITOR = m;
                 break;
             }
         }
-    } else {
+    } else
         PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
-    }
 
     if (!PMONITOR) {
         Debug::log(ERR, "Orphaned Node {}!!", pNode);
diff --git a/src/managers/AnimationManager.cpp b/src/managers/AnimationManager.cpp
index 0ff94f1f..9ff7497d 100644
--- a/src/managers/AnimationManager.cpp
+++ b/src/managers/AnimationManager.cpp
@@ -85,7 +85,7 @@ void CAnimationManager::tick() {
         PHLWINDOW    PWINDOW            = av->m_pWindow.lock();
         PHLWORKSPACE PWORKSPACE         = av->m_pWorkspace.lock();
         PHLLS        PLAYER             = av->m_pLayer.lock();
-        CMonitor*    PMONITOR           = nullptr;
+        PHLMONITOR   PMONITOR           = nullptr;
         bool         animationsDisabled = animGlobalDisabled;
 
         if (PWINDOW) {
diff --git a/src/managers/CursorManager.cpp b/src/managers/CursorManager.cpp
index 6f8292f7..34084a49 100644
--- a/src/managers/CursorManager.cpp
+++ b/src/managers/CursorManager.cpp
@@ -309,7 +309,7 @@ void CCursorManager::updateTheme() {
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
         m->forceFullFrames = 5;
-        g_pCompositor->scheduleFrameForMonitor(m.get(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
+        g_pCompositor->scheduleFrameForMonitor(m, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
     }
 }
 
diff --git a/src/managers/KeybindManager.cpp b/src/managers/KeybindManager.cpp
index d893e258..9c22fb93 100644
--- a/src/managers/KeybindManager.cpp
+++ b/src/managers/KeybindManager.cpp
@@ -271,11 +271,11 @@ void updateRelativeCursorCoords() {
         g_pCompositor->m_pLastWindow->m_vRelativeCursorCoordsOnLastWarp = g_pInputManager->getMouseCoordsInternal() - g_pCompositor->m_pLastWindow->m_vPosition;
 }
 
-bool CKeybindManager::tryMoveFocusToMonitor(CMonitor* monitor) {
+bool CKeybindManager::tryMoveFocusToMonitor(PHLMONITOR monitor) {
     if (!monitor)
         return false;
 
-    const auto LASTMONITOR = g_pCompositor->m_pLastMonitor.get();
+    const auto LASTMONITOR = g_pCompositor->m_pLastMonitor.lock();
     if (!LASTMONITOR)
         return false;
     if (LASTMONITOR == monitor) {
@@ -1096,7 +1096,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) {
     static auto PALLOWWORKSPACECYCLES = CConfigValue<Hyprlang::INT>("binds:allow_workspace_cycles");
     static auto PWORKSPACECENTERON    = CConfigValue<Hyprlang::INT>("binds:workspace_center_on");
 
-    const auto  PMONITOR = g_pCompositor->m_pLastMonitor.get();
+    const auto  PMONITOR = g_pCompositor->m_pLastMonitor.lock();
 
     if (!PMONITOR)
         return {.success = false, .error = "Last monitor not found"};
@@ -1260,7 +1260,7 @@ SDispatchResult CKeybindManager::moveActiveToWorkspace(std::string args) {
     }
 
     auto        pWorkspace            = g_pCompositor->getWorkspaceByID(WORKSPACEID);
-    CMonitor*   pMonitor              = nullptr;
+    PHLMONITOR  pMonitor              = nullptr;
     const auto  POLDWS                = PWINDOW->m_pWorkspace;
     static auto PALLOWWORKSPACECYCLES = CConfigValue<Hyprlang::INT>("binds:allow_workspace_cycles");
 
@@ -1795,7 +1795,7 @@ SDispatchResult CKeybindManager::exitHyprland(std::string argz) {
 }
 
 SDispatchResult CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {
-    CMonitor* PMONITOR = g_pCompositor->getMonitorFromString(args);
+    PHLMONITOR PMONITOR = g_pCompositor->getMonitorFromString(args);
 
     if (!PMONITOR) {
         Debug::log(ERR, "Ignoring moveCurrentWorkspaceToMonitor: monitor doesnt exist");
@@ -1854,7 +1854,7 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args
         return {.success = false, .error = "focusWorkspaceOnCurrentMonitor invalid workspace!"};
     }
 
-    const auto PCURRMONITOR = g_pCompositor->m_pLastMonitor.get();
+    const auto PCURRMONITOR = g_pCompositor->m_pLastMonitor.lock();
 
     if (!PCURRMONITOR) {
         Debug::log(ERR, "focusWorkspaceOnCurrentMonitor monitor doesn't exist!");
@@ -1944,7 +1944,7 @@ SDispatchResult CKeybindManager::forceRendererReload(std::string args) {
             continue;
 
         auto rule = g_pConfigManager->getMonitorRuleFor(m);
-        if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule, true)) {
+        if (!g_pHyprRenderer->applyMonitorRule(m, &rule, true)) {
             overAgain = true;
             break;
         }
@@ -2427,7 +2427,7 @@ SDispatchResult CKeybindManager::dpms(std::string arg) {
         }
 
         if (enable)
-            g_pHyprRenderer->damageMonitor(m.get());
+            g_pHyprRenderer->damageMonitor(m);
 
         m->events.dpmsChanged.emit();
     }
diff --git a/src/managers/KeybindManager.hpp b/src/managers/KeybindManager.hpp
index c81ca86f..8981dcaf 100644
--- a/src/managers/KeybindManager.hpp
+++ b/src/managers/KeybindManager.hpp
@@ -146,7 +146,7 @@ class CKeybindManager {
     void                            updateXKBTranslationState();
     bool                            ensureMouseBindState();
 
-    static bool                     tryMoveFocusToMonitor(CMonitor* monitor);
+    static bool                     tryMoveFocusToMonitor(PHLMONITOR monitor);
     static void                     moveWindowOutOfGroup(PHLWINDOW pWindow, const std::string& dir = "");
     static void                     moveWindowIntoGroup(PHLWINDOW pWindow, PHLWINDOW pWindowInDirection);
     static void                     switchToWindow(PHLWINDOW PWINDOWTOCHANGETO);
diff --git a/src/managers/PointerManager.cpp b/src/managers/PointerManager.cpp
index 8c2a1bad..ae90349b 100644
--- a/src/managers/PointerManager.cpp
+++ b/src/managers/PointerManager.cpp
@@ -14,7 +14,7 @@
 
 CPointerManager::CPointerManager() {
     hooks.monitorAdded = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any data) {
-        auto PMONITOR = std::any_cast<CMonitor*>(data)->self.lock();
+        auto PMONITOR = std::any_cast<PHLMONITOR>(data);
 
         onMonitorLayoutChange();
 
@@ -29,7 +29,7 @@ CPointerManager::CPointerManager() {
     });
 
     hooks.monitorPreRender = g_pHookSystem->hookDynamic("preMonitorCommit", [this](void* self, SCallbackInfo& info, std::any data) {
-        auto state = stateFor(std::any_cast<CMonitor*>(data)->self.lock());
+        auto state = stateFor(std::any_cast<PHLMONITOR>(data));
         if (!state)
             return;
 
@@ -51,16 +51,7 @@ void CPointerManager::unlockSoftwareAll() {
     updateCursorBackend();
 }
 
-void CPointerManager::lockSoftwareForMonitor(CMonitor* Monitor) {
-    for (auto const& m : g_pCompositor->m_vMonitors) {
-        if (m->ID == Monitor->ID) {
-            lockSoftwareForMonitor(m);
-            return;
-        }
-    }
-}
-
-void CPointerManager::lockSoftwareForMonitor(SP<CMonitor> mon) {
+void CPointerManager::lockSoftwareForMonitor(PHLMONITOR mon) {
     auto state = stateFor(mon);
     state->softwareLocks++;
 
@@ -68,16 +59,7 @@ void CPointerManager::lockSoftwareForMonitor(SP<CMonitor> mon) {
         updateCursorBackend();
 }
 
-void CPointerManager::unlockSoftwareForMonitor(CMonitor* Monitor) {
-    for (auto const& m : g_pCompositor->m_vMonitors) {
-        if (m->ID == Monitor->ID) {
-            unlockSoftwareForMonitor(m);
-            return;
-        }
-    }
-}
-
-void CPointerManager::unlockSoftwareForMonitor(SP<CMonitor> mon) {
+void CPointerManager::unlockSoftwareForMonitor(PHLMONITOR mon) {
     auto state = stateFor(mon);
     state->softwareLocks--;
     if (state->softwareLocks < 0)
@@ -387,7 +369,7 @@ bool CPointerManager::setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquam
     state->cursorFrontBuffer = buf;
 
     if (!state->monitor->shouldSkipScheduleFrameOnMouseEvent())
-        g_pCompositor->scheduleFrameForMonitor(state->monitor.get(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
+        g_pCompositor->scheduleFrameForMonitor(state->monitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
 
     return true;
 }
@@ -446,7 +428,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
     CRegion damage = {0, 0, INT16_MAX, INT16_MAX};
 
     g_pHyprRenderer->makeEGLCurrent();
-    g_pHyprOpenGL->m_RenderData.pMonitor = state->monitor.get();
+    g_pHyprOpenGL->m_RenderData.pMonitor = state->monitor;
 
     auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->cursorSwapchain->currentOptions().format);
     if (!RBO) {
@@ -503,7 +485,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
 
     RBO->bind();
 
-    g_pHyprOpenGL->beginSimple(state->monitor.get(), damage, RBO);
+    g_pHyprOpenGL->beginSimple(state->monitor.lock(), damage, RBO);
     g_pHyprOpenGL->clear(CColor{0.F, 0.F, 0.F, 0.F});
 
     CBox xbox = {{}, Vector2D{currentCursorImage.size / currentCursorImage.scale * state->monitor->scale}.round()};
@@ -514,7 +496,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
 
     g_pHyprOpenGL->end();
     glFlush();
-    g_pHyprOpenGL->m_RenderData.pMonitor = nullptr;
+    g_pHyprOpenGL->m_RenderData.pMonitor.reset();
 
     g_pHyprRenderer->onRenderbufferDestroy(RBO.get());
 
diff --git a/src/managers/PointerManager.hpp b/src/managers/PointerManager.hpp
index 6b89eb16..aef2490d 100644
--- a/src/managers/PointerManager.hpp
+++ b/src/managers/PointerManager.hpp
@@ -45,8 +45,6 @@ class CPointerManager {
 
     void lockSoftwareForMonitor(SP<CMonitor> pMonitor);
     void unlockSoftwareForMonitor(SP<CMonitor> pMonitor);
-    void lockSoftwareForMonitor(CMonitor* pMonitor);
-    void unlockSoftwareForMonitor(CMonitor* pMonitor);
     void lockSoftwareAll();
     void unlockSoftwareAll();
     bool softwareLockedFor(SP<CMonitor> pMonitor);
diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp
index 25a34657..601e564d 100644
--- a/src/managers/ProtocolManager.cpp
+++ b/src/managers/ProtocolManager.cpp
@@ -62,7 +62,7 @@
 #include <aquamarine/buffer/Buffer.hpp>
 #include <aquamarine/backend/Backend.hpp>
 
-void CProtocolManager::onMonitorModeChange(CMonitor* pMonitor) {
+void CProtocolManager::onMonitorModeChange(PHLMONITOR pMonitor) {
     const bool ISMIRROR = pMonitor->isMirror();
 
     // onModeChanged we check if the current mirror status matches the global.
@@ -84,7 +84,7 @@ CProtocolManager::CProtocolManager() {
 
     // Outputs are a bit dumb, we have to agree.
     static auto P = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any param) {
-        auto M = std::any_cast<CMonitor*>(param);
+        auto M = std::any_cast<PHLMONITOR>(param);
 
         // ignore mirrored outputs. I don't think this will ever be hit as mirrors are applied after
         // this event is emitted iirc.
@@ -103,7 +103,7 @@ CProtocolManager::CProtocolManager() {
     });
 
     static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {
-        auto M = std::any_cast<CMonitor*>(param);
+        auto M = std::any_cast<PHLMONITOR>(param);
         if (!PROTO::outputs.contains(M->szName))
             return;
         PROTO::outputs.at(M->szName)->remove();
diff --git a/src/managers/ProtocolManager.hpp b/src/managers/ProtocolManager.hpp
index d5629e9e..69dadd0f 100644
--- a/src/managers/ProtocolManager.hpp
+++ b/src/managers/ProtocolManager.hpp
@@ -16,7 +16,7 @@ class CProtocolManager {
   private:
     std::unordered_map<std::string, CHyprSignalListener> m_mModeChangeListeners;
 
-    void                                                 onMonitorModeChange(CMonitor* pMonitor);
+    void                                                 onMonitorModeChange(PHLMONITOR pMonitor);
 };
 
 inline std::unique_ptr<CProtocolManager> g_pProtocolManager;
diff --git a/src/managers/SessionLockManager.cpp b/src/managers/SessionLockManager.cpp
index 4e05695a..1b28cc27 100644
--- a/src/managers/SessionLockManager.cpp
+++ b/src/managers/SessionLockManager.cpp
@@ -73,7 +73,7 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
         g_pInputManager->refocus();
 
         for (auto const& m : g_pCompositor->m_vMonitors)
-            g_pHyprRenderer->damageMonitor(m.get());
+            g_pHyprRenderer->damageMonitor(m);
     });
 
     m_pSessionLock->listeners.destroy = pLock->events.destroyed.registerListener([this](std::any data) {
@@ -81,7 +81,7 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
         g_pCompositor->focusSurface(nullptr);
 
         for (auto const& m : g_pCompositor->m_vMonitors)
-            g_pHyprRenderer->damageMonitor(m.get());
+            g_pHyprRenderer->damageMonitor(m);
     });
 
     g_pCompositor->focusSurface(nullptr);
diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp
index 8b63d37e..7b3081a2 100644
--- a/src/managers/XWaylandManager.cpp
+++ b/src/managers/XWaylandManager.cpp
@@ -247,7 +247,7 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
 
     static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
 
-    CMonitor*   pMonitor     = nullptr;
+    PHLMONITOR  pMonitor     = nullptr;
     double      bestDistance = __FLT_MAX__;
     for (const auto& m : g_pCompositor->m_vMonitors) {
         const auto SIZ = *PXWLFORCESCALEZERO ? m->vecTransformedSize : m->vecSize;
@@ -257,7 +257,7 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
 
         if (distance < bestDistance) {
             bestDistance = distance;
-            pMonitor     = m.get();
+            pMonitor     = m;
         }
     }
 
diff --git a/src/managers/input/InputManager.cpp b/src/managers/input/InputManager.cpp
index eef5e040..196f0b71 100644
--- a/src/managers/input/InputManager.cpp
+++ b/src/managers/input/InputManager.cpp
@@ -172,7 +172,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
     m_vLastCursorPosFloored = MOUSECOORDSFLOORED;
 
-    const auto PMONITOR = isLocked() && g_pCompositor->m_pLastMonitor ? g_pCompositor->m_pLastMonitor.get() : g_pCompositor->getMonitorFromCursor();
+    const auto PMONITOR = isLocked() && g_pCompositor->m_pLastMonitor ? g_pCompositor->m_pLastMonitor.lock() : g_pCompositor->getMonitorFromCursor();
 
     // this can happen if there are no displays hooked up to Hyprland
     if (PMONITOR == nullptr)
@@ -212,7 +212,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             Debug::log(ERR, "BUG THIS: Null SURF/CONSTRAINT in mouse refocus. Ignoring constraints. {:x} {:x}", (uintptr_t)SURF.get(), (uintptr_t)CONSTRAINT.get());
     }
 
-    if (PMONITOR != g_pCompositor->m_pLastMonitor.get() && (*PMOUSEFOCUSMON || refocus) && m_pForcedFocus.expired())
+    if (PMONITOR != g_pCompositor->m_pLastMonitor && (*PMOUSEFOCUSMON || refocus) && m_pForcedFocus.expired())
         g_pCompositor->setActiveMonitor(PMONITOR);
 
     if (g_pSessionLockManager->isSessionLocked()) {
@@ -370,7 +370,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords, &pFoundLayerSurface);
 
     if (g_pPointerManager->softwareLockedFor(PMONITOR->self.lock()) > 0 && !skipFrameSchedule)
-        g_pCompositor->scheduleFrameForMonitor(g_pCompositor->m_pLastMonitor.get(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE);
+        g_pCompositor->scheduleFrameForMonitor(g_pCompositor->m_pLastMonitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE);
 
     // grabs
     if (g_pSeatManager->seatGrab && !g_pSeatManager->seatGrab->accepts(foundSurface)) {
@@ -720,7 +720,7 @@ void CInputManager::processMouseDownNormal(const IPointer::SButtonEvent& e) {
     // notify app if we didnt handle it
     g_pSeatManager->sendPointerButton(e.timeMs, e.button, e.state);
 
-    if (const auto PMON = g_pCompositor->getMonitorFromVector(mouseCoords); PMON != g_pCompositor->m_pLastMonitor.get() && PMON)
+    if (const auto PMON = g_pCompositor->getMonitorFromVector(mouseCoords); PMON != g_pCompositor->m_pLastMonitor && PMON)
         g_pCompositor->setActiveMonitor(PMON);
 
     if (g_pSeatManager->seatGrab && e.state == WL_POINTER_BUTTON_STATE_PRESSED) {
@@ -1359,7 +1359,7 @@ void CInputManager::refocus() {
     mouseMoveUnified(0, true);
 }
 
-void CInputManager::refocusLastWindow(CMonitor* pMonitor) {
+void CInputManager::refocusLastWindow(PHLMONITOR pMonitor) {
     if (!pMonitor) {
         refocus();
         return;
diff --git a/src/managers/input/InputManager.hpp b/src/managers/input/InputManager.hpp
index d5634796..10faff24 100644
--- a/src/managers/input/InputManager.hpp
+++ b/src/managers/input/InputManager.hpp
@@ -112,7 +112,7 @@ class CInputManager {
 
     Vector2D           getMouseCoordsInternal();
     void               refocus();
-    void               refocusLastWindow(CMonitor* pMonitor);
+    void               refocusLastWindow(PHLMONITOR pMonitor);
     void               simulateMouseMovement();
     void               sendMotionEventsToFocused();
 
diff --git a/src/managers/input/InputMethodPopup.cpp b/src/managers/input/InputMethodPopup.cpp
index cf48f2a5..ffb4edcc 100644
--- a/src/managers/input/InputMethodPopup.cpp
+++ b/src/managers/input/InputMethodPopup.cpp
@@ -100,11 +100,11 @@ void CInputPopup::updateBox() {
         cursorBoxParent = {0, 0, (int)parentBox.w, (int)parentBox.h};
     }
 
-    Vector2D  currentPopupSize = surface->getViewporterCorrectedSize() / surface->resource()->current.scale;
+    Vector2D   currentPopupSize = surface->getViewporterCorrectedSize() / surface->resource()->current.scale;
 
-    CMonitor* pMonitor = g_pCompositor->getMonitorFromVector(parentBox.middle());
+    PHLMONITOR pMonitor = g_pCompositor->getMonitorFromVector(parentBox.middle());
 
-    Vector2D  popupOffset(0, 0);
+    Vector2D   popupOffset(0, 0);
 
     if (parentBox.y + cursorBoxParent.y + cursorBoxParent.height + currentPopupSize.y > pMonitor->vecPosition.y + pMonitor->vecSize.y)
         popupOffset.y -= currentPopupSize.y;
diff --git a/src/managers/input/Swipe.cpp b/src/managers/input/Swipe.cpp
index aa1d3274..8f95c6c6 100644
--- a/src/managers/input/Swipe.cpp
+++ b/src/managers/input/Swipe.cpp
@@ -33,7 +33,7 @@ void CInputManager::beginWorkspaceSwipe() {
 
     m_sActiveSwipe.pWorkspaceBegin = PWORKSPACE;
     m_sActiveSwipe.delta           = 0;
-    m_sActiveSwipe.pMonitor        = g_pCompositor->m_pLastMonitor.get();
+    m_sActiveSwipe.pMonitor        = g_pCompositor->m_pLastMonitor;
     m_sActiveSwipe.avgSpeed        = 0;
     m_sActiveSwipe.speedPoints     = 0;
 
@@ -179,7 +179,7 @@ void CInputManager::endWorkspaceSwipe() {
     }
     m_sActiveSwipe.pWorkspaceBegin->rememberPrevWorkspace(pSwitchedTo);
 
-    g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+    g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock());
 
     if (PWORKSPACEL)
         PWORKSPACEL->m_bForceRendering = false;
@@ -264,7 +264,7 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
 
         if (workspaceIDLeft > m_sActiveSwipe.pWorkspaceBegin->m_iID || !PWORKSPACE) {
             if (*PSWIPENEW) {
-                g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+                g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock());
 
                 if (VERTANIMS)
                     m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
@@ -304,7 +304,7 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
 
         if (workspaceIDRight < m_sActiveSwipe.pWorkspaceBegin->m_iID || !PWORKSPACE) {
             if (*PSWIPENEW) {
-                g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+                g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock());
 
                 if (VERTANIMS)
                     m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
@@ -341,7 +341,7 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
         g_pCompositor->updateWorkspaceWindowDecos(workspaceIDRight);
     }
 
-    g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+    g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock());
 
     g_pCompositor->updateWorkspaceWindowDecos(m_sActiveSwipe.pWorkspaceBegin->m_iID);
 
diff --git a/src/managers/input/Touch.cpp b/src/managers/input/Touch.cpp
index 0333648a..454391af 100644
--- a/src/managers/input/Touch.cpp
+++ b/src/managers/input/Touch.cpp
@@ -18,7 +18,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
 
     auto PMONITOR = g_pCompositor->getMonitorFromName(!e.device->boundOutput.empty() ? e.device->boundOutput : "");
 
-    PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_pLastMonitor.get();
+    PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_pLastMonitor.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 1163a5e7..ffc335c9 100644
--- a/src/protocols/ForeignToplevelWlr.cpp
+++ b/src/protocols/ForeignToplevelWlr.cpp
@@ -44,7 +44,7 @@ CForeignToplevelHandleWlr::CForeignToplevelHandleWlr(SP<CZwlrForeignToplevelHand
 
                 if (PWINDOW->m_pWorkspace != monitor->activeWorkspace) {
                     g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, monitor->activeWorkspace);
-                    g_pCompositor->setActiveMonitor(monitor.get());
+                    g_pCompositor->setActiveMonitor(monitor);
                 }
             }
         }
@@ -116,7 +116,7 @@ wl_resource* CForeignToplevelHandleWlr::res() {
     return resource->resource();
 }
 
-void CForeignToplevelHandleWlr::sendMonitor(CMonitor* pMonitor) {
+void CForeignToplevelHandleWlr::sendMonitor(PHLMONITOR pMonitor) {
     if (lastMonitorID == pMonitor->ID)
         return;
 
diff --git a/src/protocols/ForeignToplevelWlr.hpp b/src/protocols/ForeignToplevelWlr.hpp
index e726707d..880b7a14 100644
--- a/src/protocols/ForeignToplevelWlr.hpp
+++ b/src/protocols/ForeignToplevelWlr.hpp
@@ -22,7 +22,7 @@ class CForeignToplevelHandleWlr {
     bool                             closed        = false;
     MONITORID                        lastMonitorID = MONITOR_INVALID;
 
-    void                             sendMonitor(CMonitor* pMonitor);
+    void                             sendMonitor(PHLMONITOR pMonitor);
     void                             sendState();
 
     friend class CForeignToplevelWlrManager;
diff --git a/src/protocols/GammaControl.cpp b/src/protocols/GammaControl.cpp
index e794e543..14c6596f 100644
--- a/src/protocols/GammaControl.cpp
+++ b/src/protocols/GammaControl.cpp
@@ -143,11 +143,11 @@ void CGammaControl::applyToMonitor() {
         pMonitor->output->state->setGammaLut({});
     }
 
-    g_pHyprRenderer->damageMonitor(pMonitor.get());
+    g_pHyprRenderer->damageMonitor(pMonitor.lock());
 }
 
-CMonitor* CGammaControl::getMonitor() {
-    return pMonitor ? pMonitor.get() : nullptr;
+PHLMONITOR CGammaControl::getMonitor() {
+    return pMonitor ? pMonitor.lock() : nullptr;
 }
 
 void CGammaControl::onMonitorDestroy() {
@@ -186,7 +186,7 @@ void CGammaControlProtocol::onGetGammaControl(CZwlrGammaControlManagerV1* pMgr,
     }
 }
 
-void CGammaControlProtocol::applyGammaToState(CMonitor* pMonitor) {
+void CGammaControlProtocol::applyGammaToState(PHLMONITOR pMonitor) {
     for (auto const& g : m_vGammaControllers) {
         if (g->getMonitor() != pMonitor)
             continue;
diff --git a/src/protocols/GammaControl.hpp b/src/protocols/GammaControl.hpp
index bbdc0139..5cfcd60a 100644
--- a/src/protocols/GammaControl.hpp
+++ b/src/protocols/GammaControl.hpp
@@ -14,13 +14,13 @@ class CGammaControl {
     CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* output);
     ~CGammaControl();
 
-    bool      good();
-    void      applyToMonitor();
-    CMonitor* getMonitor();
+    bool       good();
+    void       applyToMonitor();
+    PHLMONITOR getMonitor();
 
   private:
     SP<CZwlrGammaControlV1> resource;
-    WP<CMonitor>            pMonitor;
+    PHLMONITORREF           pMonitor;
     size_t                  gammaSize     = 0;
     bool                    gammaTableSet = false;
     std::vector<uint16_t>   gammaTable; // [r,g,b]+
@@ -39,7 +39,7 @@ class CGammaControlProtocol : public IWaylandProtocol {
 
     virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
 
-    void         applyGammaToState(CMonitor* pMonitor);
+    void         applyGammaToState(PHLMONITOR pMonitor);
 
   private:
     void onManagerResourceDestroy(wl_resource* res);
diff --git a/src/protocols/LayerShell.cpp b/src/protocols/LayerShell.cpp
index c02d23f3..5ceae5f2 100644
--- a/src/protocols/LayerShell.cpp
+++ b/src/protocols/LayerShell.cpp
@@ -14,8 +14,8 @@ void CLayerShellResource::SState::reset() {
     margin        = {0, 0, 0, 0};
 }
 
-CLayerShellResource::CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<CWLSurfaceResource> surf_, std::string namespace_, CMonitor* pMonitor, zwlrLayerShellV1Layer layer) :
-    layerNamespace(namespace_), surface(surf_), resource(resource_) {
+CLayerShellResource::CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<CWLSurfaceResource> surf_, std::string namespace_, PHLMONITOR pMonitor,
+                                         zwlrLayerShellV1Layer layer) : layerNamespace(namespace_), surface(surf_), resource(resource_) {
     if (!good())
         return;
 
@@ -218,7 +218,7 @@ void CLayerShellProtocol::destroyResource(CLayerShellResource* surf) {
 
 void CLayerShellProtocol::onGetLayerSurface(CZwlrLayerShellV1* pMgr, uint32_t id, wl_resource* surface, wl_resource* output, zwlrLayerShellV1Layer layer, std::string namespace_) {
     const auto CLIENT   = pMgr->client();
-    const auto PMONITOR = output ? CWLOutputResource::fromResource(output)->monitor.get() : nullptr;
+    const auto PMONITOR = output ? CWLOutputResource::fromResource(output)->monitor.lock() : nullptr;
     auto       SURF     = CWLSurfaceResource::fromResource(surface);
 
     if (!SURF) {
diff --git a/src/protocols/LayerShell.hpp b/src/protocols/LayerShell.hpp
index 801bdfd6..ad6c1a75 100644
--- a/src/protocols/LayerShell.hpp
+++ b/src/protocols/LayerShell.hpp
@@ -26,7 +26,7 @@ class CLayerShellRole : public ISurfaceRole {
 };
 class CLayerShellResource {
   public:
-    CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<CWLSurfaceResource> surf_, std::string namespace_, CMonitor* pMonitor, zwlrLayerShellV1Layer layer);
+    CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<CWLSurfaceResource> surf_, std::string namespace_, PHLMONITOR pMonitor, zwlrLayerShellV1Layer layer);
     ~CLayerShellResource();
 
     bool good();
diff --git a/src/protocols/LinuxDMABUF.cpp b/src/protocols/LinuxDMABUF.cpp
index d9dd1d01..8e26c74f 100644
--- a/src/protocols/LinuxDMABUF.cpp
+++ b/src/protocols/LinuxDMABUF.cpp
@@ -452,7 +452,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
             }
 
             static auto monitorAdded = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any param) {
-                auto pMonitor = std::any_cast<CMonitor*>(param);
+                auto pMonitor = std::any_cast<PHLMONITOR>(param);
                 auto mon      = pMonitor->self.lock();
                 auto tranche  = SDMABUFTranche{
                      .device  = mainDevice,
@@ -464,7 +464,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
             });
 
             static auto monitorRemoved = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {
-                auto pMonitor = std::any_cast<CMonitor*>(param);
+                auto pMonitor = std::any_cast<PHLMONITOR>(param);
                 auto mon      = pMonitor->self.lock();
                 std::erase_if(formatTable->monitorTranches, [mon](std::pair<SP<CMonitor>, SDMABUFTranche> pair) { return pair.first == mon; });
                 resetFormatTable();
diff --git a/src/protocols/OutputManagement.cpp b/src/protocols/OutputManagement.cpp
index 3fd0cf6c..77cedd41 100644
--- a/src/protocols/OutputManagement.cpp
+++ b/src/protocols/OutputManagement.cpp
@@ -29,12 +29,12 @@ COutputManager::COutputManager(SP<CZwlrOutputManagerV1> resource_) : resource(re
 
     // send all heads at start
     for (auto const& m : g_pCompositor->m_vRealMonitors) {
-        if (m.get() == g_pCompositor->m_pUnsafeOutput)
+        if (m == g_pCompositor->m_pUnsafeOutput)
             continue;
 
         LOGM(LOG, " | sending output head for {}", m->szName);
 
-        makeAndSendNewHead(m.get());
+        makeAndSendNewHead(m);
     }
 
     sendDone();
@@ -44,7 +44,7 @@ bool COutputManager::good() {
     return resource->resource();
 }
 
-void COutputManager::makeAndSendNewHead(CMonitor* pMonitor) {
+void COutputManager::makeAndSendNewHead(PHLMONITOR pMonitor) {
     if (stopped)
         return;
 
@@ -63,7 +63,7 @@ void COutputManager::makeAndSendNewHead(CMonitor* pMonitor) {
     RESOURCE->sendAllData();
 }
 
-void COutputManager::ensureMonitorSent(CMonitor* pMonitor) {
+void COutputManager::ensureMonitorSent(PHLMONITOR pMonitor) {
     if (pMonitor == g_pCompositor->m_pUnsafeOutput)
         return;
 
@@ -86,7 +86,7 @@ void COutputManager::sendDone() {
     resource->sendDone(wl_display_next_serial(g_pCompositor->m_sWLDisplay));
 }
 
-COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, CMonitor* pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
+COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
     if (!good())
         return;
 
@@ -105,7 +105,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, CMonitor* pMonitor_) :
             m->resource->sendFinished();
         }
 
-        pMonitor = nullptr;
+        pMonitor.reset();
         for (auto const& m : PROTO::outputManagement->m_vManagers) {
             m->sendDone();
         }
@@ -221,8 +221,8 @@ void COutputHead::makeAndSendNewMode(SP<Aquamarine::SOutputMode> mode) {
     RESOURCE->sendAllData();
 }
 
-CMonitor* COutputHead::monitor() {
-    return pMonitor;
+PHLMONITOR COutputHead::monitor() {
+    return pMonitor.lock();
 }
 
 COutputMode::COutputMode(SP<CZwlrOutputModeV1> resource_, SP<Aquamarine::SOutputMode> mode_) : resource(resource_), mode(mode_) {
@@ -424,14 +424,12 @@ bool COutputConfiguration::applyTestConfiguration(bool test) {
     return true;
 }
 
-COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHeadV1> resource_, CMonitor* pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
+COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHeadV1> resource_, PHLMONITOR pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
     if (!good())
         return;
 
     resource->setOnDestroy([this](CZwlrOutputConfigurationHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
 
-    listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any d) { pMonitor = nullptr; });
-
     resource->setSetMode([this](CZwlrOutputConfigurationHeadV1* r, wl_resource* outputMode) {
         const auto MODE = PROTO::outputManagement->modeFromResource(outputMode);
 
@@ -612,7 +610,7 @@ void COutputManagementProtocol::destroyResource(COutputConfigurationHead* resour
 void COutputManagementProtocol::updateAllOutputs() {
     for (auto const& m : g_pCompositor->m_vRealMonitors) {
         for (auto const& mgr : m_vManagers) {
-            mgr->ensureMonitorSent(m.get());
+            mgr->ensureMonitorSent(m);
         }
     }
 }
diff --git a/src/protocols/OutputManagement.hpp b/src/protocols/OutputManagement.hpp
index f4a84475..6deab017 100644
--- a/src/protocols/OutputManagement.hpp
+++ b/src/protocols/OutputManagement.hpp
@@ -56,7 +56,7 @@ class COutputManager {
     COutputManager(SP<CZwlrOutputManagerV1> resource_);
 
     bool good();
-    void ensureMonitorSent(CMonitor* pMonitor);
+    void ensureMonitorSent(PHLMONITOR pMonitor);
     void sendDone();
 
     // holds the states for this manager.
@@ -70,7 +70,7 @@ class COutputManager {
 
     std::vector<WP<COutputHead>> heads;
 
-    void                         makeAndSendNewHead(CMonitor* pMonitor);
+    void                         makeAndSendNewHead(PHLMONITOR pMonitor);
     friend class COutputManagementProtocol;
 };
 
@@ -92,16 +92,16 @@ class COutputMode {
 
 class COutputHead {
   public:
-    COutputHead(SP<CZwlrOutputHeadV1> resource_, CMonitor* pMonitor_);
+    COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_);
 
-    bool      good();
-    void      sendAllData(); // this has to be separate as we need to send the head first, then set the data
-    void      updateMode();
-    CMonitor* monitor();
+    bool       good();
+    void       sendAllData(); // this has to be separate as we need to send the head first, then set the data
+    void       updateMode();
+    PHLMONITOR monitor();
 
   private:
     SP<CZwlrOutputHeadV1>        resource;
-    CMonitor*                    pMonitor = nullptr;
+    PHLMONITORREF                pMonitor;
 
     void                         makeAndSendNewMode(SP<Aquamarine::SOutputMode> mode);
     void                         sendCurrentMode();
@@ -119,7 +119,7 @@ class COutputHead {
 
 class COutputConfigurationHead {
   public:
-    COutputConfigurationHead(SP<CZwlrOutputConfigurationHeadV1> resource_, CMonitor* pMonitor_);
+    COutputConfigurationHead(SP<CZwlrOutputConfigurationHeadV1> resource_, PHLMONITOR pMonitor_);
 
     bool                   good();
 
@@ -127,11 +127,7 @@ class COutputConfigurationHead {
 
   private:
     SP<CZwlrOutputConfigurationHeadV1> resource;
-    CMonitor*                          pMonitor = nullptr;
-
-    struct {
-        CHyprSignalListener monitorDestroy;
-    } listeners;
+    PHLMONITORREF                      pMonitor;
 
     friend class COutputConfiguration;
 };
diff --git a/src/protocols/OutputPower.cpp b/src/protocols/OutputPower.cpp
index 0c324bf0..257155e4 100644
--- a/src/protocols/OutputPower.cpp
+++ b/src/protocols/OutputPower.cpp
@@ -2,7 +2,7 @@
 #include "../Compositor.hpp"
 #include "core/Output.hpp"
 
-COutputPower::COutputPower(SP<CZwlrOutputPowerV1> resource_, CMonitor* pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
+COutputPower::COutputPower(SP<CZwlrOutputPowerV1> resource_, PHLMONITOR pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
     if (!resource->resource())
         return;
 
@@ -24,7 +24,7 @@ COutputPower::COutputPower(SP<CZwlrOutputPowerV1> resource_, CMonitor* pMonitor_
     resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF);
 
     listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any v) {
-        pMonitor = nullptr;
+        pMonitor.reset();
         resource->sendFailed();
     });
 
@@ -68,7 +68,7 @@ void COutputPowerProtocol::onGetOutputPower(CZwlrOutputPowerManagerV1* pMgr, uin
     }
 
     const auto CLIENT   = pMgr->client();
-    const auto RESOURCE = m_vOutputPowers.emplace_back(std::make_unique<COutputPower>(makeShared<CZwlrOutputPowerV1>(CLIENT, pMgr->version(), id), OUTPUT->monitor.get())).get();
+    const auto RESOURCE = m_vOutputPowers.emplace_back(std::make_unique<COutputPower>(makeShared<CZwlrOutputPowerV1>(CLIENT, pMgr->version(), id), OUTPUT->monitor.lock())).get();
 
     if (!RESOURCE->good()) {
         pMgr->noMemory();
diff --git a/src/protocols/OutputPower.hpp b/src/protocols/OutputPower.hpp
index 410742ca..91f2c5f3 100644
--- a/src/protocols/OutputPower.hpp
+++ b/src/protocols/OutputPower.hpp
@@ -11,14 +11,14 @@ class CMonitor;
 
 class COutputPower {
   public:
-    COutputPower(SP<CZwlrOutputPowerV1> resource_, CMonitor* pMonitor);
+    COutputPower(SP<CZwlrOutputPowerV1> resource_, PHLMONITOR pMonitor);
 
     bool good();
 
   private:
     SP<CZwlrOutputPowerV1> resource;
 
-    CMonitor*              pMonitor = nullptr;
+    PHLMONITORREF          pMonitor;
 
     struct {
         CHyprSignalListener monitorDestroy;
diff --git a/src/protocols/PresentationTime.cpp b/src/protocols/PresentationTime.cpp
index 71f74cd5..b66694bf 100644
--- a/src/protocols/PresentationTime.cpp
+++ b/src/protocols/PresentationTime.cpp
@@ -73,8 +73,8 @@ void CPresentationFeedback::sendQueued(SP<CQueuedPresentationData> data, timespe
 
 CPresentationProtocol::CPresentationProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
     static auto P = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {
-        const auto PMONITOR = std::any_cast<CMonitor*>(param);
-        std::erase_if(m_vQueue, [PMONITOR](const auto& other) { return !other->surface || other->pMonitor.get() == PMONITOR; });
+        const auto PMONITOR = std::any_cast<PHLMONITOR>(param);
+        std::erase_if(m_vQueue, [PMONITOR](const auto& other) { return !other->surface || other->pMonitor == PMONITOR; });
     });
 }
 
diff --git a/src/protocols/Screencopy.cpp b/src/protocols/Screencopy.cpp
index 1b06a1fa..780c081d 100644
--- a/src/protocols/Screencopy.cpp
+++ b/src/protocols/Screencopy.cpp
@@ -19,7 +19,7 @@ CScreencopyFrame::CScreencopyFrame(SP<CZwlrScreencopyFrameV1> resource_, int32_t
         return;
 
     overlayCursor = !!overlay_cursor;
-    pMonitor      = CWLOutputResource::fromResource(output)->monitor.get();
+    pMonitor      = CWLOutputResource::fromResource(output)->monitor;
 
     if (!pMonitor) {
         LOGM(ERR, "Client requested sharing of a monitor that doesnt exist");
@@ -38,7 +38,7 @@ CScreencopyFrame::CScreencopyFrame(SP<CZwlrScreencopyFrameV1> resource_, int32_t
 
     g_pHyprRenderer->makeEGLCurrent();
 
-    shmFormat = g_pHyprOpenGL->getPreferredReadFormat(pMonitor);
+    shmFormat = g_pHyprOpenGL->getPreferredReadFormat(pMonitor.lock());
     if (shmFormat == DRM_FORMAT_INVALID) {
         LOGM(ERR, "No format supported by renderer in capture output");
         resource->sendFailed();
@@ -87,7 +87,7 @@ void CScreencopyFrame::copy(CZwlrScreencopyFrameV1* pFrame, wl_resource* buffer_
         return;
     }
 
-    if (!g_pCompositor->monitorExists(pMonitor)) {
+    if (!g_pCompositor->monitorExists(pMonitor.lock())) {
         LOGM(ERR, "Client requested sharing of a monitor that is gone");
         resource->sendFailed();
         PROTO::screencopy->destroyResource(this);
@@ -165,7 +165,7 @@ void CScreencopyFrame::copy(CZwlrScreencopyFrameV1* pFrame, wl_resource* buffer_
     }
 
     if (!withDamage)
-        g_pHyprRenderer->damageMonitor(pMonitor);
+        g_pHyprRenderer->damageMonitor(pMonitor.lock());
 }
 
 void CScreencopyFrame::share() {
@@ -205,7 +205,7 @@ bool CScreencopyFrame::copyDmabuf() {
 
     CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
 
-    if (!g_pHyprRenderer->beginRender(pMonitor, fakeDamage, RENDER_MODE_TO_BUFFER, buffer.lock(), nullptr, true)) {
+    if (!g_pHyprRenderer->beginRender(pMonitor.lock(), fakeDamage, RENDER_MODE_TO_BUFFER, buffer.lock(), nullptr, true)) {
         LOGM(ERR, "Can't copy: failed to begin rendering to dma frame");
         return false;
     }
@@ -240,7 +240,7 @@ bool CScreencopyFrame::copyShm() {
     CFramebuffer fb;
     fb.alloc(box.w, box.h, pMonitor->output->state->state().drmFormat);
 
-    if (!g_pHyprRenderer->beginRender(pMonitor, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &fb, true)) {
+    if (!g_pHyprRenderer->beginRender(pMonitor.lock(), fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &fb, true)) {
         LOGM(ERR, "Can't copy: failed to begin rendering");
         return false;
     }
@@ -288,7 +288,7 @@ bool CScreencopyFrame::copyShm() {
         }
     }
 
-    g_pHyprOpenGL->m_RenderData.pMonitor = nullptr;
+    g_pHyprOpenGL->m_RenderData.pMonitor.reset();
 
     LOGM(TRACE, "Copied frame via shm");
 
@@ -402,7 +402,7 @@ void CScreencopyProtocol::destroyResource(CScreencopyFrame* frame) {
     std::erase_if(m_vFramesAwaitingWrite, [&](const auto& other) { return !other || other.get() == frame; });
 }
 
-void CScreencopyProtocol::onOutputCommit(CMonitor* pMonitor) {
+void CScreencopyProtocol::onOutputCommit(PHLMONITOR pMonitor) {
     if (m_vFramesAwaitingWrite.empty()) {
         g_pHyprRenderer->m_bDirectScanoutBlocked = false;
         return; // nothing to share
diff --git a/src/protocols/Screencopy.hpp b/src/protocols/Screencopy.hpp
index e121d0fd..62c9f8b8 100644
--- a/src/protocols/Screencopy.hpp
+++ b/src/protocols/Screencopy.hpp
@@ -60,7 +60,7 @@ class CScreencopyFrame {
   private:
     SP<CZwlrScreencopyFrameV1> resource;
 
-    CMonitor*                  pMonitor        = nullptr;
+    PHLMONITORREF              pMonitor;
     bool                       overlayCursor   = false;
     bool                       withDamage      = false;
     bool                       lockedSWCursors = false;
@@ -88,7 +88,7 @@ class CScreencopyProtocol : public IWaylandProtocol {
     void         destroyResource(CScreencopyClient* resource);
     void         destroyResource(CScreencopyFrame* resource);
 
-    void         onOutputCommit(CMonitor* pMonitor);
+    void         onOutputCommit(PHLMONITOR pMonitor);
 
   private:
     std::vector<SP<CScreencopyFrame>>  m_vFrames;
@@ -98,7 +98,7 @@ class CScreencopyProtocol : public IWaylandProtocol {
     SP<CEventLoopTimer>                m_pSoftwareCursorTimer;
     bool                               m_bTimerArmed = false;
 
-    void                               shareAllFrames(CMonitor* pMonitor);
+    void                               shareAllFrames(PHLMONITOR pMonitor);
     void                               shareFrame(CScreencopyFrame* frame);
     void                               sendFrameDamage(CScreencopyFrame* frame);
     bool                               copyFrameDmabuf(CScreencopyFrame* frame);
diff --git a/src/protocols/SessionLock.cpp b/src/protocols/SessionLock.cpp
index b1f701bf..642a5b89 100644
--- a/src/protocols/SessionLock.cpp
+++ b/src/protocols/SessionLock.cpp
@@ -5,7 +5,7 @@
 #include "core/Compositor.hpp"
 #include "core/Output.hpp"
 
-CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_, SP<CWLSurfaceResource> surface_, CMonitor* pMonitor_, WP<CSessionLock> owner_) :
+CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_, SP<CWLSurfaceResource> surface_, PHLMONITOR pMonitor_, WP<CSessionLock> owner_) :
     resource(resource_), sessionLock(owner_), pSurface(surface_), pMonitor(pMonitor_) {
     if (!resource->resource())
         return;
@@ -82,8 +82,8 @@ bool CSessionLockSurface::inert() {
     return sessionLock.expired();
 }
 
-CMonitor* CSessionLockSurface::monitor() {
-    return pMonitor;
+PHLMONITOR CSessionLockSurface::monitor() {
+    return pMonitor.lock();
 }
 
 SP<CWLSurfaceResource> CSessionLockSurface::surface() {
@@ -184,7 +184,7 @@ void CSessionLockProtocol::onGetLockSurface(CExtSessionLockV1* lock, uint32_t id
     LOGM(LOG, "New sessionLockSurface with id {}", id);
 
     auto             PSURFACE = CWLSurfaceResource::fromResource(surface);
-    auto             PMONITOR = CWLOutputResource::fromResource(output)->monitor.get();
+    auto             PMONITOR = CWLOutputResource::fromResource(output)->monitor.lock();
 
     SP<CSessionLock> sessionLock;
     for (auto const& l : m_vLocks) {
diff --git a/src/protocols/SessionLock.hpp b/src/protocols/SessionLock.hpp
index a0c67e88..a1df6fcf 100644
--- a/src/protocols/SessionLock.hpp
+++ b/src/protocols/SessionLock.hpp
@@ -13,12 +13,12 @@ class CWLSurfaceResource;
 
 class CSessionLockSurface {
   public:
-    CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_, SP<CWLSurfaceResource> surface_, CMonitor* pMonitor_, WP<CSessionLock> owner_);
+    CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_, SP<CWLSurfaceResource> surface_, PHLMONITOR pMonitor_, WP<CSessionLock> owner_);
     ~CSessionLockSurface();
 
     bool                   good();
     bool                   inert();
-    CMonitor*              monitor();
+    PHLMONITOR             monitor();
     SP<CWLSurfaceResource> surface();
 
     struct {
@@ -31,7 +31,7 @@ class CSessionLockSurface {
     SP<CExtSessionLockSurfaceV1> resource;
     WP<CSessionLock>             sessionLock;
     WP<CWLSurfaceResource>       pSurface;
-    CMonitor*                    pMonitor = nullptr;
+    PHLMONITORREF                pMonitor;
 
     bool                         ackdConfigure = false;
     bool                         committed     = false;
diff --git a/src/protocols/ToplevelExport.cpp b/src/protocols/ToplevelExport.cpp
index 66df5926..8b6208be 100644
--- a/src/protocols/ToplevelExport.cpp
+++ b/src/protocols/ToplevelExport.cpp
@@ -362,7 +362,7 @@ void CToplevelExportProtocol::destroyResource(CToplevelExportFrame* frame) {
     std::erase_if(m_vFramesAwaitingWrite, [&](const auto& other) { return !other || other.get() == frame; });
 }
 
-void CToplevelExportProtocol::onOutputCommit(CMonitor* pMonitor) {
+void CToplevelExportProtocol::onOutputCommit(PHLMONITOR pMonitor) {
     if (m_vFramesAwaitingWrite.empty())
         return; // nothing to share
 
diff --git a/src/protocols/ToplevelExport.hpp b/src/protocols/ToplevelExport.hpp
index 9686431b..bcfa161c 100644
--- a/src/protocols/ToplevelExport.hpp
+++ b/src/protocols/ToplevelExport.hpp
@@ -80,7 +80,7 @@ class CToplevelExportProtocol : IWaylandProtocol {
     void destroyResource(CToplevelExportFrame* frame);
 
     void onWindowUnmap(PHLWINDOW pWindow);
-    void onOutputCommit(CMonitor* pMonitor);
+    void onOutputCommit(PHLMONITOR pMonitor);
 
   private:
     std::vector<SP<CToplevelExportClient>> m_vClients;
diff --git a/src/protocols/core/DataDevice.cpp b/src/protocols/core/DataDevice.cpp
index 5644f243..056a72c4 100644
--- a/src/protocols/core/DataDevice.cpp
+++ b/src/protocols/core/DataDevice.cpp
@@ -681,7 +681,7 @@ void CWLDataDeviceProtocol::abortDrag() {
     g_pSeatManager->resendEnterEvents();
 }
 
-void CWLDataDeviceProtocol::renderDND(CMonitor* pMonitor, timespec* when) {
+void CWLDataDeviceProtocol::renderDND(PHLMONITOR pMonitor, timespec* when) {
     if (!dnd.dndSurface || !dnd.dndSurface->current.texture)
         return;
 
diff --git a/src/protocols/core/DataDevice.hpp b/src/protocols/core/DataDevice.hpp
index 50e9ac61..81ca1b11 100644
--- a/src/protocols/core/DataDevice.hpp
+++ b/src/protocols/core/DataDevice.hpp
@@ -131,7 +131,7 @@ class CWLDataDeviceProtocol : public IWaylandProtocol {
     virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
 
     // renders and damages the dnd icon, if present
-    void renderDND(CMonitor* pMonitor, timespec* when);
+    void renderDND(PHLMONITOR pMonitor, timespec* when);
     // for inputmgr to force refocus
     // TODO: move handling to seatmgr
     bool dndActive();
diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp
index 833e2ccb..fc2d1012 100644
--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -340,7 +340,7 @@ CHyprOpenGLImpl::CHyprOpenGLImpl() {
 
     initAssets();
 
-    static auto P = g_pHookSystem->hookDynamic("preRender", [&](void* self, SCallbackInfo& info, std::any data) { preRender(std::any_cast<CMonitor*>(data)); });
+    static auto P = g_pHookSystem->hookDynamic("preRender", [&](void* self, SCallbackInfo& info, std::any data) { preRender(std::any_cast<PHLMONITOR>(data)); });
 
     RASSERT(eglMakeCurrent(m_pEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT), "Couldn't unset current EGL!");
 
@@ -625,7 +625,7 @@ GLuint CHyprOpenGLImpl::compileShader(const GLuint& type, std::string src, bool
     return shader;
 }
 
-bool CHyprOpenGLImpl::passRequiresIntrospection(CMonitor* pMonitor) {
+bool CHyprOpenGLImpl::passRequiresIntrospection(PHLMONITOR pMonitor) {
     // passes requiring introspection are the ones that need to render blur,
     // or when we are rendering to a multigpu target
 
@@ -731,7 +731,7 @@ bool CHyprOpenGLImpl::passRequiresIntrospection(CMonitor* pMonitor) {
     return false;
 }
 
-void CHyprOpenGLImpl::beginSimple(CMonitor* pMonitor, const CRegion& damage, SP<CRenderbuffer> rb, CFramebuffer* fb) {
+void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP<CRenderbuffer> rb, CFramebuffer* fb) {
     m_RenderData.pMonitor = pMonitor;
 
 #ifndef GLES2
@@ -783,7 +783,7 @@ void CHyprOpenGLImpl::beginSimple(CMonitor* pMonitor, const CRegion& damage, SP<
     m_RenderData.simplePass = true;
 }
 
-void CHyprOpenGLImpl::begin(CMonitor* pMonitor, const CRegion& damage_, CFramebuffer* fb, std::optional<CRegion> finalDamage) {
+void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, CFramebuffer* fb, std::optional<CRegion> finalDamage) {
     m_RenderData.pMonitor = pMonitor;
 
     static auto PFORCEINTROSPECTION = CConfigValue<Hyprlang::INT>("opengl:force_introspection");
@@ -929,7 +929,7 @@ void CHyprOpenGLImpl::end() {
     }
 
     // reset our data
-    m_RenderData.pMonitor           = nullptr;
+    m_RenderData.pMonitor.reset();
     m_RenderData.mouseZoomFactor    = 1.f;
     m_RenderData.mouseZoomUseMouse  = true;
     m_RenderData.forceIntrospection = false;
@@ -1858,11 +1858,11 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
     return currentRenderToFB;
 }
 
-void CHyprOpenGLImpl::markBlurDirtyForMonitor(CMonitor* pMonitor) {
+void CHyprOpenGLImpl::markBlurDirtyForMonitor(PHLMONITOR pMonitor) {
     m_mMonitorRenderResources[pMonitor].blurFBDirty = true;
 }
 
-void CHyprOpenGLImpl::preRender(CMonitor* pMonitor) {
+void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
     static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
     static auto PBLURXRAY        = CConfigValue<Hyprlang::INT>("decoration:blur:xray");
     static auto PBLUR            = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
@@ -2728,7 +2728,7 @@ void CHyprOpenGLImpl::initAssets() {
                                        CColor{0.9F, 0.9F, 0.9F, 0.7F}, 20, true);
 }
 
-void CHyprOpenGLImpl::createBGTextureForMonitor(CMonitor* pMonitor) {
+void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
     RASSERT(m_RenderData.pMonitor, "Tried to createBGTex without begin()!");
 
     Debug::log(LOG, "Creating a texture for BGTex");
@@ -2860,7 +2860,7 @@ void CHyprOpenGLImpl::clearWithTex() {
     auto TEXIT = m_mMonitorBGFBs.find(m_RenderData.pMonitor);
 
     if (TEXIT == m_mMonitorBGFBs.end()) {
-        createBGTextureForMonitor(m_RenderData.pMonitor);
+        createBGTextureForMonitor(m_RenderData.pMonitor.lock());
         TEXIT = m_mMonitorBGFBs.find(m_RenderData.pMonitor);
     }
 
@@ -2872,7 +2872,7 @@ void CHyprOpenGLImpl::clearWithTex() {
     }
 }
 
-void CHyprOpenGLImpl::destroyMonitorResources(CMonitor* pMonitor) {
+void CHyprOpenGLImpl::destroyMonitorResources(PHLMONITOR pMonitor) {
     g_pHyprRenderer->makeEGLCurrent();
 
     if (!g_pHyprOpenGL)
@@ -2935,7 +2935,7 @@ void CHyprOpenGLImpl::setRenderModifEnabled(bool enabled) {
     m_RenderData.renderModif.enabled = enabled;
 }
 
-uint32_t CHyprOpenGLImpl::getPreferredReadFormat(CMonitor* pMonitor) {
+uint32_t CHyprOpenGLImpl::getPreferredReadFormat(PHLMONITOR pMonitor) {
     return pMonitor->output->state->state().drmFormat;
 }
 
diff --git a/src/render/OpenGL.hpp b/src/render/OpenGL.hpp
index 0d1c267b..04f69d49 100644
--- a/src/render/OpenGL.hpp
+++ b/src/render/OpenGL.hpp
@@ -94,7 +94,7 @@ struct SMonitorRenderData {
 };
 
 struct SCurrentRenderData {
-    CMonitor*           pMonitor   = nullptr;
+    PHLMONITORREF       pMonitor;
     PHLWORKSPACE        pWorkspace = nullptr;
     Mat3x3              projection;
     Mat3x3              savedProjection;
@@ -149,8 +149,8 @@ class CHyprOpenGLImpl {
     CHyprOpenGLImpl();
     ~CHyprOpenGLImpl();
 
-    void     begin(CMonitor*, const CRegion& damage, CFramebuffer* fb = nullptr, std::optional<CRegion> finalDamage = {});
-    void     beginSimple(CMonitor*, const CRegion& damage, SP<CRenderbuffer> rb = nullptr, CFramebuffer* fb = nullptr);
+    void     begin(PHLMONITOR, const CRegion& damage, CFramebuffer* fb = nullptr, std::optional<CRegion> finalDamage = {});
+    void     beginSimple(PHLMONITOR, const CRegion& damage, SP<CRenderbuffer> rb = nullptr, CFramebuffer* fb = nullptr);
     void     end();
 
     void     renderRect(CBox*, const CColor&, int round = 0);
@@ -186,13 +186,13 @@ class CHyprOpenGLImpl {
     void     scissor(const pixman_box32*, bool transform = true);
     void     scissor(const int x, const int y, const int w, const int h, bool transform = true);
 
-    void     destroyMonitorResources(CMonitor*);
+    void     destroyMonitorResources(PHLMONITOR);
 
-    void     markBlurDirtyForMonitor(CMonitor*);
+    void     markBlurDirtyForMonitor(PHLMONITOR);
 
     void     preWindowPass();
     bool     preBlurQueued();
-    void     preRender(CMonitor*);
+    void     preRender(PHLMONITOR);
 
     void     saveBufferForMirror(CBox*);
     void     renderMirrored();
@@ -205,31 +205,31 @@ class CHyprOpenGLImpl {
 
     void     setDamage(const CRegion& damage, std::optional<CRegion> finalDamage = {});
 
-    uint32_t getPreferredReadFormat(CMonitor* pMonitor);
-    std::vector<SDRMFormat>                           getDRMFormats();
-    EGLImageKHR                                       createEGLImage(const Aquamarine::SDMABUFAttrs& attrs);
-    SP<CEGLSync>                                      createEGLSync(int fenceFD);
-    bool                                              waitForTimelinePoint(SP<CSyncTimeline> timeline, uint64_t point);
+    uint32_t getPreferredReadFormat(PHLMONITOR pMonitor);
+    std::vector<SDRMFormat>                               getDRMFormats();
+    EGLImageKHR                                           createEGLImage(const Aquamarine::SDMABUFAttrs& attrs);
+    SP<CEGLSync>                                          createEGLSync(int fenceFD);
+    bool                                                  waitForTimelinePoint(SP<CSyncTimeline> timeline, uint64_t point);
 
-    SCurrentRenderData                                m_RenderData;
+    SCurrentRenderData                                    m_RenderData;
 
-    GLint                                             m_iCurrentOutputFb = 0;
+    GLint                                                 m_iCurrentOutputFb = 0;
 
-    int                                               m_iGBMFD      = -1;
-    gbm_device*                                       m_pGbmDevice  = nullptr;
-    EGLContext                                        m_pEglContext = nullptr;
-    EGLDisplay                                        m_pEglDisplay = nullptr;
-    EGLDeviceEXT                                      m_pEglDevice  = nullptr;
+    int                                                   m_iGBMFD      = -1;
+    gbm_device*                                           m_pGbmDevice  = nullptr;
+    EGLContext                                            m_pEglContext = nullptr;
+    EGLDisplay                                            m_pEglDisplay = nullptr;
+    EGLDeviceEXT                                          m_pEglDevice  = nullptr;
 
-    bool                                              m_bReloadScreenShader = true; // at launch it can be set
+    bool                                                  m_bReloadScreenShader = true; // at launch it can be set
 
-    PHLWINDOWREF                                      m_pCurrentWindow; // hack to get the current rendered window
-    PHLLS                                             m_pCurrentLayer;  // hack to get the current rendered layer
+    PHLWINDOWREF                                          m_pCurrentWindow; // hack to get the current rendered window
+    PHLLS                                                 m_pCurrentLayer;  // hack to get the current rendered layer
 
-    std::map<PHLWINDOWREF, CFramebuffer>              m_mWindowFramebuffers;
-    std::map<PHLLSREF, CFramebuffer>                  m_mLayerFramebuffers;
-    std::unordered_map<CMonitor*, SMonitorRenderData> m_mMonitorRenderResources;
-    std::unordered_map<CMonitor*, CFramebuffer>       m_mMonitorBGFBs;
+    std::map<PHLWINDOWREF, CFramebuffer>                  m_mWindowFramebuffers;
+    std::map<PHLLSREF, CFramebuffer>                      m_mLayerFramebuffers;
+    std::unordered_map<PHLMONITORREF, SMonitorRenderData> m_mMonitorRenderResources;
+    std::unordered_map<PHLMONITORREF, CFramebuffer>       m_mMonitorBGFBs;
 
     struct {
         PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC glEGLImageTargetRenderbufferStorageOES = nullptr;
@@ -282,7 +282,7 @@ class CHyprOpenGLImpl {
     void                    logShaderError(const GLuint&, bool program = false);
     GLuint                  createProgram(const std::string&, const std::string&, bool dynamic = false);
     GLuint                  compileShader(const GLuint&, std::string, bool dynamic = false);
-    void                    createBGTextureForMonitor(CMonitor*);
+    void                    createBGTextureForMonitor(PHLMONITOR);
     void                    initShaders();
     void                    initDRMFormats();
     void                    initEGL(bool gbm);
@@ -304,7 +304,7 @@ class CHyprOpenGLImpl {
 
     void          preBlurForCurrentMonitor();
 
-    bool          passRequiresIntrospection(CMonitor* pMonitor);
+    bool          passRequiresIntrospection(PHLMONITOR pMonitor);
 
     friend class CHyprRenderer;
 };
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index bc95abc6..1165b197 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -295,7 +295,7 @@ static void renderSurface(SP<CWLSurfaceResource> surface, int x, int y, void* da
     RDATA->surfaceCounter++;
 }
 
-bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, CMonitor* pMonitor) {
+bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
     if (!pWindow->visibleOnMonitor(pMonitor))
         return false;
 
@@ -389,7 +389,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow) {
     return false;
 }
 
-void CHyprRenderer::renderWorkspaceWindowsFullscreen(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* time) {
+void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* time) {
     PHLWINDOW pWorkspaceWindow = nullptr;
 
     EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOWS);
@@ -479,7 +479,7 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(CMonitor* pMonitor, PHLWORK
     }
 }
 
-void CHyprRenderer::renderWorkspaceWindows(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* time) {
+void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* time) {
     PHLWINDOW lastWindow;
 
     EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOWS);
@@ -551,7 +551,7 @@ void CHyprRenderer::renderWorkspaceWindows(CMonitor* pMonitor, PHLWORKSPACE pWor
     }
 }
 
-void CHyprRenderer::renderWindow(PHLWINDOW pWindow, CMonitor* pMonitor, timespec* time, bool decorate, eRenderPassMode mode, bool ignorePosition, bool ignoreAllGeometry) {
+void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, timespec* time, bool decorate, eRenderPassMode mode, bool ignorePosition, bool ignoreAllGeometry) {
     if (pWindow->isHidden())
         return;
 
@@ -766,7 +766,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, CMonitor* pMonitor, timespec
     g_pHyprOpenGL->m_RenderData.clipBox = CBox();
 }
 
-void CHyprRenderer::renderLayer(PHLLS pLayer, CMonitor* pMonitor, timespec* time, bool popups) {
+void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, timespec* time, bool popups) {
     if (!pLayer)
         return;
 
@@ -835,7 +835,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, CMonitor* pMonitor, timespec* time
     g_pHyprOpenGL->m_RenderData.discardOpacity = DA;
 }
 
-void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, CMonitor* pMonitor, timespec* time) {
+void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, timespec* time) {
     const auto  POS = pPopup->globalBox().pos();
 
     SRenderData renderdata = {pMonitor, time, POS.x, POS.y};
@@ -851,7 +851,7 @@ void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, CMonitor* pMonitor, time
     SURF->breadthfirst([](SP<CWLSurfaceResource> s, const Vector2D& offset, void* data) { renderSurface(s, offset.x, offset.y, data); }, &renderdata);
 }
 
-void CHyprRenderer::renderSessionLockSurface(SSessionLockSurface* pSurface, CMonitor* pMonitor, timespec* time) {
+void CHyprRenderer::renderSessionLockSurface(SSessionLockSurface* pSurface, PHLMONITOR pMonitor, timespec* time) {
     SRenderData renderdata = {pMonitor, time, pMonitor->vecPosition.x, pMonitor->vecPosition.y};
 
     renderdata.blur     = false;
@@ -863,7 +863,7 @@ void CHyprRenderer::renderSessionLockSurface(SSessionLockSurface* pSurface, CMon
     renderdata.surface->breadthfirst([](SP<CWLSurfaceResource> s, const Vector2D& offset, void* data) { renderSurface(s, offset.x, offset.y, data); }, &renderdata);
 }
 
-void CHyprRenderer::renderAllClientsForWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* time, const Vector2D& translate, const float& scale) {
+void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* time, const Vector2D& translate, const float& scale) {
     static auto      PDIMSPECIAL      = CConfigValue<Hyprlang::FLOAT>("decoration:dim_special");
     static auto      PBLURSPECIAL     = CConfigValue<Hyprlang::INT>("decoration:blur:special");
     static auto      PBLUR            = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
@@ -1036,7 +1036,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(CMonitor* pMonitor, PHLWORKSPAC
     g_pHyprOpenGL->m_RenderData.renderModif = {};
 }
 
-void CHyprRenderer::renderLockscreen(CMonitor* pMonitor, timespec* now, const CBox& geometry) {
+void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, timespec* now, const CBox& geometry) {
     TRACY_GPU_ZONE("RenderLockscreen");
 
     if (g_pSessionLockManager->isSessionLocked()) {
@@ -1052,7 +1052,7 @@ void CHyprRenderer::renderLockscreen(CMonitor* pMonitor, timespec* now, const CB
     }
 }
 
-void CHyprRenderer::renderSessionLockMissing(CMonitor* pMonitor) {
+void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
     const auto ALPHA = g_pSessionLockManager->getRedScreenAlphaForMonitor(pMonitor->ID);
 
     CBox       monbox = {{}, pMonitor->vecPixelSize};
@@ -1181,7 +1181,7 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
     }
 }
 
-void CHyprRenderer::renderMonitor(CMonitor* pMonitor) {
+void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
     static std::chrono::high_resolution_clock::time_point renderStart        = std::chrono::high_resolution_clock::now();
     static std::chrono::high_resolution_clock::time_point renderStartOverlay = std::chrono::high_resolution_clock::now();
     static std::chrono::high_resolution_clock::time_point endRenderOverlay   = std::chrono::high_resolution_clock::now();
@@ -1410,13 +1410,13 @@ void CHyprRenderer::renderMonitor(CMonitor* pMonitor) {
 
                 renderLockscreen(pMonitor, &now, renderBox);
 
-                if (pMonitor == g_pCompositor->m_pLastMonitor.get()) {
+                if (pMonitor == g_pCompositor->m_pLastMonitor) {
                     g_pHyprNotificationOverlay->draw(pMonitor);
                     g_pHyprError->draw();
                 }
 
                 // for drawing the debug overlay
-                if (pMonitor == g_pCompositor->m_vMonitors.front().get() && *PDEBUGOVERLAY == 1) {
+                if (pMonitor == g_pCompositor->m_vMonitors.front() && *PDEBUGOVERLAY == 1) {
                     renderStartOverlay = std::chrono::high_resolution_clock::now();
                     g_pDebugOverlay->draw();
                     endRenderOverlay = std::chrono::high_resolution_clock::now();
@@ -1491,7 +1491,7 @@ void CHyprRenderer::renderMonitor(CMonitor* pMonitor) {
     g_pDebugOverlay->renderData(pMonitor, durationUs);
 
     if (*PDEBUGOVERLAY == 1) {
-        if (pMonitor == g_pCompositor->m_vMonitors.front().get()) {
+        if (pMonitor == g_pCompositor->m_vMonitors.front()) {
             const float noOverlayUs = durationUs - std::chrono::duration_cast<std::chrono::nanoseconds>(endRenderOverlay - renderStartOverlay).count() / 1000.f;
             g_pDebugOverlay->renderDataNoOverlay(pMonitor, noOverlayUs);
         } else {
@@ -1500,7 +1500,7 @@ void CHyprRenderer::renderMonitor(CMonitor* pMonitor) {
     }
 }
 
-bool CHyprRenderer::commitPendingAndDoExplicitSync(CMonitor* pMonitor) {
+bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
     // apply timelines for explicit sync
     // save inFD otherwise reset will reset it
     auto inFD = pMonitor->output->state->state().explicitInFence;
@@ -1565,7 +1565,7 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(CMonitor* pMonitor) {
     return ok;
 }
 
-void CHyprRenderer::renderWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const CBox& geometry) {
+void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const CBox& geometry) {
     Vector2D translate = {geometry.x, geometry.y};
     float    scale     = (float)geometry.width / pMonitor->vecPixelSize.x;
 
@@ -1582,7 +1582,7 @@ void CHyprRenderer::renderWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace,
     g_pHyprOpenGL->m_RenderData.pWorkspace = nullptr;
 }
 
-void CHyprRenderer::sendFrameEventsToWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* now) {
+void CHyprRenderer::sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now) {
     for (auto const& w : g_pCompositor->m_vWindows) {
         if (w->isHidden() || !w->m_bIsMapped || w->m_bFadingOut || !w->m_pWLSurface->resource())
             continue;
@@ -1670,7 +1670,7 @@ static void applyExclusive(CBox& usableArea, uint32_t anchor, int32_t exclusive,
     }
 }
 
-void CHyprRenderer::arrangeLayerArray(CMonitor* pMonitor, const std::vector<PHLLSREF>& layerSurfaces, bool exclusiveZone, CBox* usableArea) {
+void CHyprRenderer::arrangeLayerArray(PHLMONITOR pMonitor, const std::vector<PHLLSREF>& layerSurfaces, bool exclusiveZone, CBox* usableArea) {
     CBox full_area = {pMonitor->vecPosition.x, pMonitor->vecPosition.y, pMonitor->vecSize.x, pMonitor->vecSize.y};
 
     for (auto const& ls : layerSurfaces) {
@@ -1865,7 +1865,7 @@ void CHyprRenderer::damageWindow(PHLWINDOW pWindow, bool forceFull) {
     windowBox.translate(pWindow->m_vFloatingOffset);
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        if (forceFull || g_pHyprRenderer->shouldRenderWindow(pWindow, m.get())) { // only damage if window is rendered on monitor
+        if (forceFull || g_pHyprRenderer->shouldRenderWindow(pWindow, m)) { // only damage if window is rendered on monitor
             CBox fixedDamageBox = {windowBox.x - m->vecPosition.x, windowBox.y - m->vecPosition.y, windowBox.width, windowBox.height};
             fixedDamageBox.scale(m->scale);
             m->addDamage(&fixedDamageBox);
@@ -1881,7 +1881,7 @@ void CHyprRenderer::damageWindow(PHLWINDOW pWindow, bool forceFull) {
         Debug::log(LOG, "Damage: Window ({}): xy: {}, {} wh: {}, {}", pWindow->m_szTitle, windowBox.x, windowBox.y, windowBox.width, windowBox.height);
 }
 
-void CHyprRenderer::damageMonitor(CMonitor* pMonitor) {
+void CHyprRenderer::damageMonitor(PHLMONITOR pMonitor) {
     if (g_pCompositor->m_bUnsafeState || pMonitor->isMirror())
         return;
 
@@ -1925,7 +1925,7 @@ void CHyprRenderer::damageRegion(const CRegion& rg) {
     }
 }
 
-void CHyprRenderer::damageMirrorsWith(CMonitor* pMonitor, const CRegion& pRegion) {
+void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegion) {
     for (auto const& mirror : pMonitor->mirrors) {
 
         // transform the damage here, so it won't get clipped by the monitor damage ring
@@ -1946,11 +1946,11 @@ void CHyprRenderer::damageMirrorsWith(CMonitor* pMonitor, const CRegion& pRegion
 
         mirror->addDamage(&transformed);
 
-        g_pCompositor->scheduleFrameForMonitor(mirror, Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+        g_pCompositor->scheduleFrameForMonitor(mirror.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
     }
 }
 
-void CHyprRenderer::renderDragIcon(CMonitor* pMonitor, timespec* time) {
+void CHyprRenderer::renderDragIcon(PHLMONITOR pMonitor, timespec* time) {
     PROTO::data->renderDND(pMonitor, time);
 }
 
@@ -1965,7 +1965,7 @@ DAMAGETRACKINGMODES CHyprRenderer::damageTrackingModeFromStr(const std::string&
     return DAMAGE_TRACKING_INVALID;
 }
 
-bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorRule, bool force) {
+bool CHyprRenderer::applyMonitorRule(PHLMONITOR pMonitor, SMonitorRule* pMonitorRule, bool force) {
 
     static auto PDISABLESCALECHECKS = CConfigValue<Hyprlang::INT>("debug:disable_scale_checks");
 
@@ -2436,7 +2436,7 @@ void CHyprRenderer::ensureCursorRenderingMode() {
             if (!g_pPointerManager->softwareLockedFor(m))
                 continue;
 
-            g_pHyprRenderer->damageMonitor(m.get()); // TODO: maybe just damage the cursor area?
+            g_pHyprRenderer->damageMonitor(m); // TODO: maybe just damage the cursor area?
         }
 
         setCursorHidden(true);
@@ -2448,7 +2448,7 @@ void CHyprRenderer::ensureCursorRenderingMode() {
             if (!g_pPointerManager->softwareLockedFor(m))
                 continue;
 
-            g_pHyprRenderer->damageMonitor(m.get()); // TODO: maybe just damage the cursor area?
+            g_pHyprRenderer->damageMonitor(m); // TODO: maybe just damage the cursor area?
         }
 
         setCursorHidden(false);
@@ -2479,7 +2479,7 @@ bool CHyprRenderer::shouldRenderCursor() {
     return !m_bCursorHidden && m_bCursorHasSurface;
 }
 
-std::tuple<float, float, float> CHyprRenderer::getRenderTimes(CMonitor* pMonitor) {
+std::tuple<float, float, float> CHyprRenderer::getRenderTimes(PHLMONITOR pMonitor) {
     const auto POVERLAY = &g_pDebugOverlay->m_mMonitorOverlays[pMonitor];
 
     float      avgRenderTime = 0;
@@ -2590,7 +2590,7 @@ void CHyprRenderer::setOccludedForBackLayers(CRegion& region, PHLWORKSPACE pWork
     region.subtract(rg);
 }
 
-bool CHyprRenderer::canSkipBackBufferClear(CMonitor* pMonitor) {
+bool CHyprRenderer::canSkipBackBufferClear(PHLMONITOR pMonitor) {
     for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
         if (!ls->layerSurface)
             continue;
@@ -2616,7 +2616,7 @@ bool CHyprRenderer::canSkipBackBufferClear(CMonitor* pMonitor) {
     return false;
 }
 
-void CHyprRenderer::recheckSolitaryForMonitor(CMonitor* pMonitor) {
+void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
     pMonitor->solitaryClient.reset(); // reset it, if we find one it will be set.
 
     if (g_pHyprNotificationOverlay->hasAny() || g_pSessionLockManager->isSessionLocked())
@@ -2704,7 +2704,7 @@ void CHyprRenderer::unsetEGL() {
     eglMakeCurrent(g_pHyprOpenGL->m_pEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
-bool CHyprRenderer::beginRender(CMonitor* pMonitor, CRegion& damage, eRenderMode mode, SP<IHLBuffer> buffer, CFramebuffer* fb, bool simple) {
+bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMode mode, SP<IHLBuffer> buffer, CFramebuffer* fb, bool simple) {
 
     makeEGLCurrent();
 
@@ -2777,7 +2777,7 @@ void CHyprRenderer::endRender() {
     if (m_eRenderMode != RENDER_MODE_TO_BUFFER_READ_ONLY)
         g_pHyprOpenGL->end();
     else {
-        g_pHyprOpenGL->m_RenderData.pMonitor          = nullptr;
+        g_pHyprOpenGL->m_RenderData.pMonitor.reset();
         g_pHyprOpenGL->m_RenderData.mouseZoomFactor   = 1.f;
         g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = true;
     }
diff --git a/src/render/Renderer.hpp b/src/render/Renderer.hpp
index 7d1ae4b1..41f40b5a 100644
--- a/src/render/Renderer.hpp
+++ b/src/render/Renderer.hpp
@@ -49,29 +49,29 @@ class CHyprRenderer {
     CHyprRenderer();
     ~CHyprRenderer();
 
-    void renderMonitor(CMonitor* pMonitor);
+    void renderMonitor(PHLMONITOR pMonitor);
     void arrangeLayersForMonitor(const MONITORID&);
     void damageSurface(SP<CWLSurfaceResource>, double, double, double scale = 1.0);
     void damageWindow(PHLWINDOW, bool forceFull = false);
     void damageBox(CBox*, bool skipFrameSchedule = false);
     void damageBox(const int& x, const int& y, const int& w, const int& h);
     void damageRegion(const CRegion&);
-    void damageMonitor(CMonitor*);
-    void damageMirrorsWith(CMonitor*, const CRegion&);
-    bool applyMonitorRule(CMonitor*, SMonitorRule*, bool force = false);
-    bool shouldRenderWindow(PHLWINDOW, CMonitor*);
+    void damageMonitor(PHLMONITOR);
+    void damageMirrorsWith(PHLMONITOR, const CRegion&);
+    bool applyMonitorRule(PHLMONITOR, SMonitorRule*, bool force = false);
+    bool shouldRenderWindow(PHLWINDOW, PHLMONITOR);
     bool shouldRenderWindow(PHLWINDOW);
     void ensureCursorRenderingMode();
     bool shouldRenderCursor();
     void setCursorHidden(bool hide);
     void calculateUVForSurface(PHLWINDOW, SP<CWLSurfaceResource>, SP<CMonitor> pMonitor, bool main = false, const Vector2D& projSize = {}, const Vector2D& projSizeUnscaled = {},
                                bool fixMisalignedFSV1 = false);
-    std::tuple<float, float, float> getRenderTimes(CMonitor* pMonitor); // avg max min
-    void                            renderLockscreen(CMonitor* pMonitor, timespec* now, const CBox& geometry);
+    std::tuple<float, float, float> getRenderTimes(PHLMONITOR pMonitor); // avg max min
+    void                            renderLockscreen(PHLMONITOR pMonitor, timespec* now, const CBox& geometry);
     void                            setOccludedForBackLayers(CRegion& region, PHLWORKSPACE pWorkspace);
     void                            setOccludedForMainWorkspace(CRegion& region, PHLWORKSPACE pWorkspace); // TODO: merge occlusion methods
-    bool                            canSkipBackBufferClear(CMonitor* pMonitor);
-    void                            recheckSolitaryForMonitor(CMonitor* pMonitor);
+    bool                            canSkipBackBufferClear(PHLMONITOR pMonitor);
+    void                            recheckSolitaryForMonitor(PHLMONITOR pMonitor);
     void                            setCursorSurface(SP<CWLSurface> surf, int hotspotX, int hotspotY, bool force = false);
     void                            setCursorFromName(const std::string& name, bool force = false);
     void                            onRenderbufferDestroy(CRenderbuffer* rb);
@@ -84,13 +84,13 @@ class CHyprRenderer {
 
     // if RENDER_MODE_NORMAL, provided damage will be written to.
     // otherwise, it will be the one used.
-    bool      beginRender(CMonitor* pMonitor, CRegion& damage, eRenderMode mode = RENDER_MODE_NORMAL, SP<IHLBuffer> buffer = {}, CFramebuffer* fb = nullptr, bool simple = false);
-    void      endRender();
+    bool beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMode mode = RENDER_MODE_NORMAL, SP<IHLBuffer> buffer = {}, CFramebuffer* fb = nullptr, bool simple = false);
+    void endRender();
 
-    bool      m_bBlockSurfaceFeedback = false;
-    bool      m_bRenderingSnapshot    = false;
-    CMonitor* m_pMostHzMonitor        = nullptr;
-    bool      m_bDirectScanoutBlocked = false;
+    bool m_bBlockSurfaceFeedback = false;
+    bool m_bRenderingSnapshot    = false;
+    PHLMONITORREF m_pMostHzMonitor;
+    bool          m_bDirectScanoutBlocked = false;
 
     DAMAGETRACKINGMODES
     damageTrackingModeFromStr(const std::string&);
@@ -115,20 +115,20 @@ class CHyprRenderer {
     } m_sLastCursorData;
 
   private:
-    void              arrangeLayerArray(CMonitor*, const std::vector<PHLLSREF>&, bool, CBox*);
-    void              renderWorkspaceWindowsFullscreen(CMonitor*, PHLWORKSPACE, timespec*); // renders workspace windows (fullscreen) (tiled, floating, pinned, but no special)
-    void              renderWorkspaceWindows(CMonitor*, PHLWORKSPACE, timespec*);           // renders workspace windows (no fullscreen) (tiled, floating, pinned, but no special)
-    void              renderWindow(PHLWINDOW, CMonitor*, timespec*, bool, eRenderPassMode, bool ignorePosition = false, bool ignoreAllGeometry = false);
-    void              renderLayer(PHLLS, CMonitor*, timespec*, bool popups = false);
-    void              renderSessionLockSurface(SSessionLockSurface*, CMonitor*, timespec*);
-    void              renderDragIcon(CMonitor*, timespec*);
-    void              renderIMEPopup(CInputPopup*, CMonitor*, timespec*);
-    void              renderWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const CBox& geometry);
-    void              sendFrameEventsToWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* now); // sends frame displayed events but doesn't actually render anything
-    void              renderAllClientsForWorkspace(CMonitor* pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const Vector2D& translate = {0, 0}, const float& scale = 1.f);
-    void              renderSessionLockMissing(CMonitor* pMonitor);
+    void              arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*);
+    void              renderWorkspaceWindowsFullscreen(PHLMONITOR, PHLWORKSPACE, timespec*); // renders workspace windows (fullscreen) (tiled, floating, pinned, but no special)
+    void              renderWorkspaceWindows(PHLMONITOR, PHLWORKSPACE, timespec*);           // renders workspace windows (no fullscreen) (tiled, floating, pinned, but no special)
+    void              renderWindow(PHLWINDOW, PHLMONITOR, timespec*, bool, eRenderPassMode, bool ignorePosition = false, bool ignoreAllGeometry = false);
+    void              renderLayer(PHLLS, PHLMONITOR, timespec*, bool popups = false);
+    void              renderSessionLockSurface(SSessionLockSurface*, PHLMONITOR, timespec*);
+    void              renderDragIcon(PHLMONITOR, timespec*);
+    void              renderIMEPopup(CInputPopup*, PHLMONITOR, timespec*);
+    void              renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const CBox& geometry);
+    void              sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now); // sends frame displayed events but doesn't actually render anything
+    void              renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const Vector2D& translate = {0, 0}, const float& scale = 1.f);
+    void              renderSessionLockMissing(PHLMONITOR pMonitor);
 
-    bool              commitPendingAndDoExplicitSync(CMonitor* pMonitor);
+    bool              commitPendingAndDoExplicitSync(PHLMONITOR pMonitor);
 
     bool              m_bCursorHidden        = false;
     bool              m_bCursorHasSurface    = false;
diff --git a/src/render/decorations/CHyprBorderDecoration.cpp b/src/render/decorations/CHyprBorderDecoration.cpp
index 1eaaa0af..68325a9c 100644
--- a/src/render/decorations/CHyprBorderDecoration.cpp
+++ b/src/render/decorations/CHyprBorderDecoration.cpp
@@ -46,7 +46,7 @@ CBox CHyprBorderDecoration::assignedBoxGlobal() {
     return box.translate(WORKSPACEOFFSET);
 }
 
-void CHyprBorderDecoration::draw(CMonitor* pMonitor, float a) {
+void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float a) {
     if (doesntWantBorders())
         return;
 
@@ -119,7 +119,7 @@ void CHyprBorderDecoration::damageEntire() {
     borderRegion.subtract(surfaceBoxShrunkRounding);
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        if (!g_pHyprRenderer->shouldRenderWindow(m_pWindow.lock(), m.get())) {
+        if (!g_pHyprRenderer->shouldRenderWindow(m_pWindow.lock(), m)) {
             const CRegion monitorRegion({m->vecPosition, m->vecSize});
             borderRegion.subtract(monitorRegion);
         }
diff --git a/src/render/decorations/CHyprBorderDecoration.hpp b/src/render/decorations/CHyprBorderDecoration.hpp
index 0e196565..5d248a81 100644
--- a/src/render/decorations/CHyprBorderDecoration.hpp
+++ b/src/render/decorations/CHyprBorderDecoration.hpp
@@ -11,7 +11,7 @@ class CHyprBorderDecoration : public IHyprWindowDecoration {
 
     virtual void                       onPositioningReply(const SDecorationPositioningReply& reply);
 
-    virtual void                       draw(CMonitor*, float a);
+    virtual void                       draw(PHLMONITOR, float a);
 
     virtual eDecorationType            getDecorationType();
 
diff --git a/src/render/decorations/CHyprDropShadowDecoration.cpp b/src/render/decorations/CHyprDropShadowDecoration.cpp
index 628a579a..a4388a67 100644
--- a/src/render/decorations/CHyprDropShadowDecoration.cpp
+++ b/src/render/decorations/CHyprDropShadowDecoration.cpp
@@ -67,7 +67,7 @@ void CHyprDropShadowDecoration::damageEntire() {
     }
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        if (!g_pHyprRenderer->shouldRenderWindow(PWINDOW, m.get())) {
+        if (!g_pHyprRenderer->shouldRenderWindow(PWINDOW, m)) {
             const CRegion monitorRegion({m->vecPosition, m->vecSize});
             shadowRegion.subtract(monitorRegion);
         }
@@ -86,7 +86,7 @@ void CHyprDropShadowDecoration::updateWindow(PHLWINDOW pWindow) {
     m_bLastWindowBoxWithDecos = g_pDecorationPositioner->getBoxWithIncludedDecos(pWindow);
 }
 
-void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a) {
+void CHyprDropShadowDecoration::draw(PHLMONITOR pMonitor, float a) {
 
     const auto PWINDOW = m_pWindow.lock();
 
diff --git a/src/render/decorations/CHyprDropShadowDecoration.hpp b/src/render/decorations/CHyprDropShadowDecoration.hpp
index ecd5a47b..fce9a7c7 100644
--- a/src/render/decorations/CHyprDropShadowDecoration.hpp
+++ b/src/render/decorations/CHyprDropShadowDecoration.hpp
@@ -11,7 +11,7 @@ class CHyprDropShadowDecoration : public IHyprWindowDecoration {
 
     virtual void                       onPositioningReply(const SDecorationPositioningReply& reply);
 
-    virtual void                       draw(CMonitor*, float a);
+    virtual void                       draw(PHLMONITOR, float a);
 
     virtual eDecorationType            getDecorationType();
 
diff --git a/src/render/decorations/CHyprGroupBarDecoration.cpp b/src/render/decorations/CHyprGroupBarDecoration.cpp
index 74a1e2e9..4219a5a8 100644
--- a/src/render/decorations/CHyprGroupBarDecoration.cpp
+++ b/src/render/decorations/CHyprGroupBarDecoration.cpp
@@ -94,7 +94,7 @@ void CHyprGroupBarDecoration::damageEntire() {
     g_pHyprRenderer->damageBox(&box);
 }
 
-void CHyprGroupBarDecoration::draw(CMonitor* pMonitor, float a) {
+void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float a) {
     // get how many bars we will draw
     int         barsToDraw = m_dwGroupMembers.size();
 
diff --git a/src/render/decorations/CHyprGroupBarDecoration.hpp b/src/render/decorations/CHyprGroupBarDecoration.hpp
index bfb15d5c..e388fa38 100644
--- a/src/render/decorations/CHyprGroupBarDecoration.hpp
+++ b/src/render/decorations/CHyprGroupBarDecoration.hpp
@@ -31,7 +31,7 @@ class CHyprGroupBarDecoration : public IHyprWindowDecoration {
 
     virtual void                       onPositioningReply(const SDecorationPositioningReply& reply);
 
-    virtual void                       draw(CMonitor*, float a);
+    virtual void                       draw(PHLMONITOR, float a);
 
     virtual eDecorationType            getDecorationType();
 
diff --git a/src/render/decorations/IHyprWindowDecoration.hpp b/src/render/decorations/IHyprWindowDecoration.hpp
index a58560f3..99698a56 100644
--- a/src/render/decorations/IHyprWindowDecoration.hpp
+++ b/src/render/decorations/IHyprWindowDecoration.hpp
@@ -39,7 +39,7 @@ class IHyprWindowDecoration {
 
     virtual void                       onPositioningReply(const SDecorationPositioningReply& reply) = 0;
 
-    virtual void                       draw(CMonitor*, float a) = 0;
+    virtual void                       draw(PHLMONITOR, float a) = 0;
 
     virtual eDecorationType            getDecorationType() = 0;