helpers: refactor class member vars (#10218)

63 files changed, 1781 insertions, 1780 deletions

diff --git a/src/Compositor.cpp b/src/Compositor.cpp
index 212e514b..154ec135 100644
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -476,7 +476,7 @@ void CCompositor::initAllSignals() {
 
                     for (auto const& m : m_monitors) {
                         scheduleFrameForMonitor(m);
-                        m->applyMonitorRule(&m->activeMonitorRule, true);
+                        m->applyMonitorRule(&m->m_activeMonitorRule, true);
                     }
 
                     g_pConfigManager->m_wantsMonitorReload = true;
@@ -558,8 +558,8 @@ void CCompositor::cleanup() {
     for (auto const& m : m_monitors) {
         g_pHyprOpenGL->destroyMonitorResources(m);
 
-        m->output->state->setEnabled(false);
-        m->state.commit();
+        m->m_output->state->setEnabled(false);
+        m->m_state.commit();
     }
 
     g_pXWayland.reset();
@@ -783,7 +783,7 @@ void CCompositor::startCompositor() {
 
 PHLMONITOR CCompositor::getMonitorFromID(const MONITORID& id) {
     for (auto const& m : m_monitors) {
-        if (m->ID == id) {
+        if (m->m_id == id) {
             return m;
         }
     }
@@ -793,7 +793,7 @@ PHLMONITOR CCompositor::getMonitorFromID(const MONITORID& id) {
 
 PHLMONITOR CCompositor::getMonitorFromName(const std::string& name) {
     for (auto const& m : m_monitors) {
-        if (m->szName == name) {
+        if (m->m_name == name) {
             return m;
         }
     }
@@ -802,7 +802,7 @@ PHLMONITOR CCompositor::getMonitorFromName(const std::string& name) {
 
 PHLMONITOR CCompositor::getMonitorFromDesc(const std::string& desc) {
     for (auto const& m : m_monitors) {
-        if (m->szDescription.starts_with(desc))
+        if (m->m_description.starts_with(desc))
             return m;
     }
     return nullptr;
@@ -820,7 +820,7 @@ PHLMONITOR CCompositor::getMonitorFromVector(const Vector2D& point) {
 
     PHLMONITOR mon;
     for (auto const& m : m_monitors) {
-        if (CBox{m->vecPosition, m->vecSize}.containsPoint(point)) {
+        if (CBox{m->m_position, m->m_size}.containsPoint(point)) {
             mon = m;
             break;
         }
@@ -831,7 +831,7 @@ PHLMONITOR CCompositor::getMonitorFromVector(const Vector2D& point) {
         PHLMONITOR pBestMon;
 
         for (auto const& m : m_monitors) {
-            float dist = vecToRectDistanceSquared(point, m->vecPosition, m->vecPosition + m->vecSize);
+            float dist = vecToRectDistanceSquared(point, m->m_position, m->m_position + m->m_size);
 
             if (dist < bestDistance || !pBestMon) {
                 bestDistance = dist;
@@ -901,11 +901,10 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
                 const auto PWINDOWMONITOR = w->m_monitor.lock();
 
                 // to avoid focusing windows behind special workspaces from other monitors
-                if (!*PSPECIALFALLTHRU && PWINDOWMONITOR && PWINDOWMONITOR->activeSpecialWorkspace && w->m_workspace != PWINDOWMONITOR->activeSpecialWorkspace) {
+                if (!*PSPECIALFALLTHRU && PWINDOWMONITOR && PWINDOWMONITOR->m_activeSpecialWorkspace && w->m_workspace != PWINDOWMONITOR->m_activeSpecialWorkspace) {
                     const auto BB = w->getWindowBoxUnified(properties);
-                    if (BB.x >= PWINDOWMONITOR->vecPosition.x && BB.y >= PWINDOWMONITOR->vecPosition.y &&
-                        BB.x + BB.width <= PWINDOWMONITOR->vecPosition.x + PWINDOWMONITOR->vecSize.x &&
-                        BB.y + BB.height <= PWINDOWMONITOR->vecPosition.y + PWINDOWMONITOR->vecSize.y)
+                    if (BB.x >= PWINDOWMONITOR->m_position.x && BB.y >= PWINDOWMONITOR->m_position.y &&
+                        BB.x + BB.width <= PWINDOWMONITOR->m_position.x + PWINDOWMONITOR->m_size.x && BB.y + BB.height <= PWINDOWMONITOR->m_position.y + PWINDOWMONITOR->m_size.y)
                         continue;
                 }
 
@@ -992,10 +991,10 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
     };
 
     // special workspace
-    if (PMONITOR->activeSpecialWorkspace && !*PSPECIALFALLTHRU)
+    if (PMONITOR->m_activeSpecialWorkspace && !*PSPECIALFALLTHRU)
         return windowForWorkspace(true);
 
-    if (PMONITOR->activeSpecialWorkspace) {
+    if (PMONITOR->m_activeSpecialWorkspace) {
         const auto PWINDOW = windowForWorkspace(true);
 
         if (PWINDOW)
@@ -1061,7 +1060,7 @@ Vector2D CCompositor::vectorToSurfaceLocal(const Vector2D& vec, PHLWINDOW pWindo
 
 PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
     for (auto const& m : m_monitors) {
-        if (m->output == out) {
+        if (m->m_output == out) {
             return m;
         }
     }
@@ -1071,7 +1070,7 @@ PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
 
 PHLMONITOR CCompositor::getRealMonitorFromOutput(SP<Aquamarine::IOutput> out) {
     for (auto const& m : m_realMonitors) {
-        if (m->output == out) {
+        if (m->m_output == out) {
             return m;
         }
     }
@@ -1137,7 +1136,7 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
         return;
 
     if (pWindow->m_pinned)
-        pWindow->m_workspace = m_lastMonitor->activeWorkspace;
+        pWindow->m_workspace = m_lastMonitor->m_activeWorkspace;
 
     const auto PMONITOR = pWindow->m_monitor.lock();
 
@@ -1145,8 +1144,8 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
         const auto PWORKSPACE = pWindow->m_workspace;
         // This is to fix incorrect feedback on the focus history.
         PWORKSPACE->m_lastFocusedWindow = pWindow;
-        if (m_lastMonitor->activeWorkspace)
-            PWORKSPACE->rememberPrevWorkspace(m_lastMonitor->activeWorkspace);
+        if (m_lastMonitor->m_activeWorkspace)
+            PWORKSPACE->rememberPrevWorkspace(m_lastMonitor->m_activeWorkspace);
         if (PWORKSPACE->m_isSpecialWorkspace)
             m_lastMonitor->changeWorkspace(PWORKSPACE, false, true); // if special ws, open on current monitor
         else if (PMONITOR)
@@ -1160,7 +1159,7 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
 
     /* If special fallthrough is enabled, this behavior will be disabled, as I have no better idea of nicely tracking which
        window focuses are "via keybinds" and which ones aren't. */
-    if (PMONITOR && PMONITOR->activeSpecialWorkspace && PMONITOR->activeSpecialWorkspace != pWindow->m_workspace && !pWindow->m_pinned && !*PSPECIALFALLTHROUGH)
+    if (PMONITOR && PMONITOR->m_activeSpecialWorkspace && PMONITOR->m_activeSpecialWorkspace != pWindow->m_workspace && !pWindow->m_pinned && !*PSPECIALFALLTHROUGH)
         PMONITOR->setSpecialWorkspace(nullptr);
 
     // we need to make the PLASTWINDOW not equal to m_pLastWindow so that RENDERDATA is correct for an unfocused window
@@ -1267,7 +1266,7 @@ void CCompositor::focusSurface(SP<CWLSurfaceResource> pSurface, PHLWINDOW pWindo
 }
 
 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& lsl : monitor->m_layerSurfaceLayers | std::views::reverse) {
         for (auto const& ls : lsl | std::views::reverse) {
             if (!ls->m_mapped || ls->m_fadingOut || !ls->m_layerSurface || (ls->m_layerSurface && !ls->m_layerSurface->mapped) || ls->m_alpha->value() == 0.f)
                 continue;
@@ -1474,7 +1473,7 @@ void CCompositor::cleanupFadingOut(const MONITORID& monid) {
 
         if (ls->m_fadingOut && ls->m_readyToDelete && ls->isFadedOut()) {
             for (auto const& m : m_monitors) {
-                for (auto& lsl : m->m_aLayerSurfaceLayers) {
+                for (auto& lsl : m->m_layerSurfaceLayers) {
                     if (!lsl.empty() && std::ranges::find_if(lsl, [&](auto& other) { return other == ls; }) != lsl.end()) {
                         std::erase_if(lsl, [&](auto& other) { return other == ls || !other; });
                     }
@@ -1528,7 +1527,7 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
     if (!PMONITOR)
         return nullptr; // ??
 
-    const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{PMONITOR->vecPosition, PMONITOR->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
+    const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{PMONITOR->m_position, PMONITOR->m_size} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
     const auto PWORKSPACE    = pWindow->m_workspace;
 
     return getWindowInDirection(WINDOWIDEALBB, PWORKSPACE, dir, pWindow, pWindow->m_isFloating);
@@ -1754,14 +1753,14 @@ PHLWORKSPACE CCompositor::getWorkspaceByString(const std::string& str) {
 
 bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
     return std::ranges::any_of(
-        m_monitors, [&](const PHLMONITOR& m) { return VECINRECT(point, m->vecPosition.x, m->vecPosition.y, m->vecSize.x + m->vecPosition.x, m->vecSize.y + m->vecPosition.y); });
+        m_monitors, [&](const PHLMONITOR& m) { return VECINRECT(point, m->m_position.x, m->m_position.y, m->m_size.x + m->m_position.x, m->m_size.y + m->m_position.y); });
 }
 
 bool CCompositor::isPointOnReservedArea(const Vector2D& point, const PHLMONITOR pMonitor) {
     const auto PMONITOR = pMonitor ? pMonitor : getMonitorFromVector(point);
 
-    const auto XY1 = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
-    const auto XY2 = PMONITOR->vecPosition + PMONITOR->vecSize - PMONITOR->vecReservedBottomRight;
+    const auto XY1 = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
+    const auto XY2 = PMONITOR->m_position + PMONITOR->m_size - PMONITOR->m_reservedBottomRight;
 
     return VECNOTINRECT(point, XY1.x, XY1.y, XY2.x, XY2.y);
 }
@@ -1774,8 +1773,8 @@ PHLMONITOR CCompositor::getMonitorInDirection(PHLMONITOR pSourceMonitor, const c
     if (!pSourceMonitor)
         return nullptr;
 
-    const auto POSA  = pSourceMonitor->vecPosition;
-    const auto SIZEA = pSourceMonitor->vecSize;
+    const auto POSA  = pSourceMonitor->m_position;
+    const auto SIZEA = pSourceMonitor->m_size;
 
     auto       longestIntersect        = -1;
     PHLMONITOR longestIntersectMonitor = nullptr;
@@ -1784,8 +1783,8 @@ PHLMONITOR CCompositor::getMonitorInDirection(PHLMONITOR pSourceMonitor, const c
         if (m == pSourceMonitor)
             continue;
 
-        const auto POSB  = m->vecPosition;
-        const auto SIZEB = m->vecSize;
+        const auto POSB  = m->m_position;
+        const auto SIZEB = m->m_size;
         switch (dir) {
             case 'l':
                 if (STICKS(POSA.x, POSB.x + SIZEB.x)) {
@@ -1937,13 +1936,13 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {
 
 MONITORID CCompositor::getNextAvailableMonitorID(std::string const& name) {
     // reuse ID if it's already in the map, and the monitor with that ID is not being used by another monitor
-    if (m_monitorIDMap.contains(name) && !std::ranges::any_of(m_realMonitors, [&](auto m) { return m->ID == m_monitorIDMap[name]; }))
+    if (m_monitorIDMap.contains(name) && !std::ranges::any_of(m_realMonitors, [&](auto m) { return m->m_id == m_monitorIDMap[name]; }))
         return m_monitorIDMap[name];
 
     // otherwise, find minimum available ID that is not in the map
     std::unordered_set<MONITORID> usedIDs;
     for (auto const& monitor : m_realMonitors) {
-        usedIDs.insert(monitor->ID);
+        usedIDs.insert(monitor->m_id);
     }
 
     MONITORID nextID = 0;
@@ -1955,11 +1954,11 @@ MONITORID CCompositor::getNextAvailableMonitorID(std::string const& name) {
 }
 
 void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitorB) {
-    const auto PWORKSPACEA = pMonitorA->activeWorkspace;
-    const auto PWORKSPACEB = pMonitorB->activeWorkspace;
+    const auto PWORKSPACEA = pMonitorA->m_activeWorkspace;
+    const auto PWORKSPACEB = pMonitorB->m_activeWorkspace;
 
     PWORKSPACEA->m_monitor = pMonitorB;
-    PWORKSPACEA->moveToMonitor(pMonitorB->ID);
+    PWORKSPACEA->moveToMonitor(pMonitorB->m_id);
 
     for (auto const& w : m_windows) {
         if (w->m_workspace == PWORKSPACEA) {
@@ -1972,11 +1971,11 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
 
             // additionally, move floating and fs windows manually
             if (w->m_isFloating)
-                *w->m_realPosition = w->m_realPosition->goal() - pMonitorA->vecPosition + pMonitorB->vecPosition;
+                *w->m_realPosition = w->m_realPosition->goal() - pMonitorA->m_position + pMonitorB->m_position;
 
             if (w->isFullscreen()) {
-                *w->m_realPosition = pMonitorB->vecPosition;
-                *w->m_realSize     = pMonitorB->vecSize;
+                *w->m_realPosition = pMonitorB->m_position;
+                *w->m_realSize     = pMonitorB->m_size;
             }
 
             w->updateToplevel();
@@ -1984,7 +1983,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
     }
 
     PWORKSPACEB->m_monitor = pMonitorA;
-    PWORKSPACEB->moveToMonitor(pMonitorA->ID);
+    PWORKSPACEB->moveToMonitor(pMonitorA->m_id);
 
     for (auto const& w : m_windows) {
         if (w->m_workspace == PWORKSPACEB) {
@@ -1997,46 +1996,46 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
 
             // additionally, move floating and fs windows manually
             if (w->m_isFloating)
-                *w->m_realPosition = w->m_realPosition->goal() - pMonitorB->vecPosition + pMonitorA->vecPosition;
+                *w->m_realPosition = w->m_realPosition->goal() - pMonitorB->m_position + pMonitorA->m_position;
 
             if (w->isFullscreen()) {
-                *w->m_realPosition = pMonitorA->vecPosition;
-                *w->m_realSize     = pMonitorA->vecSize;
+                *w->m_realPosition = pMonitorA->m_position;
+                *w->m_realSize     = pMonitorA->m_size;
             }
 
             w->updateToplevel();
         }
     }
 
-    pMonitorA->activeWorkspace = PWORKSPACEB;
-    pMonitorB->activeWorkspace = PWORKSPACEA;
+    pMonitorA->m_activeWorkspace = PWORKSPACEB;
+    pMonitorB->m_activeWorkspace = PWORKSPACEA;
 
     PWORKSPACEA->rememberPrevWorkspace(PWORKSPACEB);
     PWORKSPACEB->rememberPrevWorkspace(PWORKSPACEA);
 
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorA->ID);
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorB->ID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorA->m_id);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorB->m_id);
 
     updateFullscreenFadeOnWorkspace(PWORKSPACEB);
     updateFullscreenFadeOnWorkspace(PWORKSPACEA);
 
-    if (pMonitorA->ID == g_pCompositor->m_lastMonitor->ID || pMonitorB->ID == g_pCompositor->m_lastMonitor->ID) {
-        const auto LASTWIN = pMonitorA->ID == g_pCompositor->m_lastMonitor->ID ? PWORKSPACEB->getLastFocusedWindow() : PWORKSPACEA->getLastFocusedWindow();
+    if (pMonitorA->m_id == g_pCompositor->m_lastMonitor->m_id || pMonitorB->m_id == g_pCompositor->m_lastMonitor->m_id) {
+        const auto LASTWIN = pMonitorA->m_id == g_pCompositor->m_lastMonitor->m_id ? PWORKSPACEB->getLastFocusedWindow() : PWORKSPACEA->getLastFocusedWindow();
         g_pCompositor->focusWindow(LASTWIN ? LASTWIN :
                                              (g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING)));
 
-        const auto PNEWWORKSPACE = pMonitorA->ID == g_pCompositor->m_lastMonitor->ID ? PWORKSPACEB : PWORKSPACEA;
+        const auto PNEWWORKSPACE = pMonitorA->m_id == g_pCompositor->m_lastMonitor->m_id ? PWORKSPACEB : PWORKSPACEA;
         g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspace", .data = PNEWWORKSPACE->m_name});
         g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspacev2", .data = std::format("{},{}", PNEWWORKSPACE->m_id, PNEWWORKSPACE->m_name)});
         EMIT_HOOK_EVENT("workspace", PNEWWORKSPACE);
     }
 
     // event
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEA->m_name + "," + pMonitorB->szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEA->m_id, PWORKSPACEA->m_name, pMonitorB->szName)});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEA->m_name + "," + pMonitorB->m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEA->m_id, PWORKSPACEA->m_name, pMonitorB->m_name)});
     EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEA, pMonitorB}));
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEB->m_name + "," + pMonitorA->szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEB->m_id, PWORKSPACEB->m_name, pMonitorA->szName)});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEB->m_name + "," + pMonitorA->m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEB->m_id, PWORKSPACEB->m_name, pMonitorA->m_name)});
 
     EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEB, pMonitorA}));
 }
@@ -2103,7 +2102,7 @@ PHLMONITOR CCompositor::getMonitorFromString(const std::string& name) {
         }
     } else {
         for (auto const& m : m_monitors) {
-            if (!m->output)
+            if (!m->m_output)
                 continue;
 
             if (m->matchesStaticSelector(name)) {
@@ -2124,11 +2123,11 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
     if (pWorkspace->m_monitor == pMonitor)
         return;
 
-    Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_id, pMonitor->ID);
+    Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_id, pMonitor->m_id);
 
     const auto POLDMON = pWorkspace->m_monitor.lock();
 
-    const bool SWITCHINGISACTIVE = POLDMON ? POLDMON->activeWorkspace == pWorkspace : false;
+    const bool SWITCHINGISACTIVE = POLDMON ? POLDMON->m_activeWorkspace == pWorkspace : false;
 
     // fix old mon
     WORKSPACEID nextWorkspaceOnMonitorID = WORKSPACE_INVALID;
@@ -2154,7 +2153,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
             Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new {}", nextWorkspaceOnMonitorID);
 
             if (POLDMON)
-                g_pCompositor->createNewWorkspace(nextWorkspaceOnMonitorID, POLDMON->ID);
+                g_pCompositor->createNewWorkspace(nextWorkspaceOnMonitorID, POLDMON->m_id);
         }
 
         Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with existing {}", nextWorkspaceOnMonitorID);
@@ -2164,7 +2163,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
 
     // move the workspace
     pWorkspace->m_monitor = pMonitor;
-    pWorkspace->moveToMonitor(pMonitor->ID);
+    pWorkspace->moveToMonitor(pMonitor->m_id);
 
     for (auto const& w : m_windows) {
         if (w->m_workspace == pWorkspace) {
@@ -2179,16 +2178,16 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
             if (w->m_isMapped && !w->isHidden()) {
                 if (POLDMON) {
                     if (w->m_isFloating)
-                        *w->m_realPosition = w->m_realPosition->goal() - POLDMON->vecPosition + pMonitor->vecPosition;
+                        *w->m_realPosition = w->m_realPosition->goal() - POLDMON->m_position + pMonitor->m_position;
 
                     if (w->isFullscreen()) {
-                        *w->m_realPosition = pMonitor->vecPosition;
-                        *w->m_realSize     = pMonitor->vecSize;
+                        *w->m_realPosition = pMonitor->m_position;
+                        *w->m_realSize     = pMonitor->m_size;
                     }
                 } else
                     *w->m_realPosition = Vector2D{
-                        (pMonitor->vecSize.x != 0) ? (int)w->m_realPosition->goal().x % (int)pMonitor->vecSize.x : 0,
-                        (pMonitor->vecSize.y != 0) ? (int)w->m_realPosition->goal().y % (int)pMonitor->vecSize.y : 0,
+                        (pMonitor->m_size.x != 0) ? (int)w->m_realPosition->goal().x % (int)pMonitor->m_size.x : 0,
+                        (pMonitor->m_size.y != 0) ? (int)w->m_realPosition->goal().y % (int)pMonitor->m_size.y : 0,
                     };
             }
 
@@ -2199,32 +2198,32 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
     if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_lastMonitor) { // if it was active, preserve its' status. If it wasn't, don't.
         Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_id);
 
-        if (valid(pMonitor->activeWorkspace)) {
-            pMonitor->activeWorkspace->m_visible = false;
-            pMonitor->activeWorkspace->startAnim(false, false);
+        if (valid(pMonitor->m_activeWorkspace)) {
+            pMonitor->m_activeWorkspace->m_visible = false;
+            pMonitor->m_activeWorkspace->startAnim(false, false);
         }
 
         if (*PHIDESPECIALONWORKSPACECHANGE)
             pMonitor->setSpecialWorkspace(nullptr);
 
         setActiveMonitor(pMonitor);
-        pMonitor->activeWorkspace = pWorkspace;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->ID);
+        pMonitor->m_activeWorkspace = pWorkspace;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->m_id);
 
         pWorkspace->startAnim(true, true, true);
         pWorkspace->m_visible = true;
 
         if (!noWarpCursor)
-            g_pPointerManager->warpTo(pMonitor->vecPosition + pMonitor->vecTransformedSize / 2.F);
+            g_pPointerManager->warpTo(pMonitor->m_position + pMonitor->m_transformedSize / 2.F);
 
         g_pInputManager->sendMotionEventsToFocused();
     }
 
     // finalize
     if (POLDMON) {
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->ID);
-        if (valid(POLDMON->activeWorkspace))
-            updateFullscreenFadeOnWorkspace(POLDMON->activeWorkspace);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->m_id);
+        if (valid(POLDMON->m_activeWorkspace))
+            updateFullscreenFadeOnWorkspace(POLDMON->m_activeWorkspace);
         updateSuspendedStates();
     }
 
@@ -2232,8 +2231,8 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
     updateSuspendedStates();
 
     // event
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = pWorkspace->m_name + "," + pMonitor->szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", pWorkspace->m_id, pWorkspace->m_name, pMonitor->szName)});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = pWorkspace->m_name + "," + pMonitor->m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", pWorkspace->m_id, pWorkspace->m_name, pMonitor->m_name)});
     EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{pWorkspace, pMonitor}));
 }
 
@@ -2274,7 +2273,7 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) {
     const auto PMONITOR = pWorkspace->m_monitor.lock();
 
     if (pWorkspace->m_id == PMONITOR->activeWorkspaceID() || pWorkspace->m_id == PMONITOR->activeSpecialWorkspaceID()) {
-        for (auto const& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+        for (auto const& ls : PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
             if (!ls->m_fadingOut)
                 *ls->m_alpha = FULLSCREEN && pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
         }
@@ -2382,7 +2381,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, SFullscreenS
     // send a scanout tranche if we are entering fullscreen, and send a regular one if we aren't.
     // ignore if DS is disabled.
     if (*PDIRECTSCANOUT == 1 || (*PDIRECTSCANOUT == 2 && PWINDOW->getContentType() == CONTENT_TYPE_GAME))
-        g_pHyprRenderer->setSurfaceScanoutMode(PWINDOW->m_wlSurface->resource(), EFFECTIVE_MODE != FSMODE_NONE ? PMONITOR->self.lock() : nullptr);
+        g_pHyprRenderer->setSurfaceScanoutMode(PWINDOW->m_wlSurface->resource(), EFFECTIVE_MODE != FSMODE_NONE ? PMONITOR->m_self.lock() : nullptr);
 
     g_pConfigManager->ensureVRR(PMONITOR);
 }
@@ -2406,13 +2405,13 @@ void CCompositor::scheduleFrameForMonitor(PHLMONITOR pMonitor, IOutput::schedule
     if ((m_aqBackend->hasSession() && !m_aqBackend->session->active) || !m_sessionActive)
         return;
 
-    if (!pMonitor->m_bEnabled)
+    if (!pMonitor->m_enabled)
         return;
 
-    if (pMonitor->renderingActive)
-        pMonitor->pendingFrame = true;
+    if (pMonitor->m_renderingActive)
+        pMonitor->m_pendingFrame = true;
 
-    pMonitor->output->scheduleFrame(reason);
+    pMonitor->m_output->scheduleFrame(reason);
 }
 
 PHLWINDOW CCompositor::getWindowByRegex(const std::string& regexp_) {
@@ -2617,8 +2616,8 @@ Vector2D CCompositor::parseWindowVectorArgsRelative(const std::string& args, con
     int Y = 0;
 
     if (isExact) {
-        X = xIsPercent ? std::stof(x) * 0.01 * PMONITOR->vecSize.x : std::stoi(x);
-        Y = yIsPercent ? std::stof(y) * 0.01 * PMONITOR->vecSize.y : std::stoi(y);
+        X = xIsPercent ? std::stof(x) * 0.01 * PMONITOR->m_size.x : std::stoi(x);
+        Y = yIsPercent ? std::stof(y) * 0.01 * PMONITOR->m_size.y : std::stoi(y);
     } else {
         X = xIsPercent ? (std::stof(x) * 0.01 * relativeTo.x) + relativeTo.x : std::stoi(x) + relativeTo.x;
         Y = yIsPercent ? (std::stof(y) * 0.01 * relativeTo.y) + relativeTo.y : std::stoi(y) + relativeTo.y;
@@ -2633,7 +2632,7 @@ PHLWORKSPACE CCompositor::createNewWorkspace(const WORKSPACEID& id, const MONITO
 
     // check if bound
     if (const auto PMONITOR = g_pConfigManager->getBoundMonitorForWS(NAME); PMONITOR)
-        monID = PMONITOR->ID;
+        monID = PMONITOR->m_id;
 
     const bool SPECIAL = id >= SPECIAL_WORKSPACE_START && id <= -2;
 
@@ -2659,16 +2658,16 @@ void CCompositor::setActiveMonitor(PHLMONITOR pMonitor) {
         return;
     }
 
-    const auto PWORKSPACE = pMonitor->activeWorkspace;
+    const auto PWORKSPACE = pMonitor->m_activeWorkspace;
 
     const auto WORKSPACE_ID   = PWORKSPACE ? std::to_string(PWORKSPACE->m_id) : std::to_string(WORKSPACE_INVALID);
     const auto WORKSPACE_NAME = PWORKSPACE ? PWORKSPACE->m_name : "?";
 
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmon", .data = pMonitor->szName + "," + WORKSPACE_NAME});
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmonv2", .data = pMonitor->szName + "," + WORKSPACE_ID});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmon", .data = pMonitor->m_name + "," + WORKSPACE_NAME});
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmonv2", .data = pMonitor->m_name + "," + WORKSPACE_ID});
 
     EMIT_HOOK_EVENT("focusedMon", pMonitor);
-    m_lastMonitor = pMonitor->self;
+    m_lastMonitor = pMonitor->m_self;
 }
 
 bool CCompositor::isWorkspaceSpecial(const WORKSPACEID& id) {
@@ -2733,7 +2732,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
 
     const PHLWINDOW pFirstWindowOnWorkspace   = pWorkspace->getFirstWindow();
     const int       visibleWindowsOnWorkspace = pWorkspace->getWindows(std::nullopt, true);
-    const auto      POSTOMON                  = pWindow->m_realPosition->goal() - (pWindow->m_monitor ? pWindow->m_monitor->vecPosition : Vector2D{});
+    const auto      POSTOMON                  = pWindow->m_realPosition->goal() - (pWindow->m_monitor ? pWindow->m_monitor->m_position : Vector2D{});
     const auto      PWORKSPACEMONITOR         = pWorkspace->m_monitor.lock();
 
     if (!pWindow->m_isFloating)
@@ -2770,7 +2769,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
             g_pLayoutManager->getCurrentLayout()->onWindowCreatedTiling(pWindow);
 
         if (pWindow->m_isFloating)
-            *pWindow->m_realPosition = POSTOMON + PWORKSPACEMONITOR->vecPosition;
+            *pWindow->m_realPosition = POSTOMON + PWORKSPACEMONITOR->m_position;
     }
 
     pWindow->updateToplevel();
@@ -2826,11 +2825,11 @@ void CCompositor::arrangeMonitors() {
     for (auto it = toArrange.begin(); it != toArrange.end();) {
         auto m = *it;
 
-        if (m->activeMonitorRule.offset != Vector2D{-INT32_MAX, -INT32_MAX}) {
+        if (m->m_activeMonitorRule.offset != Vector2D{-INT32_MAX, -INT32_MAX}) {
             // explicit.
-            Debug::log(LOG, "arrangeMonitors: {} explicit {:j}", m->szName, m->activeMonitorRule.offset);
+            Debug::log(LOG, "arrangeMonitors: {} explicit {:j}", m->m_name, m->m_activeMonitorRule.offset);
 
-            m->moveTo(m->activeMonitorRule.offset);
+            m->moveTo(m->m_activeMonitorRule.offset);
             arranged.push_back(m);
             it = toArrange.erase(it);
 
@@ -2857,10 +2856,10 @@ void CCompositor::arrangeMonitors() {
 
         // Finds the max and min values of explicitely placed monitors.
         for (auto const& m : arranged) {
-            maxXOffsetRight = std::max<double>(m->vecPosition.x + m->vecSize.x, maxXOffsetRight);
-            maxXOffsetLeft  = std::min<double>(m->vecPosition.x, maxXOffsetLeft);
-            maxYOffsetDown  = std::max<double>(m->vecPosition.y + m->vecSize.y, maxYOffsetDown);
-            maxYOffsetUp    = std::min<double>(m->vecPosition.y, maxYOffsetUp);
+            maxXOffsetRight = std::max<double>(m->m_position.x + m->m_size.x, maxXOffsetRight);
+            maxXOffsetLeft  = std::min<double>(m->m_position.x, maxXOffsetLeft);
+            maxYOffsetDown  = std::max<double>(m->m_position.y + m->m_size.y, maxYOffsetDown);
+            maxYOffsetUp    = std::min<double>(m->m_position.y, maxYOffsetUp);
         }
     };
 
@@ -2871,15 +2870,15 @@ void CCompositor::arrangeMonitors() {
         // Moves the monitor to their appropriate position on the x/y axis and
         // increments/decrements the corresponding max offset.
         Vector2D newPosition = {0, 0};
-        switch (m->activeMonitorRule.autoDir) {
-            case eAutoDirs::DIR_AUTO_UP: newPosition.y = maxYOffsetUp - m->vecSize.y; break;
+        switch (m->m_activeMonitorRule.autoDir) {
+            case eAutoDirs::DIR_AUTO_UP: newPosition.y = maxYOffsetUp - m->m_size.y; break;
             case eAutoDirs::DIR_AUTO_DOWN: newPosition.y = maxYOffsetDown; break;
-            case eAutoDirs::DIR_AUTO_LEFT: newPosition.x = maxXOffsetLeft - m->vecSize.x; break;
+            case eAutoDirs::DIR_AUTO_LEFT: newPosition.x = maxXOffsetLeft - m->m_size.x; break;
             case eAutoDirs::DIR_AUTO_RIGHT:
             case eAutoDirs::DIR_AUTO_NONE: newPosition.x = maxXOffsetRight; break;
             default: UNREACHABLE();
         }
-        Debug::log(LOG, "arrangeMonitors: {} auto {:j}", m->szName, m->vecPosition);
+        Debug::log(LOG, "arrangeMonitors: {} auto {:j}", m->m_name, m->m_position);
         m->moveTo(newPosition);
         arranged.emplace_back(m);
     }
@@ -2888,14 +2887,14 @@ void CCompositor::arrangeMonitors() {
     // and set xwayland positions aka auto for all
     maxXOffsetRight = 0;
     for (auto const& m : m_monitors) {
-        Debug::log(LOG, "arrangeMonitors: {} xwayland [{}, {}]", m->szName, maxXOffsetRight, 0);
-        m->vecXWaylandPosition = {maxXOffsetRight, 0};
-        maxXOffsetRight += (*PXWLFORCESCALEZERO ? m->vecTransformedSize.x : m->vecSize.x);
+        Debug::log(LOG, "arrangeMonitors: {} xwayland [{}, {}]", m->m_name, maxXOffsetRight, 0);
+        m->m_xwaylandPosition = {maxXOffsetRight, 0};
+        maxXOffsetRight += (*PXWLFORCESCALEZERO ? m->m_transformedSize.x : m->m_size.x);
 
         if (*PXWLFORCESCALEZERO)
-            m->xwaylandScale = m->scale;
+            m->m_xwaylandScale = m->m_scale;
         else
-            m->xwaylandScale = 1.f;
+            m->m_xwaylandScale = 1.f;
     }
 
     PROTO::xdgOutput->updateAllOutputs();
@@ -2907,7 +2906,7 @@ void CCompositor::enterUnsafeState() {
 
     Debug::log(LOG, "Entering unsafe state");
 
-    if (!m_unsafeOutput->m_bEnabled)
+    if (!m_unsafeOutput->m_enabled)
         m_unsafeOutput->onConnect(false);
 
     m_unsafeState = true;
@@ -2925,7 +2924,7 @@ void CCompositor::leaveUnsafeState() {
 
     PHLMONITOR pNewMonitor = nullptr;
     for (auto const& pMonitor : m_monitors) {
-        if (pMonitor->output != m_unsafeOutput->output) {
+        if (pMonitor->m_output != m_unsafeOutput->m_output) {
             pNewMonitor = pMonitor;
             break;
         }
@@ -2933,7 +2932,7 @@ void CCompositor::leaveUnsafeState() {
 
     RASSERT(pNewMonitor, "Tried to leave unsafe without a monitor");
 
-    if (m_unsafeOutput->m_bEnabled)
+    if (m_unsafeOutput->m_enabled)
         m_unsafeOutput->onDisconnect();
 
     for (auto const& m : m_monitors) {
@@ -2993,7 +2992,7 @@ static void checkDefaultCursorWarp(PHLMONITOR monitor) {
     }
 
     if (!cursorDefaultDone && *PCURSORMONITOR != STRVAL_EMPTY) {
-        if (*PCURSORMONITOR == monitor->szName) {
+        if (*PCURSORMONITOR == monitor->m_name) {
             cursorDefaultDone = true;
             g_pCompositor->warpCursorTo(POS, true);
             g_pInputManager->refocus();
@@ -3018,23 +3017,23 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
 
     Debug::log(LOG, "New output with name {}", output->name);
 
-    PNEWMONITOR->szName           = output->name;
-    PNEWMONITOR->self             = PNEWMONITOR;
-    const bool FALLBACK           = g_pCompositor->m_unsafeOutput ? output == g_pCompositor->m_unsafeOutput->output : false;
-    PNEWMONITOR->ID               = FALLBACK ? MONITOR_INVALID : g_pCompositor->getNextAvailableMonitorID(output->name);
-    PNEWMONITOR->isUnsafeFallback = FALLBACK;
+    PNEWMONITOR->m_name             = output->name;
+    PNEWMONITOR->m_self             = PNEWMONITOR;
+    const bool FALLBACK             = g_pCompositor->m_unsafeOutput ? output == g_pCompositor->m_unsafeOutput->m_output : false;
+    PNEWMONITOR->m_id               = FALLBACK ? MONITOR_INVALID : g_pCompositor->getNextAvailableMonitorID(output->name);
+    PNEWMONITOR->m_isUnsafeFallback = FALLBACK;
 
     EMIT_HOOK_EVENT("newMonitor", PNEWMONITOR);
 
     if (!FALLBACK)
         PNEWMONITOR->onConnect(false);
 
-    if (!PNEWMONITOR->m_bEnabled || FALLBACK)
+    if (!PNEWMONITOR->m_enabled || FALLBACK)
         return;
 
     // ready to process if we have a real monitor
 
-    if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->refreshRate > g_pHyprRenderer->m_pMostHzMonitor->refreshRate) && PNEWMONITOR->m_bEnabled)
+    if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->m_refreshRate > g_pHyprRenderer->m_pMostHzMonitor->m_refreshRate) && PNEWMONITOR->m_enabled)
         g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR;
 
     g_pCompositor->m_readyToProcess = true;
@@ -3112,7 +3111,7 @@ void CCompositor::ensurePersistentWorkspacesPresent(const std::vector<SWorkspace
             }
             PWORKSPACE = getWorkspaceByID(id);
             if (!PWORKSPACE)
-                createNewWorkspace(id, PMONITOR ? PMONITOR->ID : m_lastMonitor->ID, wsname, false);
+                createNewWorkspace(id, PMONITOR ? PMONITOR->m_id : m_lastMonitor->m_id, wsname, false);
         }
 
         if (PWORKSPACE)
@@ -3125,12 +3124,12 @@ void CCompositor::ensurePersistentWorkspacesPresent(const std::vector<SWorkspace
 
         if (PWORKSPACE) {
             if (PWORKSPACE->m_monitor == PMONITOR) {
-                Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} already on {}", rule.workspaceString, PMONITOR->szName);
+                Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} already on {}", rule.workspaceString, PMONITOR->m_name);
 
                 continue;
             }
 
-            Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} not on {}, moving", rule.workspaceString, PMONITOR->szName);
+            Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} not on {}, moving", rule.workspaceString, PMONITOR->m_name);
             moveWorkspaceToMonitor(PWORKSPACE, PMONITOR);
             continue;
         }
diff --git a/src/config/ConfigManager.cpp b/src/config/ConfigManager.cpp
index 3c0f2cf8..f84b868f 100644
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
@@ -1016,7 +1016,7 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
     }
 
     for (auto const& m : g_pCompositor->m_monitors)
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
 
     // Update the keyboard layout to the cfg'd one if this is not the first launch
     if (!m_isFirstLaunch) {
@@ -1113,11 +1113,11 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
         g_pCompositor->scheduleFrameForMonitor(m);
 
         // Force the compositor to fully re-render all monitors
-        m->forceFullFrames = 2;
+        m->m_forceFullFrames = 2;
 
         // also force mirrors, as the aspect ratio could've changed
-        for (auto const& mirror : m->mirrors)
-            mirror->forceFullFrames = 3;
+        for (auto const& mirror : m->m_mirrors)
+            mirror->m_forceFullFrames = 3;
     }
 
     // Reset no monitor reload
@@ -1157,7 +1157,7 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
     // invalidate layouts if they changed
     if (COMMAND == "monitor" || COMMAND.contains("gaps_") || COMMAND.starts_with("dwindle:") || COMMAND.starts_with("master:")) {
         for (auto const& m : g_pCompositor->m_monitors)
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
     }
 
     if (COMMAND.contains("explicit")) {
@@ -1225,7 +1225,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
         if (!CONFIG)
             return rule;
 
-        Debug::log(LOG, "CConfigManager::getMonitorRuleFor: found a wlr_output_manager override for {}", PMONITOR->szName);
+        Debug::log(LOG, "CConfigManager::getMonitorRuleFor: found a wlr_output_manager override for {}", PMONITOR->m_name);
 
         Debug::log(LOG, " > overriding enabled: {} -> {}", !rule.disabled, !CONFIG->enabled);
         rule.disabled = !CONFIG->enabled;
@@ -1266,7 +1266,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
         }
     }
 
-    Debug::log(WARN, "No rule found for {}, trying to use the first.", PMONITOR->szName);
+    Debug::log(WARN, "No rule found for {}, trying to use the first.", PMONITOR->m_name);
 
     for (auto const& r : m_monitorRules) {
         if (r.name.empty()) {
@@ -1605,7 +1605,7 @@ void CConfigManager::performMonitorReload() {
     bool overAgain = false;
 
     for (auto const& m : g_pCompositor->m_realMonitors) {
-        if (!m->output || m->isUnsafeFallback)
+        if (!m->m_output || m->m_isUnsafeFallback)
             continue;
 
         auto rule = getMonitorRuleFor(m);
@@ -1618,7 +1618,7 @@ void CConfigManager::performMonitorReload() {
         // ensure mirror
         m->setMirror(rule.mirrorOf);
 
-        g_pHyprRenderer->arrangeLayersForMonitor(m->ID);
+        g_pHyprRenderer->arrangeLayersForMonitor(m->m_id);
     }
 
     if (overAgain)
@@ -1662,12 +1662,12 @@ bool CConfigManager::shouldBlurLS(const std::string& ns) {
 
 void CConfigManager::ensureMonitorStatus() {
     for (auto const& rm : g_pCompositor->m_realMonitors) {
-        if (!rm->output || rm->isUnsafeFallback)
+        if (!rm->m_output || rm->m_isUnsafeFallback)
             continue;
 
         auto rule = getMonitorRuleFor(rm);
 
-        if (rule.disabled == rm->m_bEnabled)
+        if (rule.disabled == rm->m_enabled)
             rm->applyMonitorRule(&rule);
     }
 }
@@ -1676,38 +1676,38 @@ void CConfigManager::ensureVRR(PHLMONITOR pMonitor) {
     static auto PVRR = reinterpret_cast<Hyprlang::INT* const*>(getConfigValuePtr("misc:vrr"));
 
     static auto ensureVRRForDisplay = [&](PHLMONITOR m) -> void {
-        if (!m->output || m->createdByUser)
+        if (!m->m_output || m->m_createdByUser)
             return;
 
-        const auto USEVRR = m->activeMonitorRule.vrr.has_value() ? m->activeMonitorRule.vrr.value() : **PVRR;
+        const auto USEVRR = m->m_activeMonitorRule.vrr.has_value() ? m->m_activeMonitorRule.vrr.value() : **PVRR;
 
         if (USEVRR == 0) {
-            if (m->vrrActive) {
-                m->output->state->resetExplicitFences();
-                m->output->state->setAdaptiveSync(false);
+            if (m->m_vrrActive) {
+                m->m_output->state->resetExplicitFences();
+                m->m_output->state->setAdaptiveSync(false);
 
-                if (!m->state.commit())
-                    Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> false", m->output->name);
+                if (!m->m_state.commit())
+                    Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> false", m->m_output->name);
             }
-            m->vrrActive = false;
+            m->m_vrrActive = false;
             return;
         } else if (USEVRR == 1) {
-            if (!m->vrrActive) {
-                m->output->state->resetExplicitFences();
-                m->output->state->setAdaptiveSync(true);
+            if (!m->m_vrrActive) {
+                m->m_output->state->resetExplicitFences();
+                m->m_output->state->setAdaptiveSync(true);
 
-                if (!m->state.test()) {
-                    Debug::log(LOG, "Pending output {} does not accept VRR.", m->output->name);
-                    m->output->state->setAdaptiveSync(false);
+                if (!m->m_state.test()) {
+                    Debug::log(LOG, "Pending output {} does not accept VRR.", m->m_output->name);
+                    m->m_output->state->setAdaptiveSync(false);
                 }
 
-                if (!m->state.commit())
-                    Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> true", m->output->name);
+                if (!m->m_state.commit())
+                    Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> true", m->m_output->name);
             }
-            m->vrrActive = true;
+            m->m_vrrActive = true;
             return;
         } else if (USEVRR == 2 || USEVRR == 3) {
-            const auto PWORKSPACE = m->activeWorkspace;
+            const auto PWORKSPACE = m->m_activeWorkspace;
 
             if (!PWORKSPACE)
                 return; // ???
@@ -1720,20 +1720,20 @@ void CConfigManager::ensureVRR(PHLMONITOR pMonitor) {
 
             if (wantVRR) {
                 /* fullscreen */
-                m->vrrActive = true;
+                m->m_vrrActive = true;
 
-                if (!m->output->state->state().adaptiveSync) {
-                    m->output->state->setAdaptiveSync(true);
+                if (!m->m_output->state->state().adaptiveSync) {
+                    m->m_output->state->setAdaptiveSync(true);
 
-                    if (!m->state.test()) {
-                        Debug::log(LOG, "Pending output {} does not accept VRR.", m->output->name);
-                        m->output->state->setAdaptiveSync(false);
+                    if (!m->m_state.test()) {
+                        Debug::log(LOG, "Pending output {} does not accept VRR.", m->m_output->name);
+                        m->m_output->state->setAdaptiveSync(false);
                     }
                 }
             } else {
-                m->vrrActive = false;
+                m->m_vrrActive = false;
 
-                m->output->state->setAdaptiveSync(false);
+                m->m_output->state->setAdaptiveSync(false);
             }
         }
     };
@@ -1840,7 +1840,7 @@ std::string CConfigManager::getDefaultWorkspaceFor(const std::string& name) {
                 return other->workspaceString;
             if (other->monitor.starts_with("desc:")) {
                 auto const monitor = g_pCompositor->getMonitorFromDesc(trim(other->monitor.substr(5)));
-                if (monitor && monitor->szName == name)
+                if (monitor && monitor->m_name == name)
                     return other->workspaceString;
             }
         }
@@ -2630,7 +2630,7 @@ std::optional<std::string> CConfigManager::handleLayerRule(const std::string& co
     m_layerRules.emplace_back(rule);
 
     for (auto const& m : g_pCompositor->m_monitors)
-        for (auto const& lsl : m->m_aLayerSurfaceLayers)
+        for (auto const& lsl : m->m_layerSurfaceLayers)
             for (auto const& ls : lsl)
                 ls->applyRules();
 
@@ -2645,7 +2645,7 @@ void CConfigManager::updateBlurredLS(const std::string& name, const bool forceBl
         matchName = matchName.substr(8);
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        for (auto const& lsl : m->m_aLayerSurfaceLayers) {
+        for (auto const& lsl : m->m_layerSurfaceLayers) {
             for (auto const& ls : lsl) {
                 if (BYADDRESS) {
                     if (std::format("0x{:x}", (uintptr_t)ls.get()) == matchName)
@@ -2925,7 +2925,7 @@ bool CConfigManager::shouldUseSoftwareCursors(PHLMONITOR pMonitor) {
     switch (*PNOHW) {
         case 0: return false;
         case 1: return true;
-        case 2: return pMonitor->tearingState.activelyTearing;
+        case 2: return pMonitor->m_tearingState.activelyTearing;
         default: break;
     }
 
diff --git a/src/debug/HyprCtl.cpp b/src/debug/HyprCtl.cpp
index 3e6a3f08..2ad182ab 100644
--- a/src/debug/HyprCtl.cpp
+++ b/src/debug/HyprCtl.cpp
@@ -97,7 +97,7 @@ static std::string formatToString(uint32_t drmFormat) {
 static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFormat format) {
     std::string result;
 
-    for (auto const& m : pMonitor->output->modes) {
+    for (auto const& m : pMonitor->m_output->modes) {
         if (format == FORMAT_NORMAL)
             result += std::format("{}x{}@{:.2f}Hz ", m->pixelSize.x, m->pixelSize.y, m->refreshRate / 1000.0);
         else
@@ -111,7 +111,7 @@ static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFo
 
 std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor> m, eHyprCtlOutputFormat format) {
     std::string result;
-    if (!m->output || m->ID == -1)
+    if (!m->m_output || m->m_id == -1)
         return "";
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -152,27 +152,28 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
     "availableModes": [{}]
 }},)#",
 
-            m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), escapeJSONStrings(m->output->make), escapeJSONStrings(m->output->model),
-            escapeJSONStrings(m->output->serial), (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
-            m->activeWorkspaceID(), (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_name)), m->activeSpecialWorkspaceID(),
-            escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_name : ""), (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_lastMonitor ? "true" : "false"),
-            (m->dpmsStatus ? "true" : "false"), (m->output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->solitaryClient.get(),
-            (m->tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->lastScanout.get(), (m->m_bEnabled ? "false" : "true"),
-            formatToString(m->output->state->state().drmFormat), m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));
+            m->m_id, escapeJSONStrings(m->m_name), escapeJSONStrings(m->m_shortDescription), escapeJSONStrings(m->m_output->make), escapeJSONStrings(m->m_output->model),
+            escapeJSONStrings(m->m_output->serial), (int)m->m_pixelSize.x, (int)m->m_pixelSize.y, m->m_refreshRate, (int)m->m_position.x, (int)m->m_position.y,
+            m->activeWorkspaceID(), (!m->m_activeWorkspace ? "" : escapeJSONStrings(m->m_activeWorkspace->m_name)), m->activeSpecialWorkspaceID(),
+            escapeJSONStrings(m->m_activeSpecialWorkspace ? m->m_activeSpecialWorkspace->m_name : ""), (int)m->m_reservedTopLeft.x, (int)m->m_reservedTopLeft.y,
+            (int)m->m_reservedBottomRight.x, (int)m->m_reservedBottomRight.y, m->m_scale, (int)m->m_transform, (m == g_pCompositor->m_lastMonitor ? "true" : "false"),
+            (m->m_dpmsStatus ? "true" : "false"), (m->m_output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->m_solitaryClient.get(),
+            (m->m_tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->m_lastScanout.get(), (m->m_enabled ? "false" : "true"),
+            formatToString(m->m_output->state->state().drmFormat), m->m_mirrorOf ? std::format("{}", m->m_mirrorOf->m_id) : "none", 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"
-                              "special workspace: {} ({})\n\treserved: {} {} {} {}\n\tscale: {:.2f}\n\ttransform: {}\n\tfocused: {}\n\t"
-                              "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: "
-                              "{}\n\tavailableModes: {}\n\n",
-                              m->szName, m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->szShortDescription,
-                              m->output->make, m->output->model, m->output->serial, m->activeWorkspaceID(), (!m->activeWorkspace ? "" : m->activeWorkspace->m_name),
-                              m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_name : ""), (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_lastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(),
-                              m->tearingState.activelyTearing, (uint64_t)m->lastScanout.get(), !m->m_bEnabled, formatToString(m->output->state->state().drmFormat),
-                              m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));
+        result +=
+            std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t"
+                        "special workspace: {} ({})\n\treserved: {} {} {} {}\n\tscale: {:.2f}\n\ttransform: {}\n\tfocused: {}\n\t"
+                        "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: "
+                        "{}\n\tavailableModes: {}\n\n",
+                        m->m_name, m->m_id, (int)m->m_pixelSize.x, (int)m->m_pixelSize.y, m->m_refreshRate, (int)m->m_position.x, (int)m->m_position.y, m->m_shortDescription,
+                        m->m_output->make, m->m_output->model, m->m_output->serial, m->activeWorkspaceID(), (!m->m_activeWorkspace ? "" : m->m_activeWorkspace->m_name),
+                        m->activeSpecialWorkspaceID(), (m->m_activeSpecialWorkspace ? m->m_activeSpecialWorkspace->m_name : ""), (int)m->m_reservedTopLeft.x,
+                        (int)m->m_reservedTopLeft.y, (int)m->m_reservedBottomRight.x, (int)m->m_reservedBottomRight.y, m->m_scale, (int)m->m_transform,
+                        (m == g_pCompositor->m_lastMonitor ? "yes" : "no"), (int)m->m_dpmsStatus, m->m_output->state->state().adaptiveSync, (uint64_t)m->m_solitaryClient.get(),
+                        m->m_tearingState.activelyTearing, (uint64_t)m->m_lastScanout.get(), !m->m_enabled, formatToString(m->m_output->state->state().drmFormat),
+                        m->m_mirrorOf ? std::format("{}", m->m_mirrorOf->m_id) : "none", availableModesForOutput(m, format));
     }
 
     return result;
@@ -201,7 +202,7 @@ static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string requ
         result += "]";
     } else {
         for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) {
-            if (!m->output || m->ID == -1)
+            if (!m->m_output || m->m_id == -1)
                 continue;
 
             result += CHyprCtl::getMonitorData(m, format);
@@ -349,13 +350,13 @@ std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat form
     "lastwindowtitle": "{}",
     "ispersistent": {}
 }})#",
-                           w->m_id, escapeJSONStrings(w->m_name), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"),
-                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_hasFullscreenWindow ? "true" : "false",
+                           w->m_id, escapeJSONStrings(w->m_name), escapeJSONStrings(PMONITOR ? PMONITOR->m_name : "?"),
+                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->m_id) : "null"), w->getWindows(), w->m_hasFullscreenWindow ? "true" : "false",
                            (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_title) : "", w->m_persistent ? "true" : "false");
     } else {
         return std::format(
             "workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\tispersistent: {}\n\n",
-            w->m_id, w->m_name, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_hasFullscreenWindow,
+            w->m_id, w->m_name, PMONITOR ? PMONITOR->m_name : "?", PMONITOR ? std::to_string(PMONITOR->m_id) : "null", w->getWindows(), (int)w->m_hasFullscreenWindow,
             (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_title : "", (int)w->m_persistent);
     }
 }
@@ -415,7 +416,7 @@ static std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::stri
         return "unsafe state";
 
     std::string result = "";
-    auto        w      = g_pCompositor->m_lastMonitor->activeWorkspace;
+    auto        w      = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
     if (!valid(w))
         return "internal error";
@@ -489,10 +490,10 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
                 R"#("{}": {{
     "levels": {{
 )#",
-                escapeJSONStrings(mon->szName));
+                escapeJSONStrings(mon->m_name));
 
             int layerLevel = 0;
-            for (auto const& level : mon->m_aLayerSurfaceLayers) {
+            for (auto const& level : mon->m_layerSurfaceLayers) {
                 result += std::format(
                     R"#(
         "{}": [
@@ -534,10 +535,10 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
 
     } else {
         for (auto const& mon : g_pCompositor->m_monitors) {
-            result += std::format("Monitor {}:\n", mon->szName);
+            result += std::format("Monitor {}:\n", mon->m_name);
             int                                     layerLevel = 0;
             static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"};
-            for (auto const& level : mon->m_aLayerSurfaceLayers) {
+            for (auto const& level : mon->m_layerSurfaceLayers) {
                 result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]);
 
                 for (auto const& layer : level) {
@@ -1143,7 +1144,7 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
         COMMAND.starts_with("windowrule")) {
         for (auto const& m : g_pCompositor->m_monitors) {
             g_pHyprRenderer->damageMonitor(m);
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
         }
     }
 
@@ -1449,7 +1450,7 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
 
     if (!vars[3].empty()) {
         for (auto const& m : g_pCompositor->m_realMonitors) {
-            if (m->szName == vars[3])
+            if (m->m_name == vars[3])
                 return "Name already taken";
         }
     }
@@ -1483,10 +1484,10 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
         if (!PMONITOR)
             return "output not found";
 
-        if (!PMONITOR->createdByUser)
+        if (!PMONITOR->m_createdByUser)
             return "cannot remove a real display. Use the monitor keyword.";
 
-        PMONITOR->output->destroy();
+        PMONITOR->m_output->destroy();
     }
 
     return "ok";
@@ -1836,7 +1837,7 @@ std::string CHyprCtl::getReply(std::string request) {
 
         for (auto const& m : g_pCompositor->m_monitors) {
             g_pHyprRenderer->damageMonitor(m);
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
         }
     }
 
diff --git a/src/debug/HyprDebugOverlay.cpp b/src/debug/HyprDebugOverlay.cpp
index d055ec90..874252d0 100644
--- a/src/debug/HyprDebugOverlay.cpp
+++ b/src/debug/HyprDebugOverlay.cpp
@@ -18,7 +18,7 @@ void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs)
 
     m_lastRenderTimes.emplace_back(durationUs / 1000.f);
 
-    if (m_lastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
+    if (m_lastRenderTimes.size() > (long unsigned int)pMonitor->m_refreshRate)
         m_lastRenderTimes.pop_front();
 
     if (!m_monitor)
@@ -33,7 +33,7 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float du
 
     m_lastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
 
-    if (m_lastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
+    if (m_lastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->m_refreshRate)
         m_lastRenderTimesNoOverlay.pop_front();
 
     if (!m_monitor)
@@ -48,7 +48,7 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
 
     m_lastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_lastFrame).count() / 1000.f);
 
-    if (m_lastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
+    if (m_lastFrametimes.size() > (long unsigned int)pMonitor->m_refreshRate)
         m_lastFrametimes.pop_front();
 
     m_lastFrame = std::chrono::high_resolution_clock::now();
@@ -59,7 +59,7 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
     // anim data too
     const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock();
     if (PMONITORFORTICKS) {
-        if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
+        if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate)
             m_lastAnimationTicks.pop_front();
 
         m_lastAnimationTicks.push_back(g_pAnimationManager->m_fLastTickTime);
@@ -166,7 +166,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f);
 
     std::string text;
-    showText(m_monitor->szName.c_str(), 10);
+    showText(m_monitor->m_name.c_str(), 10);
 
     if (FPS > idealFPS * 0.95f)
         cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 0.2f, 1.f, 0.2f, 1.f);
@@ -199,7 +199,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     cairo_get_current_point(cr, &posX, &posY);
 
     g_pHyprRenderer->damageBox(m_lastDrawnBox);
-    m_lastDrawnBox = {(int)g_pCompositor->m_monitors.front()->vecPosition.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_monitors.front()->vecPosition.y + offset + MARGIN_TOP - 1,
+    m_lastDrawnBox = {(int)g_pCompositor->m_monitors.front()->m_position.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_monitors.front()->m_position.y + offset + MARGIN_TOP - 1,
                       (int)maxTextW + 2, posY - offset - MARGIN_TOP + 2};
     g_pHyprRenderer->damageBox(m_lastDrawnBox);
 
@@ -238,7 +238,7 @@ void CHyprDebugOverlay::draw() {
     const auto PMONITOR = g_pCompositor->m_monitors.front();
 
     if (!m_cairoSurface || !m_cairo) {
-        m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+        m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
         m_cairo        = cairo_create(m_cairoSurface);
     }
 
@@ -269,10 +269,10 @@ void CHyprDebugOverlay::draw() {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
 #endif
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     CTexPassElement::SRenderData data;
     data.tex = m_texture;
-    data.box = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    data.box = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
     g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }
diff --git a/src/debug/HyprNotificationOverlay.cpp b/src/debug/HyprNotificationOverlay.cpp
index ede5f8e2..1dc6e167 100644
--- a/src/debug/HyprNotificationOverlay.cpp
+++ b/src/debug/HyprNotificationOverlay.cpp
@@ -77,8 +77,8 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     float                 offsetY  = 10;
     float                 maxWidth = 0;
 
-    const auto            SCALE   = pMonitor->scale;
-    const auto            MONSIZE = pMonitor->vecTransformedSize;
+    const auto            SCALE   = pMonitor->m_scale;
+    const auto            MONSIZE = pMonitor->m_transformedSize;
 
     static auto           fontFamily = CConfigValue<std::string>("misc:font_family");
 
@@ -94,7 +94,7 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
 
     for (auto const& notif : m_notifications) {
         const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD;
-        const auto FONTSIZE        = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
+        const auto FONTSIZE        = std::clamp((int)(notif->fontSize * ((pMonitor->m_pixelSize.x * SCALE) / 1920.f)), 8, 40);
 
         // first rect (bg, col)
         const float FIRSTRECTANIMP =
@@ -189,12 +189,12 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     // cleanup notifs
     std::erase_if(m_notifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
 
-    return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
+    return CBox{(int)(pMonitor->m_position.x + pMonitor->m_size.x - maxWidth - 20), (int)pMonitor->m_position.y, (int)maxWidth + 20, (int)offsetY + 10};
 }
 
 void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
 
-    const auto MONSIZE = pMonitor->vecTransformedSize;
+    const auto MONSIZE = pMonitor->m_transformedSize;
 
     if (m_lastMonitor != pMonitor || m_lastSize != MONSIZE || !m_cairo || !m_cairoSurface) {
 
diff --git a/src/desktop/LayerSurface.cpp b/src/desktop/LayerSurface.cpp
index dcbf35fe..5954a571 100644
--- a/src/desktop/LayerSurface.cpp
+++ b/src/desktop/LayerSurface.cpp
@@ -24,7 +24,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
         return pLS;
     }
 
-    if (pMonitor->pMirrorOf)
+    if (pMonitor->m_mirrorOf)
         pMonitor = g_pCompositor->m_monitors.front();
 
     pLS->m_self = pLS;
@@ -34,7 +34,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
     pLS->m_layer     = resource->current.layer;
     pLS->m_popupHead = CPopup::create(pLS);
     pLS->m_monitor   = pMonitor;
-    pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);
+    pMonitor->m_layerSurfaceLayers[resource->current.layer].emplace_back(pLS);
 
     pLS->m_forceBlur = g_pConfigManager->shouldBlurLS(pLS->m_namespace);
 
@@ -46,7 +46,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
 
     pLS->m_alpha->setValueAndWarp(0.f);
 
-    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->m_layer, pMonitor->szName);
+    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->m_layer, pMonitor->m_name);
 
     return pLS;
 }
@@ -77,7 +77,7 @@ CLayerSurface::~CLayerSurface() {
     std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); });
 
     for (auto const& mon : g_pCompositor->m_realMonitors) {
-        for (auto& lsl : mon->m_aLayerSurfaceLayers) {
+        for (auto& lsl : mon->m_layerSurfaceLayers) {
             std::erase_if(lsl, [this](auto& ls) { return ls.expired() || ls.get() == this; });
         }
     }
@@ -110,11 +110,11 @@ void CLayerSurface::onDestroy() {
 
     // rearrange to fix the reserved areas
     if (PMONITOR) {
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
-        PMONITOR->scheduledRecalc = true;
+        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
+        PMONITOR->m_scheduledRecalc = true;
 
         // and damage
-        CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height};
+        CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
         g_pHyprRenderer->damageBox(geomFixed);
     }
 
@@ -149,11 +149,11 @@ void CLayerSurface::onMap() {
 
     applyRules();
 
-    PMONITOR->scheduledRecalc = true;
+    PMONITOR->m_scheduledRecalc = true;
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
 
-    m_surface->resource()->enter(PMONITOR->self.lock());
+    m_surface->resource()->enter(PMONITOR->m_self.lock());
 
     const bool ISEXCLUSIVE = m_layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
 
@@ -171,16 +171,16 @@ void CLayerSurface::onMap() {
         g_pInputManager->releaseAllMouseButtons();
         g_pCompositor->focusSurface(m_surface->resource());
 
-        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y);
+        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y);
         g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL);
         g_pInputManager->m_bEmptyFocusCursorSet = false;
     }
 
     m_position = Vector2D(m_geometry.x, m_geometry.y);
 
-    CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height};
+    CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
     g_pHyprRenderer->damageBox(geomFixed);
-    const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_hasFullscreenWindow && PMONITOR->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN;
+    const bool FULLSCREEN = PMONITOR->m_activeWorkspace && PMONITOR->m_activeWorkspace->m_hasFullscreenWindow && PMONITOR->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN;
 
     startAnimation(!(m_layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
     m_readyToDelete = false;
@@ -189,8 +189,8 @@ void CLayerSurface::onMap() {
     g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", m_namespace});
     EMIT_HOOK_EVENT("openLayer", m_self.lock());
 
-    g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->transform);
+    g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->m_scale);
+    g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->m_transform);
 }
 
 void CLayerSurface::onUnmap() {
@@ -244,16 +244,16 @@ void CLayerSurface::onUnmap() {
     } else if (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus != m_surface->resource())
         g_pSeatManager->setKeyboardFocus(g_pCompositor->m_lastFocus.lock());
 
-    CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height};
+    CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
     g_pHyprRenderer->damageBox(geomFixed);
 
-    geomFixed = {m_geometry.x + (int)PMONITOR->vecPosition.x, m_geometry.y + (int)PMONITOR->vecPosition.y, (int)m_layerSurface->surface->current.size.x,
+    geomFixed = {m_geometry.x + (int)PMONITOR->m_position.x, m_geometry.y + (int)PMONITOR->m_position.y, (int)m_layerSurface->surface->current.size.x,
                  (int)m_layerSurface->surface->current.size.y};
     g_pHyprRenderer->damageBox(geomFixed);
 
     g_pInputManager->simulateMouseMovement();
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
 }
 
 void CLayerSurface::onCommit() {
@@ -285,12 +285,12 @@ void CLayerSurface::onCommit() {
     if (m_layerSurface->current.committed != 0) {
         if (m_layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
 
-            for (auto it = PMONITOR->m_aLayerSurfaceLayers[m_layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[m_layer].end(); it++) {
+            for (auto it = PMONITOR->m_layerSurfaceLayers[m_layer].begin(); it != PMONITOR->m_layerSurfaceLayers[m_layer].end(); it++) {
                 if (*it == m_self) {
                     if (m_layerSurface->current.layer == m_layer)
                         break;
-                    PMONITOR->m_aLayerSurfaceLayers[m_layerSurface->current.layer].emplace_back(*it);
-                    PMONITOR->m_aLayerSurfaceLayers[m_layer].erase(it);
+                    PMONITOR->m_layerSurfaceLayers[m_layerSurface->current.layer].emplace_back(*it);
+                    PMONITOR->m_layerSurfaceLayers[m_layer].erase(it);
                     break;
                 }
             }
@@ -301,14 +301,14 @@ void CLayerSurface::onCommit() {
                 g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
         }
 
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
 
-        PMONITOR->scheduledRecalc = true;
+        PMONITOR->m_scheduledRecalc = true;
     } else {
         m_position = Vector2D(m_geometry.x, m_geometry.y);
 
         // update geom if it changed
-        if (m_layerSurface->surface->current.scale == 1 && PMONITOR->scale != 1.f && m_layerSurface->surface->current.viewport.hasDestination) {
+        if (m_layerSurface->surface->current.scale == 1 && PMONITOR->m_scale != 1.f && m_layerSurface->surface->current.viewport.hasDestination) {
             // fractional scaling. Dirty hack.
             m_geometry = {m_geometry.pos(), m_layerSurface->surface->current.viewport.destination};
         } else {
@@ -364,7 +364,7 @@ void CLayerSurface::onCommit() {
             g_pInputManager->releaseAllMouseButtons();
             g_pCompositor->focusSurface(m_surface->resource());
 
-            const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y);
+            const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y);
             g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL);
             g_pInputManager->m_bEmptyFocusCursorSet = false;
         }
@@ -374,8 +374,8 @@ void CLayerSurface::onCommit() {
 
     g_pHyprRenderer->damageSurface(m_surface->resource(), m_position.x, m_position.y);
 
-    g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->transform);
+    g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->m_scale);
+    g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->m_transform);
 }
 
 void CLayerSurface::applyRules() {
@@ -484,10 +484,10 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
         }
 
         const std::array<Vector2D, 4> edgePoints = {
-            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, 0.0},
-            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, PMONITOR->vecSize.y},
-            PMONITOR->vecPosition + Vector2D{0.0, PMONITOR->vecSize.y},
-            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x, PMONITOR->vecSize.y / 2},
+            PMONITOR->m_position + Vector2D{PMONITOR->m_size.x / 2, 0.0},
+            PMONITOR->m_position + Vector2D{PMONITOR->m_size.x / 2, PMONITOR->m_size.y},
+            PMONITOR->m_position + Vector2D{0.0, PMONITOR->m_size.y},
+            PMONITOR->m_position + Vector2D{PMONITOR->m_size.x, PMONITOR->m_size.y / 2},
         };
 
         float closest = std::numeric_limits<float>::max();
@@ -511,19 +511,19 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
         switch (leader) {
             case 0:
                 // TOP
-                prePos = {m_geometry.x, PMONITOR->vecPosition.y - m_geometry.h};
+                prePos = {m_geometry.x, PMONITOR->m_position.y - m_geometry.h};
                 break;
             case 1:
                 // BOTTOM
-                prePos = {m_geometry.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y};
+                prePos = {m_geometry.x, PMONITOR->m_position.y + PMONITOR->m_size.y};
                 break;
             case 2:
                 // LEFT
-                prePos = {PMONITOR->vecPosition.x - m_geometry.w, m_geometry.y};
+                prePos = {PMONITOR->m_position.x - m_geometry.w, m_geometry.y};
                 break;
             case 3:
                 // RIGHT
-                prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, m_geometry.y};
+                prePos = {PMONITOR->m_position.x + PMONITOR->m_size.x, m_geometry.y};
                 break;
             default: UNREACHABLE();
         }
@@ -594,7 +594,7 @@ int CLayerSurface::popupsCount() {
 }
 
 MONITORID CLayerSurface::monitorID() {
-    return m_monitor ? m_monitor->ID : MONITOR_INVALID;
+    return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
 }
 
 pid_t CLayerSurface::getPID() {
diff --git a/src/desktop/Popup.cpp b/src/desktop/Popup.cpp
index 049db245..30cf966d 100644
--- a/src/desktop/Popup.cpp
+++ b/src/desktop/Popup.cpp
@@ -110,7 +110,7 @@ void CPopup::onMap() {
 
     //unconstrain();
     sendScale();
-    m_resource->surface->surface->enter(PMONITOR->self.lock());
+    m_resource->surface->surface->enter(PMONITOR->m_self.lock());
 
     if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
         g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
@@ -224,7 +224,7 @@ void CPopup::reposition() {
     if (!PMONITOR)
         return;
 
-    CBox box = {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    CBox box = {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
     m_resource->applyPositioning(box, COORDS);
 }
 
diff --git a/src/desktop/Window.cpp b/src/desktop/Window.cpp
index 899c260a..53ecf049 100644
--- a/src/desktop/Window.cpp
+++ b/src/desktop/Window.cpp
@@ -137,8 +137,8 @@ SBoxExtents CWindow::getFullWindowExtents() {
 
     if (m_windowData.dimAround.valueOrDefault()) {
         if (const auto PMONITOR = m_monitor.lock(); PMONITOR)
-            return {{m_realPosition->value().x - PMONITOR->vecPosition.x, m_realPosition->value().y - PMONITOR->vecPosition.y},
-                    {PMONITOR->vecSize.x - (m_realPosition->value().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_realPosition->value().y - PMONITOR->vecPosition.y)}};
+            return {{m_realPosition->value().x - PMONITOR->m_position.x, m_realPosition->value().y - PMONITOR->m_position.y},
+                    {PMONITOR->m_size.x - (m_realPosition->value().x - PMONITOR->m_position.x), PMONITOR->m_size.y - (m_realPosition->value().y - PMONITOR->m_position.y)}};
     }
 
     SBoxExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
@@ -197,7 +197,7 @@ SBoxExtents CWindow::getFullWindowExtents() {
 CBox CWindow::getFullWindowBoundingBox() {
     if (m_windowData.dimAround.valueOrDefault()) {
         if (const auto PMONITOR = m_monitor.lock(); PMONITOR)
-            return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+            return {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
     }
 
     auto maxExtents = getFullWindowExtents();
@@ -218,25 +218,25 @@ CBox CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
     auto SIZE = m_size;
 
     if (isFullscreen()) {
-        POS  = PMONITOR->vecPosition;
-        SIZE = PMONITOR->vecSize;
+        POS  = PMONITOR->m_position;
+        SIZE = PMONITOR->m_size;
 
         return CBox{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
     }
 
-    if (DELTALESSTHAN(POS.y - PMONITOR->vecPosition.y, PMONITOR->vecReservedTopLeft.y, 1)) {
-        POS.y = PMONITOR->vecPosition.y;
-        SIZE.y += PMONITOR->vecReservedTopLeft.y;
+    if (DELTALESSTHAN(POS.y - PMONITOR->m_position.y, PMONITOR->m_reservedTopLeft.y, 1)) {
+        POS.y = PMONITOR->m_position.y;
+        SIZE.y += PMONITOR->m_reservedTopLeft.y;
     }
-    if (DELTALESSTHAN(POS.x - PMONITOR->vecPosition.x, PMONITOR->vecReservedTopLeft.x, 1)) {
-        POS.x = PMONITOR->vecPosition.x;
-        SIZE.x += PMONITOR->vecReservedTopLeft.x;
+    if (DELTALESSTHAN(POS.x - PMONITOR->m_position.x, PMONITOR->m_reservedTopLeft.x, 1)) {
+        POS.x = PMONITOR->m_position.x;
+        SIZE.x += PMONITOR->m_reservedTopLeft.x;
     }
-    if (DELTALESSTHAN(POS.x + SIZE.x - PMONITOR->vecPosition.x, PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x, 1)) {
-        SIZE.x += PMONITOR->vecReservedBottomRight.x;
+    if (DELTALESSTHAN(POS.x + SIZE.x - PMONITOR->m_position.x, PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x, 1)) {
+        SIZE.x += PMONITOR->m_reservedBottomRight.x;
     }
-    if (DELTALESSTHAN(POS.y + SIZE.y - PMONITOR->vecPosition.y, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y, 1)) {
-        SIZE.y += PMONITOR->vecReservedBottomRight.y;
+    if (DELTALESSTHAN(POS.y + SIZE.y - PMONITOR->m_position.y, PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y, 1)) {
+        SIZE.y += PMONITOR->m_reservedBottomRight.y;
     }
 
     return CBox{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
@@ -246,7 +246,7 @@ CBox CWindow::getWindowBoxUnified(uint64_t properties) {
     if (m_windowData.dimAround.valueOrDefault()) {
         const auto PMONITOR = m_monitor.lock();
         if (PMONITOR)
-            return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+            return {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
     }
 
     SBoxExtents EXTENTS = {{0, 0}, {0, 0}};
@@ -385,10 +385,10 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) {
         return;
 
     if (PNEWMONITOR != PLASTMONITOR || force) {
-        if (PLASTMONITOR && PLASTMONITOR->m_bEnabled && PNEWMONITOR != PLASTMONITOR)
-            m_wlSurface->resource()->breadthfirst([PLASTMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->leave(PLASTMONITOR->self.lock()); }, nullptr);
+        if (PLASTMONITOR && PLASTMONITOR->m_enabled && PNEWMONITOR != PLASTMONITOR)
+            m_wlSurface->resource()->breadthfirst([PLASTMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->leave(PLASTMONITOR->m_self.lock()); }, nullptr);
 
-        m_wlSurface->resource()->breadthfirst([PNEWMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->enter(PNEWMONITOR->self.lock()); }, nullptr);
+        m_wlSurface->resource()->breadthfirst([PNEWMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->enter(PNEWMONITOR->m_self.lock()); }, nullptr);
     }
 
     const auto PMONITOR = m_monitor.lock();
@@ -396,12 +396,12 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) {
     m_wlSurface->resource()->breadthfirst(
         [PMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) {
             const auto PSURFACE = CWLSurface::fromResource(s);
-            if (PSURFACE && PSURFACE->m_lastScaleFloat == PMONITOR->scale)
+            if (PSURFACE && PSURFACE->m_lastScaleFloat == PMONITOR->m_scale)
                 return;
 
-            PROTO::fractional->sendScale(s, PMONITOR->scale);
-            g_pCompositor->setPreferredScaleForSurface(s, PMONITOR->scale);
-            g_pCompositor->setPreferredTransformForSurface(s, PMONITOR->transform);
+            PROTO::fractional->sendScale(s, PMONITOR->m_scale);
+            g_pCompositor->setPreferredScaleForSurface(s, PMONITOR->m_scale);
+            g_pCompositor->setPreferredTransformForSurface(s, PMONITOR->m_transform);
         },
         nullptr);
 }
@@ -520,14 +520,14 @@ void CWindow::onUnmap() {
 
     if (*PCLOSEONLASTSPECIAL && m_workspace && m_workspace->getWindows() == 0 && onSpecialWorkspace()) {
         const auto PMONITOR = m_monitor.lock();
-        if (PMONITOR && PMONITOR->activeSpecialWorkspace && PMONITOR->activeSpecialWorkspace == m_workspace)
+        if (PMONITOR && PMONITOR->m_activeSpecialWorkspace && PMONITOR->m_activeSpecialWorkspace == m_workspace)
             PMONITOR->setSpecialWorkspace(nullptr);
     }
 
     const auto PMONITOR = m_monitor.lock();
 
-    if (PMONITOR && PMONITOR->solitaryClient == m_self)
-        PMONITOR->solitaryClient.reset();
+    if (PMONITOR && PMONITOR->m_solitaryClient == m_self)
+        PMONITOR->m_solitaryClient.reset();
 
     if (m_workspace) {
         m_workspace->updateWindows();
@@ -1248,7 +1248,7 @@ void CWindow::setSuspended(bool suspend) {
 bool CWindow::visibleOnMonitor(PHLMONITOR pMonitor) {
     CBox wbox = {m_realPosition->value(), m_realSize->value()};
 
-    return !wbox.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty();
+    return !wbox.intersection({pMonitor->m_position, pMonitor->m_size}).empty();
 }
 
 void CWindow::setAnimationsToMove() {
@@ -1274,21 +1274,21 @@ void CWindow::onWorkspaceAnimUpdate() {
 
     const auto WINBB = getFullWindowBoundingBox();
     if (PWORKSPACE->m_renderOffset->value().x != 0) {
-        const auto PROGRESS = PWORKSPACE->m_renderOffset->value().x / PWSMON->vecSize.x;
+        const auto PROGRESS = PWORKSPACE->m_renderOffset->value().x / PWSMON->m_size.x;
 
-        if (WINBB.x < PWSMON->vecPosition.x)
-            offset.x += (PWSMON->vecPosition.x - WINBB.x) * PROGRESS;
+        if (WINBB.x < PWSMON->m_position.x)
+            offset.x += (PWSMON->m_position.x - WINBB.x) * PROGRESS;
 
-        if (WINBB.x + WINBB.width > PWSMON->vecPosition.x + PWSMON->vecSize.x)
-            offset.x += (WINBB.x + WINBB.width - PWSMON->vecPosition.x - PWSMON->vecSize.x) * PROGRESS;
+        if (WINBB.x + WINBB.width > PWSMON->m_position.x + PWSMON->m_size.x)
+            offset.x += (WINBB.x + WINBB.width - PWSMON->m_position.x - PWSMON->m_size.x) * PROGRESS;
     } else if (PWORKSPACE->m_renderOffset->value().y != 0) {
-        const auto PROGRESS = PWORKSPACE->m_renderOffset->value().y / PWSMON->vecSize.y;
+        const auto PROGRESS = PWORKSPACE->m_renderOffset->value().y / PWSMON->m_size.y;
 
-        if (WINBB.y < PWSMON->vecPosition.y)
-            offset.y += (PWSMON->vecPosition.y - WINBB.y) * PROGRESS;
+        if (WINBB.y < PWSMON->m_position.y)
+            offset.y += (PWSMON->m_position.y - WINBB.y) * PROGRESS;
 
-        if (WINBB.y + WINBB.height > PWSMON->vecPosition.y + PWSMON->vecSize.y)
-            offset.y += (WINBB.y + WINBB.height - PWSMON->vecPosition.y - PWSMON->vecSize.y) * PROGRESS;
+        if (WINBB.y + WINBB.height > PWSMON->m_position.y + PWSMON->m_size.y)
+            offset.y += (WINBB.y + WINBB.height - PWSMON->m_position.y - PWSMON->m_size.y) * PROGRESS;
     }
 
     m_floatingOffset = offset;
@@ -1342,7 +1342,7 @@ WORKSPACEID CWindow::workspaceID() {
 }
 
 MONITORID CWindow::monitorID() {
-    return m_monitor ? m_monitor->ID : MONITOR_INVALID;
+    return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
 }
 
 bool CWindow::onSpecialWorkspace() {
@@ -1426,7 +1426,7 @@ void CWindow::onUpdateState() {
         if (requestsID.has_value() && (requestsID.value() != MONITOR_INVALID) && !(m_suppressedEvents & SUPPRESS_FULLSCREEN_OUTPUT)) {
             if (m_isMapped) {
                 const auto monitor = g_pCompositor->getMonitorFromID(requestsID.value());
-                g_pCompositor->moveWindowToWorkspaceSafe(m_self.lock(), monitor->activeWorkspace);
+                g_pCompositor->moveWindowToWorkspaceSafe(m_self.lock(), monitor->m_activeWorkspace);
                 g_pCompositor->setActiveMonitor(monitor);
             }
 
@@ -1580,7 +1580,7 @@ void CWindow::onX11ConfigureRequest(CBox box) {
     if (!m_workspace || !m_workspace->isVisible())
         return; // further things are only for visible windows
 
-    m_workspace = g_pCompositor->getMonitorFromVector(m_realPosition->goal() + m_realSize->goal() / 2.f)->activeWorkspace;
+    m_workspace = g_pCompositor->getMonitorFromVector(m_realPosition->goal() + m_realSize->goal() / 2.f)->m_activeWorkspace;
 
     g_pCompositor->changeWindowZOrder(m_self.lock(), true);
 
@@ -1711,7 +1711,7 @@ Vector2D CWindow::realToReportSize() {
     const auto  PMONITOR   = m_monitor.lock();
 
     if (*PXWLFORCESCALEZERO && PMONITOR)
-        return REPORTSIZE * PMONITOR->scale;
+        return REPORTSIZE * PMONITOR->m_scale;
 
     return REPORTSIZE;
 }
@@ -1728,7 +1728,7 @@ Vector2D CWindow::xwaylandSizeToReal(Vector2D size) {
 
     const auto  PMONITOR = m_monitor.lock();
     const auto  SIZE     = size.clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
-    const auto  SCALE    = *PXWLFORCESCALEZERO ? PMONITOR->scale : 1.0f;
+    const auto  SCALE    = *PXWLFORCESCALEZERO ? PMONITOR->m_scale : 1.0f;
 
     return SIZE / SCALE;
 }
@@ -1743,7 +1743,7 @@ void CWindow::updateX11SurfaceScale() {
     m_X11SurfaceScaledBy = 1.0f;
     if (m_isX11 && *PXWLFORCESCALEZERO) {
         if (const auto PMONITOR = m_monitor.lock(); PMONITOR)
-            m_X11SurfaceScaledBy = PMONITOR->scale;
+            m_X11SurfaceScaledBy = PMONITOR->m_scale;
     }
 }
 
diff --git a/src/desktop/Workspace.cpp b/src/desktop/Workspace.cpp
index 8bb7f7a0..fbbad118 100644
--- a/src/desktop/Workspace.cpp
+++ b/src/desktop/Workspace.cpp
@@ -110,24 +110,24 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
         if (ANIMSTYLE.starts_with("slidefadevert")) {
             if (in) {
                 m_alpha->setValueAndWarp(0.f);
-                m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
+                m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->m_size.y : -PMONITOR->m_size.y) * (movePerc / 100.f)));
                 *m_alpha        = 1.f;
                 *m_renderOffset = Vector2D(0, 0);
             } else {
                 m_alpha->setValueAndWarp(1.f);
                 *m_alpha        = 0.f;
-                *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
+                *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->m_size.y : PMONITOR->m_size.y) * (movePerc / 100.f));
             }
         } else {
             if (in) {
                 m_alpha->setValueAndWarp(0.f);
-                m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0));
+                m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->m_size.x : -PMONITOR->m_size.x) * (movePerc / 100.f), 0.0));
                 *m_alpha        = 1.f;
                 *m_renderOffset = Vector2D(0, 0);
             } else {
                 m_alpha->setValueAndWarp(1.f);
                 *m_alpha        = 0.f;
-                *m_renderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0);
+                *m_renderOffset = Vector2D((left ? -PMONITOR->m_size.x : PMONITOR->m_size.x) * (movePerc / 100.f), 0.0);
             }
         }
     } else if (ANIMSTYLE == "fade") {
@@ -143,7 +143,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     } else if (ANIMSTYLE == "slidevert") {
         // fallback is slide
         const auto PMONITOR  = m_monitor.lock();
-        const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
+        const auto YDISTANCE = PMONITOR->m_size.y + *PWORKSPACEGAP;
 
         m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
@@ -156,7 +156,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     } else {
         // fallback is slide
         const auto PMONITOR  = m_monitor.lock();
-        const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
+        const auto XDISTANCE = PMONITOR->m_size.x + *PWORKSPACEGAP;
 
         m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
@@ -520,7 +520,7 @@ bool CWorkspace::inert() {
 }
 
 MONITORID CWorkspace::monitorID() {
-    return m_monitor ? m_monitor->ID : MONITOR_INVALID;
+    return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
 }
 
 PHLWINDOW CWorkspace::getFullscreenWindow() {
@@ -538,10 +538,10 @@ bool CWorkspace::isVisible() {
 
 bool CWorkspace::isVisibleNotCovered() {
     const auto PMONITOR = m_monitor.lock();
-    if (PMONITOR->activeSpecialWorkspace)
-        return PMONITOR->activeSpecialWorkspace->m_id == m_id;
+    if (PMONITOR->m_activeSpecialWorkspace)
+        return PMONITOR->m_activeSpecialWorkspace->m_id == m_id;
 
-    return PMONITOR->activeWorkspace->m_id == m_id;
+    return PMONITOR->m_activeWorkspace->m_id == m_id;
 }
 
 int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
@@ -597,7 +597,7 @@ PHLWINDOW CWorkspace::getTopLeftWindow() {
 
         const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
 
-        if (WINDOWIDEALBB.x <= PMONITOR->vecPosition.x + 1 && WINDOWIDEALBB.y <= PMONITOR->vecPosition.y + 1)
+        if (WINDOWIDEALBB.x <= PMONITOR->m_position.x + 1 && WINDOWIDEALBB.y <= PMONITOR->m_position.y + 1)
             return w;
     }
     return nullptr;
diff --git a/src/devices/VirtualPointer.cpp b/src/devices/VirtualPointer.cpp
index 1aaf8b10..bc45f035 100644
--- a/src/devices/VirtualPointer.cpp
+++ b/src/devices/VirtualPointer.cpp
@@ -42,7 +42,7 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : m_poi
     m_listeners.holdBegin      = m_pointer->events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); });
     m_listeners.holdEnd        = m_pointer->events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); });
 
-    m_boundOutput = resource->boundOutput ? resource->boundOutput->szName : "";
+    m_boundOutput = resource->boundOutput ? resource->boundOutput->m_name : "";
 
     m_deviceName = m_pointer->name;
 }
diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp
index f476c6e8..838839d3 100644
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -63,7 +63,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         g_pCompositor->setActiveMonitor(g_pCompositor->getMonitorFromVector({}));
         PMONITOR = g_pCompositor->m_lastMonitor.lock();
     }
-    auto PWORKSPACE          = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
+    auto PWORKSPACE          = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace;
     PWINDOW->m_monitor       = PMONITOR;
     PWINDOW->m_workspace     = PWORKSPACE;
     PWINDOW->m_isMapped      = true;
@@ -172,7 +172,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID()));
                         PMONITOR = PMONITORFROMID;
                     }
-                    PWINDOW->m_workspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
+                    PWINDOW->m_workspace = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace;
                     PWORKSPACE           = PWINDOW->m_workspace;
 
                     Debug::log(LOG, "Rule monitor, applying to {:mw}", PWINDOW);
@@ -356,7 +356,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
             PWINDOW->m_workspace = pWorkspace;
             PWINDOW->m_monitor   = pWorkspace->m_monitor;
 
-            if (PWINDOW->m_monitor.lock()->activeSpecialWorkspace && !pWorkspace->m_isSpecialWorkspace)
+            if (PWINDOW->m_monitor.lock()->m_activeSpecialWorkspace && !pWorkspace->m_isSpecialWorkspace)
                 workspaceSilent = true;
 
             if (!workspaceSilent) {
@@ -385,7 +385,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
             g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID()));
             PMONITOR = PMONITORFROMID;
         }
-        PWINDOW->m_workspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
+        PWINDOW->m_workspace = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace;
         PWORKSPACE           = PWINDOW->m_workspace;
 
         Debug::log(LOG, "Requested monitor, applying to {:mw}", PWINDOW);
@@ -432,11 +432,11 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
                         const auto  MAXSIZE = PWINDOW->requestedMaxSize();
 
-                        const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->vecSize.x) :
-                                                                stringToFloatClamp(SIZEXSTR, PWINDOW->m_realSize->goal().x, PMONITOR->vecSize.x);
+                        const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->m_size.x) :
+                                                                stringToFloatClamp(SIZEXSTR, PWINDOW->m_realSize->goal().x, PMONITOR->m_size.x);
 
-                        const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) :
-                                                                stringToFloatClamp(SIZEYSTR, PWINDOW->m_realSize->goal().y, PMONITOR->vecSize.y);
+                        const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->m_size.y) :
+                                                                stringToFloatClamp(SIZEYSTR, PWINDOW->m_realSize->goal().y, PMONITOR->m_size.y);
 
                         Debug::log(LOG, "Rule size, applying to {}", PWINDOW);
 
@@ -469,8 +469,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         if (POSXSTR.starts_with("100%-")) {
                             const bool subtractWindow = POSXSTR.starts_with("100%-w-");
                             const auto POSXRAW        = (subtractWindow) ? POSXSTR.substr(7) : POSXSTR.substr(5);
-                            posX                      = PMONITOR->vecSize.x -
-                                (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
+                            posX =
+                                PMONITOR->m_size.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->m_size.x);
 
                             if (subtractWindow)
                                 posX -= PWINDOW->m_realSize->goal().x;
@@ -478,13 +478,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
                             if (CURSOR)
                                 Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
                         } else if (!CURSOR) {
-                            posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x;
+                            posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->m_size.x;
                         } else {
                             // cursor
                             if (POSXSTR == "cursor") {
-                                posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x;
+                                posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->m_position.x;
                             } else {
-                                posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x +
+                                posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->m_position.x +
                                     (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_realSize->goal().x);
                             }
                         }
@@ -492,8 +492,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         if (POSYSTR.starts_with("100%-")) {
                             const bool subtractWindow = POSYSTR.starts_with("100%-w-");
                             const auto POSYRAW        = (subtractWindow) ? POSYSTR.substr(7) : POSYSTR.substr(5);
-                            posY                      = PMONITOR->vecSize.y -
-                                (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
+                            posY =
+                                PMONITOR->m_size.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->m_size.y);
 
                             if (subtractWindow)
                                 posY -= PWINDOW->m_realSize->goal().y;
@@ -501,13 +501,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
                             if (CURSOR)
                                 Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
                         } else if (!CURSOR) {
-                            posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y;
+                            posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->m_size.y;
                         } else {
                             // cursor
                             if (POSYSTR == "cursor") {
-                                posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y;
+                                posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->m_position.y;
                             } else {
-                                posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y +
+                                posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->m_position.y +
                                     (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_realSize->goal().y);
                             }
                         }
@@ -515,16 +515,16 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         if (ONSCREEN) {
                             int borderSize = PWINDOW->getRealBorderSize();
 
-                            posX = std::clamp(posX, (int)(PMONITOR->vecReservedTopLeft.x + borderSize),
-                                              (int)(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PWINDOW->m_realSize->goal().x - borderSize));
+                            posX = std::clamp(posX, (int)(PMONITOR->m_reservedTopLeft.x + borderSize),
+                                              (int)(PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x - PWINDOW->m_realSize->goal().x - borderSize));
 
-                            posY = std::clamp(posY, (int)(PMONITOR->vecReservedTopLeft.y + borderSize),
-                                              (int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_realSize->goal().y - borderSize));
+                            posY = std::clamp(posY, (int)(PMONITOR->m_reservedTopLeft.y + borderSize),
+                                              (int)(PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y - PWINDOW->m_realSize->goal().y - borderSize));
                         }
 
                         Debug::log(LOG, "Rule move, applying to {}", PWINDOW);
 
-                        *PWINDOW->m_realPosition = Vector2D(posX, posY) + PMONITOR->vecPosition;
+                        *PWINDOW->m_realPosition = Vector2D(posX, posY) + PMONITOR->m_position;
 
                         PWINDOW->setHidden(false);
                     } catch (...) { Debug::log(LOG, "Rule move failed, rule: {} -> {}", r->m_rule, r->m_value); }
@@ -534,7 +534,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     auto       RESERVEDOFFSET = Vector2D();
                     const auto ARGS           = CVarList(r->m_rule, 2, ' ');
                     if (ARGS[1] == "1")
-                        RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;
+                        RESERVEDOFFSET = (PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight) / 2.f;
 
                     *PWINDOW->m_realPosition = PMONITOR->middle() - PWINDOW->m_realSize->goal() / 2.f + RESERVEDOFFSET;
                     break;
@@ -565,9 +565,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
                 const auto  MAXSIZE = PWINDOW->requestedMaxSize();
 
-                const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->vecSize.x) : stringToPercentage(SIZEXSTR, PMONITOR->vecSize.x);
+                const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->m_size.x) : stringToPercentage(SIZEXSTR, PMONITOR->m_size.x);
 
-                const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) : stringToPercentage(SIZEYSTR, PMONITOR->vecSize.y);
+                const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->m_size.y) : stringToPercentage(SIZEYSTR, PMONITOR->m_size.y);
 
                 Debug::log(LOG, "Rule size (tiled), applying to {}", PWINDOW);
 
@@ -662,7 +662,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     PWINDOW->m_firstMap = false;
 
-    Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->szName, PWINDOW->m_realPosition->goal(), PWINDOW->m_realSize->goal());
+    Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->m_name, PWINDOW->m_realPosition->goal(), PWINDOW->m_realSize->goal());
 
     auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_name;
     g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", std::format("{:x},{},{},{}", PWINDOW, workspaceID, PWINDOW->m_class, PWINDOW->m_title)});
@@ -687,8 +687,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
     if (PWORKSPACE->m_hasFullscreenWindow && !PWINDOW->isFullscreen() && !PWINDOW->m_isFloating)
         PWINDOW->m_alpha->setValueAndWarp(0.f);
 
-    g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->transform);
+    g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->m_scale);
+    g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->m_transform);
 
     if (g_pSeatManager->mouse.expired() || !g_pInputManager->isConstrained())
         g_pInputManager->sendMotionEventsToFocused();
@@ -700,7 +700,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_workspace->updateWindows();
 
     if (PMONITOR && PWINDOW->isX11OverrideRedirect())
-        PWINDOW->m_X11SurfaceScaledBy = PMONITOR->scale;
+        PWINDOW->m_X11SurfaceScaledBy = PMONITOR->m_scale;
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
@@ -721,7 +721,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     const auto PMONITOR = PWINDOW->m_monitor.lock();
     if (PMONITOR) {
-        PWINDOW->m_originalClosedPos     = PWINDOW->m_realPosition->value() - PMONITOR->vecPosition;
+        PWINDOW->m_originalClosedPos     = PWINDOW->m_realPosition->value() - PMONITOR->m_position;
         PWINDOW->m_originalClosedSize    = PWINDOW->m_realSize->value();
         PWINDOW->m_originalClosedExtents = PWINDOW->getFullWindowExtents();
     }
@@ -892,14 +892,14 @@ void Events::listener_commitWindow(void* owner, void* data) {
     }
 
     // tearing: if solitary, redraw it. This still might be a single surface window
-    if (PMONITOR && PMONITOR->solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear && PWINDOW->m_wlSurface->resource()->current.texture) {
+    if (PMONITOR && PMONITOR->m_solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->m_tearingState.canTear && PWINDOW->m_wlSurface->resource()->current.texture) {
         CRegion damageBox{PWINDOW->m_wlSurface->resource()->current.accumulateBufferDamage()};
 
         if (!damageBox.empty()) {
-            if (PMONITOR->tearingState.busy) {
-                PMONITOR->tearingState.frameScheduledWhileBusy = true;
+            if (PMONITOR->m_tearingState.busy) {
+                PMONITOR->m_tearingState.frameScheduledWhileBusy = true;
             } else {
-                PMONITOR->tearingState.nextRenderTorn = true;
+                PMONITOR->m_tearingState.nextRenderTorn = true;
                 g_pHyprRenderer->renderMonitor(PMONITOR);
             }
         }
@@ -998,14 +998,14 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
 
         if (*PXWLFORCESCALEZERO) {
             if (const auto PMONITOR = PWINDOW->m_monitor.lock(); PMONITOR) {
-                PWINDOW->m_realSize->setValueAndWarp(PWINDOW->m_realSize->goal() / PMONITOR->scale);
+                PWINDOW->m_realSize->setValueAndWarp(PWINDOW->m_realSize->goal() / PMONITOR->m_scale);
             }
         }
 
         PWINDOW->m_position = PWINDOW->m_realPosition->goal();
         PWINDOW->m_size     = PWINDOW->m_realSize->goal();
 
-        PWINDOW->m_workspace = g_pCompositor->getMonitorFromVector(PWINDOW->m_realPosition->value() + PWINDOW->m_realSize->value() / 2.f)->activeWorkspace;
+        PWINDOW->m_workspace = g_pCompositor->getMonitorFromVector(PWINDOW->m_realPosition->value() + PWINDOW->m_realSize->value() / 2.f)->m_activeWorkspace;
 
         g_pCompositor->changeWindowZOrder(PWINDOW, true);
         PWINDOW->updateWindowDecos();
diff --git a/src/helpers/Color.cpp b/src/helpers/Color.cpp
index 8dfefbbd..42ae1fd4 100644
--- a/src/helpers/Color.cpp
+++ b/src/helpers/Color.cpp
@@ -8,11 +8,11 @@
 CHyprColor::CHyprColor() = default;
 
 CHyprColor::CHyprColor(float r_, float g_, float b_, float a_) : r(r_), g(g_), b(b_), a(a_) {
-    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+    m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
 }
 
 CHyprColor::CHyprColor(uint64_t hex) : r(RED(hex)), g(GREEN(hex)), b(BLUE(hex)), a(ALPHA(hex)) {
-    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+    m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
 }
 
 CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
@@ -21,7 +21,7 @@ CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
     g               = SRGB.g;
     b               = SRGB.b;
 
-    okLab = color.asOkLab();
+    m_okLab = color.asOkLab();
 }
 
 uint32_t CHyprColor::getAsHex() const {
@@ -33,11 +33,11 @@ Hyprgraphics::CColor::SSRGB CHyprColor::asRGB() const {
 }
 
 Hyprgraphics::CColor::SOkLab CHyprColor::asOkLab() const {
-    return okLab;
+    return m_okLab;
 }
 
 Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const {
-    return Hyprgraphics::CColor(okLab).asHSL();
+    return Hyprgraphics::CColor(m_okLab).asHSL();
 }
 
 CHyprColor CHyprColor::stripA() const {
diff --git a/src/helpers/Color.hpp b/src/helpers/Color.hpp
index 8050bebd..e72fcd58 100644
--- a/src/helpers/Color.hpp
+++ b/src/helpers/Color.hpp
@@ -43,7 +43,7 @@ class CHyprColor {
     double r = 0, g = 0, b = 0, a = 0;
 
   private:
-    Hyprgraphics::CColor::SOkLab okLab; // cache for the OkLab representation
+    Hyprgraphics::CColor::SOkLab m_okLab; // cache for the OkLab representation
 };
 
 //NOLINTNEXTLINE
diff --git a/src/helpers/DamageRing.cpp b/src/helpers/DamageRing.cpp
index 093e7ca6..82c8894b 100644
--- a/src/helpers/DamageRing.cpp
+++ b/src/helpers/DamageRing.cpp
@@ -1,43 +1,43 @@
 #include "DamageRing.hpp"
 
 void CDamageRing::setSize(const Vector2D& size_) {
-    if (size_ == size)
+    if (size_ == m_size)
         return;
 
-    size = size_;
+    m_size = size_;
 
     damageEntire();
 }
 
 bool CDamageRing::damage(const CRegion& rg) {
-    CRegion clipped = rg.copy().intersect(CBox{{}, size});
+    CRegion clipped = rg.copy().intersect(CBox{{}, m_size});
     if (clipped.empty())
         return false;
 
-    current.add(clipped);
+    m_current.add(clipped);
     return true;
 }
 
 void CDamageRing::damageEntire() {
-    damage(CBox{{}, size});
+    damage(CBox{{}, m_size});
 }
 
 void CDamageRing::rotate() {
-    previousIdx = (previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
+    m_previousIdx = (m_previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
 
-    previous[previousIdx] = current;
-    current.clear();
+    m_previous[m_previousIdx] = m_current;
+    m_current.clear();
 }
 
 CRegion CDamageRing::getBufferDamage(int age) {
     if (age <= 0 || age > DAMAGE_RING_PREVIOUS_LEN + 1)
-        return CBox{{}, size};
+        return CBox{{}, m_size};
 
-    CRegion damage = current;
+    CRegion damage = m_current;
 
     for (int i = 0; i < age - 1; ++i) {
-        int j = (previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
-        damage.add(previous.at(j));
+        int j = (m_previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
+        damage.add(m_previous.at(j));
     }
 
     // don't return a ludicrous amount of rects
@@ -48,5 +48,5 @@ CRegion CDamageRing::getBufferDamage(int age) {
 }
 
 bool CDamageRing::hasChanged() {
-    return !current.empty();
+    return !m_current.empty();
 }
diff --git a/src/helpers/DamageRing.hpp b/src/helpers/DamageRing.hpp
index ae85c453..f53d6bf0 100644
--- a/src/helpers/DamageRing.hpp
+++ b/src/helpers/DamageRing.hpp
@@ -15,8 +15,8 @@ class CDamageRing {
     bool    hasChanged();
 
   private:
-    Vector2D                                      size;
-    CRegion                                       current;
-    std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> previous;
-    size_t                                        previousIdx = 0;
+    Vector2D                                      m_size;
+    CRegion                                       m_current;
+    std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> m_previous;
+    size_t                                        m_previousIdx = 0;
 };
diff --git a/src/helpers/MiscFunctions.cpp b/src/helpers/MiscFunctions.cpp
index bb5510b6..ed67618e 100644
--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -148,7 +148,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (same_mon) {
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (PMONITOR && (PMONITOR->ID != g_pCompositor->m_lastMonitor->ID))
+                if (PMONITOR && (PMONITOR->m_id != g_pCompositor->m_lastMonitor->m_id))
                     invalidWSes.insert(rule.workspaceId);
             }
         }
@@ -165,7 +165,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (!g_pCompositor->m_lastMonitor)
             return {WORKSPACE_INVALID};
 
-        const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+        const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
         if (!valid(PWORKSPACE))
             return {WORKSPACE_INVALID};
@@ -184,12 +184,12 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
         return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name};
     } else if (in == "next") {
-        if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->activeWorkspace) {
+        if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->m_activeWorkspace) {
             Debug::log(ERR, "no active monitor or workspace for 'next'");
             return {WORKSPACE_INVALID};
         }
 
-        auto        PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+        auto        PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
         WORKSPACEID nextId = PCURRENTWORKSPACE->m_id + 1;
 
@@ -227,7 +227,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             }
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (!PMONITOR || PMONITOR->ID == g_pCompositor->m_lastMonitor->ID) {
+                if (!PMONITOR || PMONITOR->m_id == g_pCompositor->m_lastMonitor->m_id) {
                     // Can't be invalid
                     continue;
                 }
@@ -265,7 +265,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             } else {
 
                 // Just take a blind guess at where we'll probably end up
-                WORKSPACEID activeWSID    = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1;
+                WORKSPACEID activeWSID    = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
                 WORKSPACEID predictedWSID = activeWSID + remains;
                 int         remainingWSes = 0;
                 char        walkDir       = in[1];
@@ -407,7 +407,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
                 remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
 
                 // get the current item
-                WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1;
+                WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
                 for (ssize_t i = 0; i < (ssize_t)validWSes.size(); i++) {
                     if (validWSes[i] == activeWSID) {
                         currentItem = i;
diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp
index 4ee0166f..2edba78a 100644
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -39,133 +39,133 @@ using namespace Hyprutils::OS;
 using enum NContentType::eContentType;
 
 static int ratHandler(void* data) {
-    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->self.lock());
+    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->m_self.lock());
 
     return 1;
 }
 
-CMonitor::CMonitor(SP<Aquamarine::IOutput> output_) : state(this), output(output_) {
+CMonitor::CMonitor(SP<Aquamarine::IOutput> output_) : m_state(this), m_output(output_) {
     ;
 }
 
 CMonitor::~CMonitor() {
-    events.destroy.emit();
+    m_events.destroy.emit();
     if (g_pHyprOpenGL)
-        g_pHyprOpenGL->destroyMonitorResources(self);
+        g_pHyprOpenGL->destroyMonitorResources(m_self);
 }
 
 void CMonitor::onConnect(bool noRule) {
-    EMIT_HOOK_EVENT("preMonitorAdded", self.lock());
+    EMIT_HOOK_EVENT("preMonitorAdded", m_self.lock());
     CScopeGuard x = {[]() { g_pCompositor->arrangeMonitors(); }};
 
     g_pEventLoopManager->doLater([] { g_pConfigManager->ensurePersistentWorkspacesPresent(); });
 
-    listeners.frame  = output->events.frame.registerListener([this](std::any d) { onMonitorFrame(); });
-    listeners.commit = output->events.commit.registerListener([this](std::any d) {
+    m_listeners.frame  = m_output->events.frame.registerListener([this](std::any d) { onMonitorFrame(); });
+    m_listeners.commit = m_output->events.commit.registerListener([this](std::any d) {
         if (true) { // FIXME: E->state->committed & WLR_OUTPUT_STATE_BUFFER
-            PROTO::screencopy->onOutputCommit(self.lock());
-            PROTO::toplevelExport->onOutputCommit(self.lock());
+            PROTO::screencopy->onOutputCommit(m_self.lock());
+            PROTO::toplevelExport->onOutputCommit(m_self.lock());
         }
     });
-    listeners.needsFrame =
-        output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
+    m_listeners.needsFrame =
+        m_output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
 
-    listeners.presented = output->events.present.registerListener([this](std::any d) {
+    m_listeners.presented = m_output->events.present.registerListener([this](std::any d) {
         auto      E = std::any_cast<Aquamarine::IOutput::SPresentEvent>(d);
 
         timespec* ts = E.when;
         if (!ts) {
             timespec now;
             clock_gettime(CLOCK_MONOTONIC, &now);
-            PROTO::presentation->onPresented(self.lock(), Time::fromTimespec(&now), E.refresh, E.seq, E.flags);
+            PROTO::presentation->onPresented(m_self.lock(), Time::fromTimespec(&now), E.refresh, E.seq, E.flags);
         } else
-            PROTO::presentation->onPresented(self.lock(), Time::fromTimespec(E.when), E.refresh, E.seq, E.flags);
+            PROTO::presentation->onPresented(m_self.lock(), Time::fromTimespec(E.when), E.refresh, E.seq, E.flags);
     });
 
-    listeners.destroy = output->events.destroy.registerListener([this](std::any d) {
-        Debug::log(LOG, "Destroy called for monitor {}", szName);
+    m_listeners.destroy = m_output->events.destroy.registerListener([this](std::any d) {
+        Debug::log(LOG, "Destroy called for monitor {}", m_name);
 
         onDisconnect(true);
 
-        output                 = nullptr;
-        m_bRenderingInitPassed = false;
+        m_output              = nullptr;
+        m_renderingInitPassed = false;
 
-        Debug::log(LOG, "Removing monitor {} from realMonitors", szName);
+        Debug::log(LOG, "Removing monitor {} from realMonitors", m_name);
 
         std::erase_if(g_pCompositor->m_realMonitors, [&](PHLMONITOR& el) { return el.get() == this; });
     });
 
-    listeners.state = output->events.state.registerListener([this](std::any d) {
+    m_listeners.state = m_output->events.state.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IOutput::SStateEvent>(d);
 
         if (E.size == Vector2D{}) {
             // an indication to re-set state
             // we can't do much for createdByUser displays I think
-            if (createdByUser)
+            if (m_createdByUser)
                 return;
 
-            Debug::log(LOG, "Reapplying monitor rule for {} from a state request", szName);
-            applyMonitorRule(&activeMonitorRule, true);
+            Debug::log(LOG, "Reapplying monitor rule for {} from a state request", m_name);
+            applyMonitorRule(&m_activeMonitorRule, true);
             return;
         }
 
-        if (!createdByUser)
+        if (!m_createdByUser)
             return;
 
         const auto SIZE = E.size;
 
-        forceSize = SIZE;
+        m_forceSize = SIZE;
 
-        SMonitorRule rule = activeMonitorRule;
+        SMonitorRule rule = m_activeMonitorRule;
         rule.resolution   = SIZE;
 
         applyMonitorRule(&rule);
     });
 
-    tearingState.canTear = output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
+    m_tearingState.canTear = m_output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
 
-    if (m_bEnabled) {
-        output->state->resetExplicitFences();
-        output->state->setEnabled(true);
-        state.commit();
+    if (m_enabled) {
+        m_output->state->resetExplicitFences();
+        m_output->state->setEnabled(true);
+        m_state.commit();
         return;
     }
 
-    szName = output->name;
+    m_name = m_output->name;
 
-    szDescription = output->description;
+    m_description = m_output->description;
     // remove comma character from description. This allow monitor specific rules to work on monitor with comma on their description
-    std::erase(szDescription, ',');
+    std::erase(m_description, ',');
 
     // field is backwards-compatible with intended usage of `szDescription` but excludes the parenthesized DRM node name suffix
-    szShortDescription = trim(std::format("{} {} {}", output->make, output->model, output->serial));
-    std::erase(szShortDescription, ',');
+    m_shortDescription = trim(std::format("{} {} {}", m_output->make, m_output->model, m_output->serial));
+    std::erase(m_shortDescription, ',');
 
-    if (output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
-        createdByUser = true; // should be true. WL and Headless backends should be addable / removable
+    if (m_output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
+        m_createdByUser = true; // should be true. WL and Headless backends should be addable / removable
 
     // get monitor rule that matches
-    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(self.lock());
+    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(m_self.lock());
 
     // if it's disabled, disable and ignore
     if (monitorRule.disabled) {
 
-        output->state->resetExplicitFences();
-        output->state->setEnabled(false);
+        m_output->state->resetExplicitFences();
+        m_output->state->setEnabled(false);
 
-        if (!state.commit())
-            Debug::log(ERR, "Couldn't commit disabled state on output {}", output->name);
+        if (!m_state.commit())
+            Debug::log(ERR, "Couldn't commit disabled state on output {}", m_output->name);
 
-        m_bEnabled = false;
+        m_enabled = false;
 
-        listeners.frame.reset();
+        m_listeners.frame.reset();
         return;
     }
 
-    if (output->nonDesktop) {
+    if (m_output->nonDesktop) {
         Debug::log(LOG, "Not configuring non-desktop output");
         if (PROTO::lease)
-            PROTO::lease->offer(self.lock());
+            PROTO::lease->offer(m_self.lock());
 
         return;
     }
@@ -174,7 +174,7 @@ void CMonitor::onConnect(bool noRule) {
 
     // find the wrap
     for (auto& m : g_pCompositor->m_realMonitors) {
-        if (m->ID == ID) {
+        if (m->m_id == m_id) {
             thisWrapper = &m;
             break;
         }
@@ -185,21 +185,21 @@ void CMonitor::onConnect(bool noRule) {
     if (std::find_if(g_pCompositor->m_monitors.begin(), g_pCompositor->m_monitors.end(), [&](auto& other) { return other.get() == this; }) == g_pCompositor->m_monitors.end())
         g_pCompositor->m_monitors.push_back(*thisWrapper);
 
-    m_bEnabled = true;
+    m_enabled = true;
 
-    output->state->resetExplicitFences();
-    output->state->setEnabled(true);
+    m_output->state->resetExplicitFences();
+    m_output->state->setEnabled(true);
 
     // set mode, also applies
     if (!noRule)
         applyMonitorRule(&monitorRule, true);
 
-    if (!state.commit())
+    if (!m_state.commit())
         Debug::log(WARN, "state.commit() failed in CMonitor::onCommit");
 
-    damage.setSize(vecTransformedSize);
+    m_damage.setSize(m_transformedSize);
 
-    Debug::log(LOG, "Added new monitor with name {} at {:j0} with size {:j0}, pointer {:x}", output->name, vecPosition, vecPixelSize, (uintptr_t)output.get());
+    Debug::log(LOG, "Added new monitor with name {} at {:j0} with size {:j0}, pointer {:x}", m_output->name, m_position, m_pixelSize, (uintptr_t)m_output.get());
 
     setupDefaultWS(monitorRule);
 
@@ -207,31 +207,31 @@ void CMonitor::onConnect(bool noRule) {
         if (!valid(ws))
             continue;
 
-        if (ws->m_lastMonitor == szName || g_pCompositor->m_monitors.size() == 1 /* avoid lost workspaces on recover */) {
-            g_pCompositor->moveWorkspaceToMonitor(ws, self.lock());
+        if (ws->m_lastMonitor == m_name || g_pCompositor->m_monitors.size() == 1 /* avoid lost workspaces on recover */) {
+            g_pCompositor->moveWorkspaceToMonitor(ws, m_self.lock());
             ws->startAnim(true, true, true);
             ws->m_lastMonitor = "";
         }
     }
 
-    scale = monitorRule.scale;
-    if (scale < 0.1)
-        scale = getDefaultScale();
+    m_scale = monitorRule.scale;
+    if (m_scale < 0.1)
+        m_scale = getDefaultScale();
 
-    forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
+    m_forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
     //
 
-    if (!activeMonitorRule.mirrorOf.empty())
-        setMirror(activeMonitorRule.mirrorOf);
+    if (!m_activeMonitorRule.mirrorOf.empty())
+        setMirror(m_activeMonitorRule.mirrorOf);
 
     if (!g_pCompositor->m_lastMonitor) // set the last monitor if it isnt set yet
-        g_pCompositor->setActiveMonitor(self.lock());
+        g_pCompositor->setActiveMonitor(m_self.lock());
 
-    g_pHyprRenderer->arrangeLayersForMonitor(ID);
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(m_id);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
     // ensure VRR (will enable if necessary)
-    g_pConfigManager->ensureVRR(self.lock());
+    g_pConfigManager->ensureVRR(m_self.lock());
 
     // verify last mon valid
     bool found = false;
@@ -242,63 +242,63 @@ void CMonitor::onConnect(bool noRule) {
         }
     }
 
-    Debug::log(LOG, "checking if we have seen this monitor before: {}", szName);
+    Debug::log(LOG, "checking if we have seen this monitor before: {}", m_name);
     // if we saw this monitor before, set it to the workspace it was on
-    if (g_pCompositor->m_seenMonitorWorkspaceMap.contains(szName)) {
-        auto workspaceID = g_pCompositor->m_seenMonitorWorkspaceMap[szName];
-        Debug::log(LOG, "Monitor {} was on workspace {}, setting it to that", szName, workspaceID);
+    if (g_pCompositor->m_seenMonitorWorkspaceMap.contains(m_name)) {
+        auto workspaceID = g_pCompositor->m_seenMonitorWorkspaceMap[m_name];
+        Debug::log(LOG, "Monitor {} was on workspace {}, setting it to that", m_name, workspaceID);
         auto ws = g_pCompositor->getWorkspaceByID(workspaceID);
         if (ws) {
-            g_pCompositor->moveWorkspaceToMonitor(ws, self.lock());
+            g_pCompositor->moveWorkspaceToMonitor(ws, m_self.lock());
             changeWorkspace(ws, true, false, false);
         }
     } else
-        Debug::log(LOG, "Monitor {} was not on any workspace", szName);
+        Debug::log(LOG, "Monitor {} was not on any workspace", m_name);
 
     if (!found)
-        g_pCompositor->setActiveMonitor(self.lock());
+        g_pCompositor->setActiveMonitor(m_self.lock());
 
-    renderTimer = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, ratHandler, this);
+    m_renderTimer = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, ratHandler, this);
 
-    g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEW_MONITOR);
+    g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEW_MONITOR);
 
-    PROTO::gamma->applyGammaToState(self.lock());
+    PROTO::gamma->applyGammaToState(m_self.lock());
 
-    events.connect.emit();
+    m_events.connect.emit();
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{"monitoraddedv2", std::format("{},{},{}", ID, szName, szShortDescription)});
-    EMIT_HOOK_EVENT("monitorAdded", self.lock());
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoraddedv2", std::format("{},{},{}", m_id, m_name, m_shortDescription)});
+    EMIT_HOOK_EVENT("monitorAdded", m_self.lock());
 }
 
 void CMonitor::onDisconnect(bool destroy) {
-    EMIT_HOOK_EVENT("preMonitorRemoved", self.lock());
+    EMIT_HOOK_EVENT("preMonitorRemoved", m_self.lock());
     CScopeGuard x = {[this]() {
         if (g_pCompositor->m_isShuttingDown)
             return;
-        g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
-        EMIT_HOOK_EVENT("monitorRemoved", self.lock());
+        g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", m_name});
+        EMIT_HOOK_EVENT("monitorRemoved", m_self.lock());
         g_pCompositor->arrangeMonitors();
     }};
 
-    if (renderTimer) {
-        wl_event_source_remove(renderTimer);
-        renderTimer = nullptr;
+    if (m_renderTimer) {
+        wl_event_source_remove(m_renderTimer);
+        m_renderTimer = nullptr;
     }
 
-    if (!m_bEnabled || g_pCompositor->m_isShuttingDown)
+    if (!m_enabled || g_pCompositor->m_isShuttingDown)
         return;
 
-    Debug::log(LOG, "onDisconnect called for {}", output->name);
+    Debug::log(LOG, "onDisconnect called for {}", m_output->name);
 
-    events.disconnect.emit();
+    m_events.disconnect.emit();
     if (g_pHyprOpenGL)
-        g_pHyprOpenGL->destroyMonitorResources(self);
+        g_pHyprOpenGL->destroyMonitorResources(m_self);
 
     // record what workspace this monitor was on
-    if (activeWorkspace) {
-        Debug::log(LOG, "Disconnecting Monitor {} was on workspace {}", szName, activeWorkspace->m_id);
-        g_pCompositor->m_seenMonitorWorkspaceMap[szName] = activeWorkspace->m_id;
+    if (m_activeWorkspace) {
+        Debug::log(LOG, "Disconnecting Monitor {} was on workspace {}", m_name, m_activeWorkspace->m_id);
+        g_pCompositor->m_seenMonitorWorkspaceMap[m_name] = m_activeWorkspace->m_id;
     }
 
     // Cleanup everything. Move windows back, snap cursor, shit.
@@ -311,58 +311,58 @@ void CMonitor::onDisconnect(bool destroy) {
     }
 
     // remove mirror
-    if (pMirrorOf) {
-        pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == self; }));
+    if (m_mirrorOf) {
+        m_mirrorOf->m_mirrors.erase(std::find_if(m_mirrorOf->m_mirrors.begin(), m_mirrorOf->m_mirrors.end(), [&](const auto& other) { return other == m_self; }));
 
         // unlock software for mirrored monitor
-        g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf.lock());
-        pMirrorOf.reset();
+        g_pPointerManager->unlockSoftwareForMonitor(m_mirrorOf.lock());
+        m_mirrorOf.reset();
     }
 
-    if (!mirrors.empty()) {
-        for (auto const& m : mirrors) {
+    if (!m_mirrors.empty()) {
+        for (auto const& m : m_mirrors) {
             m->setMirror("");
         }
 
         g_pConfigManager->m_wantsMonitorReload = true;
     }
 
-    listeners.frame.reset();
-    listeners.presented.reset();
-    listeners.needsFrame.reset();
-    listeners.commit.reset();
+    m_listeners.frame.reset();
+    m_listeners.presented.reset();
+    m_listeners.needsFrame.reset();
+    m_listeners.commit.reset();
 
     for (size_t i = 0; i < 4; ++i) {
-        for (auto const& ls : m_aLayerSurfaceLayers[i]) {
+        for (auto const& ls : m_layerSurfaceLayers[i]) {
             if (ls->m_layerSurface && !ls->m_fadingOut)
                 ls->m_layerSurface->sendClosed();
         }
-        m_aLayerSurfaceLayers[i].clear();
+        m_layerSurfaceLayers[i].clear();
     }
 
-    Debug::log(LOG, "Removed monitor {}!", szName);
+    Debug::log(LOG, "Removed monitor {}!", m_name);
 
     if (!BACKUPMON) {
         Debug::log(WARN, "Unplugged last monitor, entering an unsafe state. Good luck my friend.");
         g_pCompositor->enterUnsafeState();
     }
 
-    m_bEnabled             = false;
-    m_bRenderingInitPassed = false;
+    m_enabled             = false;
+    m_renderingInitPassed = false;
 
     if (BACKUPMON) {
         // snap cursor
-        g_pCompositor->warpCursorTo(BACKUPMON->vecPosition + BACKUPMON->vecTransformedSize / 2.F, true);
+        g_pCompositor->warpCursorTo(BACKUPMON->m_position + BACKUPMON->m_transformedSize / 2.F, true);
 
         // move workspaces
         std::vector<PHLWORKSPACE> wspToMove;
         for (auto const& w : g_pCompositor->m_workspaces) {
-            if (w->m_monitor == self || !w->m_monitor)
+            if (w->m_monitor == m_self || !w->m_monitor)
                 wspToMove.push_back(w);
         }
 
         for (auto const& w : wspToMove) {
-            w->m_lastMonitor = szName;
+            w->m_lastMonitor = m_name;
             g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
             w->startAnim(true, true, true);
         }
@@ -372,28 +372,28 @@ void CMonitor::onDisconnect(bool destroy) {
         g_pCompositor->m_lastMonitor.reset();
     }
 
-    if (activeWorkspace)
-        activeWorkspace->m_visible = false;
-    activeWorkspace.reset();
+    if (m_activeWorkspace)
+        m_activeWorkspace->m_visible = false;
+    m_activeWorkspace.reset();
 
-    output->state->resetExplicitFences();
-    output->state->setAdaptiveSync(false);
-    output->state->setEnabled(false);
+    m_output->state->resetExplicitFences();
+    m_output->state->setAdaptiveSync(false);
+    m_output->state->setEnabled(false);
 
-    if (!state.commit())
+    if (!m_state.commit())
         Debug::log(WARN, "state.commit() failed in CMonitor::onDisconnect");
 
-    if (g_pCompositor->m_lastMonitor == self)
+    if (g_pCompositor->m_lastMonitor == m_self)
         g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_unsafeOutput.lock());
 
-    if (g_pHyprRenderer->m_pMostHzMonitor == self) {
+    if (g_pHyprRenderer->m_pMostHzMonitor == m_self) {
         int        mostHz         = 0;
         PHLMONITOR pMonitorMostHz = nullptr;
 
         for (auto const& m : g_pCompositor->m_monitors) {
-            if (m->refreshRate > mostHz && m != self) {
+            if (m->m_refreshRate > mostHz && m != m_self) {
                 pMonitorMostHz = m;
-                mostHz         = m->refreshRate;
+                mostHz         = m->m_refreshRate;
             }
         }
 
@@ -406,44 +406,44 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
     static auto PDISABLESCALECHECKS = CConfigValue<Hyprlang::INT>("debug:disable_scale_checks");
 
-    Debug::log(LOG, "Applying monitor rule for {}", szName);
+    Debug::log(LOG, "Applying monitor rule for {}", m_name);
 
-    activeMonitorRule = *pMonitorRule;
+    m_activeMonitorRule = *pMonitorRule;
 
-    if (forceSize.has_value())
-        activeMonitorRule.resolution = forceSize.value();
+    if (m_forceSize.has_value())
+        m_activeMonitorRule.resolution = m_forceSize.value();
 
-    const auto RULE = &activeMonitorRule;
+    const auto RULE = &m_activeMonitorRule;
 
     // if it's disabled, disable and ignore
     if (RULE->disabled) {
-        if (m_bEnabled)
+        if (m_enabled)
             onDisconnect();
 
-        events.modeChanged.emit();
+        m_events.modeChanged.emit();
 
         return true;
     }
 
     // don't touch VR headsets
-    if (output->nonDesktop)
+    if (m_output->nonDesktop)
         return true;
 
-    if (!m_bEnabled) {
+    if (!m_enabled) {
         onConnect(true); // enable it.
-        Debug::log(LOG, "Monitor {} is disabled but is requested to be enabled", szName);
+        Debug::log(LOG, "Monitor {} is disabled but is requested to be enabled", m_name);
         force = true;
     }
 
     // Check if the rule isn't already applied
     // TODO: clean this up lol
-    if (!force && DELTALESSTHAN(vecPixelSize.x, RULE->resolution.x, 1) && DELTALESSTHAN(vecPixelSize.y, RULE->resolution.y, 1) &&
-        DELTALESSTHAN(refreshRate, RULE->refreshRate, 1) && setScale == RULE->scale &&
-        ((DELTALESSTHAN(vecPosition.x, RULE->offset.x, 1) && DELTALESSTHAN(vecPosition.y, RULE->offset.y, 1)) || RULE->offset == Vector2D(-INT32_MAX, -INT32_MAX)) &&
-        transform == RULE->transform && RULE->enable10bit == enabled10bit && RULE->cmType == cmType && RULE->sdrSaturation == sdrSaturation &&
-        RULE->sdrBrightness == sdrBrightness && !std::memcmp(&customDrmMode, &RULE->drmMode, sizeof(customDrmMode))) {
+    if (!force && DELTALESSTHAN(m_pixelSize.x, RULE->resolution.x, 1) && DELTALESSTHAN(m_pixelSize.y, RULE->resolution.y, 1) &&
+        DELTALESSTHAN(m_refreshRate, RULE->refreshRate, 1) && m_setScale == RULE->scale &&
+        ((DELTALESSTHAN(m_position.x, RULE->offset.x, 1) && DELTALESSTHAN(m_position.y, RULE->offset.y, 1)) || RULE->offset == Vector2D(-INT32_MAX, -INT32_MAX)) &&
+        m_transform == RULE->transform && RULE->enable10bit == m_enabled10bit && RULE->cmType == m_cmType && RULE->sdrSaturation == m_sdrSaturation &&
+        RULE->sdrBrightness == m_sdrBrightness && !std::memcmp(&m_customDrmMode, &RULE->drmMode, sizeof(m_customDrmMode))) {
 
-        Debug::log(LOG, "Not applying a new rule to {} because it's already applied!", szName);
+        Debug::log(LOG, "Not applying a new rule to {} because it's already applied!", m_name);
 
         setMirror(RULE->mirrorOf);
 
@@ -453,15 +453,15 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     bool autoScale = false;
 
     if (RULE->scale > 0.1) {
-        scale = RULE->scale;
+        m_scale = RULE->scale;
     } else {
         autoScale               = true;
         const auto DEFAULTSCALE = getDefaultScale();
-        scale                   = DEFAULTSCALE;
+        m_scale                 = DEFAULTSCALE;
     }
 
-    setScale  = scale;
-    transform = RULE->transform;
+    m_setScale  = m_scale;
+    m_transform = RULE->transform;
 
     // accumulate requested modes in reverse order (cause inesrting at front is inefficient)
     std::vector<SP<Aquamarine::SOutputMode>> requestedModes;
@@ -469,7 +469,7 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
     // use sortFunc, add best 3 to requestedModes in reverse, since we test in reverse
     auto addBest3Modes = [&](auto const& sortFunc) {
-        auto sortedModes = output->modes;
+        auto sortedModes = m_output->modes;
         std::ranges::sort(sortedModes, sortFunc);
         if (sortedModes.size() > 3)
             sortedModes.erase(sortedModes.begin() + 3, sortedModes.end());
@@ -477,22 +477,22 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     };
 
     // last fallback is always preferred mode
-    if (!output->preferredMode())
-        Debug::log(ERR, "Monitor {} has NO PREFERRED MODE", output->name);
+    if (!m_output->preferredMode())
+        Debug::log(ERR, "Monitor {} has NO PREFERRED MODE", m_output->name);
     else
-        requestedModes.push_back(output->preferredMode());
+        requestedModes.push_back(m_output->preferredMode());
 
     if (RULE->resolution == Vector2D()) {
         requestedStr = "preferred";
 
         // fallback to first 3 modes if preferred fails/doesn't exist
-        requestedModes = output->modes;
+        requestedModes = m_output->modes;
         if (requestedModes.size() > 3)
             requestedModes.erase(requestedModes.begin() + 3, requestedModes.end());
         std::ranges::reverse(requestedModes.begin(), requestedModes.end());
 
-        if (output->preferredMode())
-            requestedModes.push_back(output->preferredMode());
+        if (m_output->preferredMode())
+            requestedModes.push_back(m_output->preferredMode());
     } else if (RULE->resolution == Vector2D(-1, -1)) {
         requestedStr = "highrr";
 
@@ -541,7 +541,7 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
         // then if requested is custom, try custom mode first
         if (RULE->drmMode.type == DRM_MODE_TYPE_USERDEF) {
-            if (output->getBackend()->type() != Aquamarine::eBackendType::AQ_BACKEND_DRM)
+            if (m_output->getBackend()->type() != Aquamarine::eBackendType::AQ_BACKEND_DRM)
                 Debug::log(ERR, "Tried to set custom modeline on non-DRM output");
             else
                 requestedModes.push_back(makeShared<Aquamarine::SOutputMode>(
@@ -549,21 +549,21 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         }
     }
 
-    const auto WAS10B  = enabled10bit;
-    const auto OLDRES  = vecPixelSize;
+    const auto WAS10B  = m_enabled10bit;
+    const auto OLDRES  = m_pixelSize;
     bool       success = false;
 
     // Needed in case we are switching from a custom modeline to a standard mode
-    customDrmMode = {};
-    currentMode   = nullptr;
+    m_customDrmMode = {};
+    m_currentMode   = nullptr;
 
-    output->state->setFormat(DRM_FORMAT_XRGB8888);
-    prevDrmFormat = drmFormat;
-    drmFormat     = DRM_FORMAT_XRGB8888;
-    output->state->resetExplicitFences();
+    m_output->state->setFormat(DRM_FORMAT_XRGB8888);
+    m_prevDrmFormat = m_drmFormat;
+    m_drmFormat     = DRM_FORMAT_XRGB8888;
+    m_output->state->resetExplicitFences();
 
     if (Debug::m_trace) {
-        Debug::log(TRACE, "Monitor {} requested modes:", szName);
+        Debug::log(TRACE, "Monitor {} requested modes:", m_name);
         if (requestedModes.empty())
             Debug::log(TRACE, "| None");
         else {
@@ -577,81 +577,81 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         std::string modeStr = std::format("{:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
 
         if (mode->modeInfo.has_value() && mode->modeInfo->type == DRM_MODE_TYPE_USERDEF) {
-            output->state->setCustomMode(mode);
+            m_output->state->setCustomMode(mode);
 
-            if (!state.test()) {
-                Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", szName, modeStr);
+            if (!m_state.test()) {
+                Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", m_name, modeStr);
                 continue;
             }
 
-            customDrmMode = mode->modeInfo.value();
+            m_customDrmMode = mode->modeInfo.value();
         } else {
-            output->state->setMode(mode);
+            m_output->state->setMode(mode);
 
-            if (!state.test()) {
-                Debug::log(ERR, "Monitor {}: REJECTED available mode {}!", szName, modeStr);
+            if (!m_state.test()) {
+                Debug::log(ERR, "Monitor {}: REJECTED available mode {}!", m_name, modeStr);
                 if (mode->preferred)
-                    Debug::log(ERR, "Monitor {}: REJECTED preferred mode!!!", szName);
+                    Debug::log(ERR, "Monitor {}: REJECTED preferred mode!!!", m_name);
                 continue;
             }
 
-            customDrmMode = {};
+            m_customDrmMode = {};
         }
 
-        refreshRate = mode->refreshRate / 1000.f;
-        vecSize     = mode->pixelSize;
-        currentMode = mode;
+        m_refreshRate = mode->refreshRate / 1000.f;
+        m_size        = mode->pixelSize;
+        m_currentMode = mode;
 
         success = true;
 
         if (mode->preferred)
-            Debug::log(LOG, "Monitor {}: requested {}, using preferred mode {}", szName, requestedStr, modeStr);
+            Debug::log(LOG, "Monitor {}: requested {}, using preferred mode {}", m_name, requestedStr, modeStr);
         else if (mode->modeInfo.has_value() && mode->modeInfo->type == DRM_MODE_TYPE_USERDEF)
-            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", szName, requestedStr, modeStr);
+            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", m_name, requestedStr, modeStr);
         else
-            Debug::log(LOG, "Monitor {}: requested {}, using available mode {}", szName, requestedStr, modeStr);
+            Debug::log(LOG, "Monitor {}: requested {}, using available mode {}", m_name, requestedStr, modeStr);
 
         break;
     }
 
     // try requested as custom mode jic it works
     if (!success && RULE->resolution != Vector2D() && RULE->resolution != Vector2D(-1, -1) && RULE->resolution != Vector2D(-1, -2)) {
-        auto        refreshRate = output->getBackend()->type() == Aquamarine::eBackendType::AQ_BACKEND_DRM ? RULE->refreshRate * 1000 : 0;
+        auto        refreshRate = m_output->getBackend()->type() == Aquamarine::eBackendType::AQ_BACKEND_DRM ? RULE->refreshRate * 1000 : 0;
         auto        mode        = makeShared<Aquamarine::SOutputMode>(Aquamarine::SOutputMode{.pixelSize = RULE->resolution, .refreshRate = refreshRate});
         std::string modeStr     = std::format("{:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
 
-        output->state->setCustomMode(mode);
+        m_output->state->setCustomMode(mode);
 
-        if (state.test()) {
-            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", szName, requestedStr, modeStr);
+        if (m_state.test()) {
+            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", m_name, requestedStr, modeStr);
 
-            refreshRate   = mode->refreshRate / 1000.f;
-            vecSize       = mode->pixelSize;
-            currentMode   = mode;
-            customDrmMode = {};
+            refreshRate     = mode->refreshRate / 1000.f;
+            m_size          = mode->pixelSize;
+            m_currentMode   = mode;
+            m_customDrmMode = {};
 
             success = true;
         } else
-            Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", szName, modeStr);
+            Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", m_name, modeStr);
     }
 
     // try any of the modes if none of the above work
     if (!success) {
-        for (auto const& mode : output->modes) {
-            output->state->setMode(mode);
+        for (auto const& mode : m_output->modes) {
+            m_output->state->setMode(mode);
 
-            if (!state.test())
+            if (!m_state.test())
                 continue;
 
             auto errorMessage =
-                std::format("Monitor {} failed to set any requested modes, falling back to mode {:X0}@{:.2f}Hz", szName, mode->pixelSize, mode->refreshRate / 1000.f);
+                std::format("Monitor {} failed to set any requested modes, falling back to mode {:X0}@{:.2f}Hz", m_name, mode->pixelSize, mode->refreshRate / 1000.f);
             Debug::log(WARN, errorMessage);
             g_pHyprNotificationOverlay->addNotification(errorMessage, CHyprColor(0xff0000ff), 5000, ICON_WARNING);
 
-            refreshRate   = mode->refreshRate / 1000.f;
-            vecSize       = mode->pixelSize;
-            currentMode   = mode;
-            customDrmMode = {};
+            m_refreshRate   = mode->refreshRate / 1000.f;
+            m_size          = mode->pixelSize;
+            m_currentMode   = mode;
+            m_customDrmMode = {};
 
             success = true;
 
@@ -660,14 +660,14 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     }
 
     if (!success) {
-        Debug::log(ERR, "Monitor {} has NO FALLBACK MODES, and an INVALID one was requested: {:X0}@{:.2f}Hz", szName, RULE->resolution, RULE->refreshRate);
+        Debug::log(ERR, "Monitor {} has NO FALLBACK MODES, and an INVALID one was requested: {:X0}@{:.2f}Hz", m_name, RULE->resolution, RULE->refreshRate);
         return true;
     }
 
-    vrrActive = output->state->state().adaptiveSync // disabled here, will be tested in CConfigManager::ensureVRR()
-        || createdByUser;                           // wayland backend doesn't allow for disabling adaptive_sync
+    m_vrrActive = m_output->state->state().adaptiveSync // disabled here, will be tested in CConfigManager::ensureVRR()
+        || m_createdByUser;                             // wayland backend doesn't allow for disabling adaptive_sync
 
-    vecPixelSize = vecSize;
+    m_pixelSize = m_size;
 
     // clang-format off
     static const std::array<std::vector<std::pair<std::string, uint32_t>>, 2> formats{
@@ -683,102 +683,102 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     bool set10bit = false;
 
     for (auto const& fmt : formats[(int)!RULE->enable10bit]) {
-        output->state->setFormat(fmt.second);
-        prevDrmFormat = drmFormat;
-        drmFormat     = fmt.second;
+        m_output->state->setFormat(fmt.second);
+        m_prevDrmFormat = m_drmFormat;
+        m_drmFormat     = fmt.second;
 
-        if (!state.test()) {
-            Debug::log(ERR, "output {} failed basic test on format {}", szName, fmt.first);
+        if (!m_state.test()) {
+            Debug::log(ERR, "output {} failed basic test on format {}", m_name, fmt.first);
         } else {
-            Debug::log(LOG, "output {} succeeded basic test on format {}", szName, fmt.first);
+            Debug::log(LOG, "output {} succeeded basic test on format {}", m_name, fmt.first);
             if (RULE->enable10bit && fmt.first.contains("101010"))
                 set10bit = true;
             break;
         }
     }
 
-    enabled10bit = set10bit;
+    m_enabled10bit = set10bit;
 
-    auto oldImageDescription = imageDescription;
-    cmType                   = RULE->cmType;
-    switch (cmType) {
-        case CM_AUTO: cmType = enabled10bit && output->parsedEDID.supportsBT2020 ? CM_WIDE : CM_SRGB; break;
-        case CM_EDID: cmType = output->parsedEDID.chromaticityCoords.has_value() ? CM_EDID : CM_SRGB; break;
+    auto oldImageDescription = m_imageDescription;
+    m_cmType                 = RULE->cmType;
+    switch (m_cmType) {
+        case CM_AUTO: m_cmType = m_enabled10bit && m_output->parsedEDID.supportsBT2020 ? CM_WIDE : CM_SRGB; break;
+        case CM_EDID: m_cmType = m_output->parsedEDID.chromaticityCoords.has_value() ? CM_EDID : CM_SRGB; break;
         case CM_HDR:
         case CM_HDR_EDID:
-            cmType = output->parsedEDID.supportsBT2020 && output->parsedEDID.hdrMetadata.has_value() && output->parsedEDID.hdrMetadata->supportsPQ ? cmType : CM_SRGB;
+            m_cmType = m_output->parsedEDID.supportsBT2020 && m_output->parsedEDID.hdrMetadata.has_value() && m_output->parsedEDID.hdrMetadata->supportsPQ ? m_cmType : CM_SRGB;
             break;
         default: break;
     }
-    switch (cmType) {
-        case CM_SRGB: imageDescription = {}; break; // assumes SImageDescirption defaults to sRGB
+    switch (m_cmType) {
+        case CM_SRGB: m_imageDescription = {}; break; // assumes SImageDescirption defaults to sRGB
         case CM_WIDE:
-            imageDescription = {.primariesNameSet = true,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020)};
+            m_imageDescription = {.primariesNameSet = true,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020)};
             break;
         case CM_EDID:
-            imageDescription = {.primariesNameSet = false,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = {
-                                           .red   = {.x = output->parsedEDID.chromaticityCoords->red.x, .y = output->parsedEDID.chromaticityCoords->red.y},
-                                           .green = {.x = output->parsedEDID.chromaticityCoords->green.x, .y = output->parsedEDID.chromaticityCoords->green.y},
-                                           .blue  = {.x = output->parsedEDID.chromaticityCoords->blue.x, .y = output->parsedEDID.chromaticityCoords->blue.y},
-                                           .white = {.x = output->parsedEDID.chromaticityCoords->white.x, .y = output->parsedEDID.chromaticityCoords->white.y},
-                                }};
+            m_imageDescription = {.primariesNameSet = false,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = {
+                                             .red   = {.x = m_output->parsedEDID.chromaticityCoords->red.x, .y = m_output->parsedEDID.chromaticityCoords->red.y},
+                                             .green = {.x = m_output->parsedEDID.chromaticityCoords->green.x, .y = m_output->parsedEDID.chromaticityCoords->green.y},
+                                             .blue  = {.x = m_output->parsedEDID.chromaticityCoords->blue.x, .y = m_output->parsedEDID.chromaticityCoords->blue.y},
+                                             .white = {.x = m_output->parsedEDID.chromaticityCoords->white.x, .y = m_output->parsedEDID.chromaticityCoords->white.y},
+                                  }};
             break;
         case CM_HDR:
-            imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
-                                .primariesNameSet = true,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
-                                .luminances       = {.min = 0, .max = 10000, .reference = 203}};
+            m_imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
+                                  .primariesNameSet = true,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
+                                  .luminances       = {.min = 0, .max = 10000, .reference = 203}};
             break;
         case CM_HDR_EDID:
-            imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
-                                .primariesNameSet = false,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = output->parsedEDID.chromaticityCoords.has_value() ?
-                                           NColorManagement::SPCPRimaries{
-                                               .red   = {.x = output->parsedEDID.chromaticityCoords->red.x, .y = output->parsedEDID.chromaticityCoords->red.y},
-                                               .green = {.x = output->parsedEDID.chromaticityCoords->green.x, .y = output->parsedEDID.chromaticityCoords->green.y},
-                                               .blue  = {.x = output->parsedEDID.chromaticityCoords->blue.x, .y = output->parsedEDID.chromaticityCoords->blue.y},
-                                               .white = {.x = output->parsedEDID.chromaticityCoords->white.x, .y = output->parsedEDID.chromaticityCoords->white.y},
-                                    } :
-                                           NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
-                                .luminances       = {.min       = output->parsedEDID.hdrMetadata->desiredContentMinLuminance,
-                                                     .max       = output->parsedEDID.hdrMetadata->desiredContentMaxLuminance,
-                                                     .reference = output->parsedEDID.hdrMetadata->desiredMaxFrameAverageLuminance}};
+            m_imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
+                                  .primariesNameSet = false,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = m_output->parsedEDID.chromaticityCoords.has_value() ?
+                                             NColorManagement::SPCPRimaries{
+                                                 .red   = {.x = m_output->parsedEDID.chromaticityCoords->red.x, .y = m_output->parsedEDID.chromaticityCoords->red.y},
+                                                 .green = {.x = m_output->parsedEDID.chromaticityCoords->green.x, .y = m_output->parsedEDID.chromaticityCoords->green.y},
+                                                 .blue  = {.x = m_output->parsedEDID.chromaticityCoords->blue.x, .y = m_output->parsedEDID.chromaticityCoords->blue.y},
+                                                 .white = {.x = m_output->parsedEDID.chromaticityCoords->white.x, .y = m_output->parsedEDID.chromaticityCoords->white.y},
+                                      } :
+                                             NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
+                                  .luminances       = {.min       = m_output->parsedEDID.hdrMetadata->desiredContentMinLuminance,
+                                                       .max       = m_output->parsedEDID.hdrMetadata->desiredContentMaxLuminance,
+                                                       .reference = m_output->parsedEDID.hdrMetadata->desiredMaxFrameAverageLuminance}};
 
             break;
         default: UNREACHABLE();
     }
-    if (oldImageDescription != imageDescription)
-        PROTO::colorManagement->onMonitorImageDescriptionChanged(self);
+    if (oldImageDescription != m_imageDescription)
+        PROTO::colorManagement->onMonitorImageDescriptionChanged(m_self);
 
-    sdrSaturation = RULE->sdrSaturation;
-    sdrBrightness = RULE->sdrBrightness;
+    m_sdrSaturation = RULE->sdrSaturation;
+    m_sdrBrightness = RULE->sdrBrightness;
 
-    Vector2D logicalSize = vecPixelSize / scale;
+    Vector2D logicalSize = m_pixelSize / m_scale;
     if (!*PDISABLESCALECHECKS && (logicalSize.x != std::round(logicalSize.x) || logicalSize.y != std::round(logicalSize.y))) {
         // invalid scale, will produce fractional pixels.
         // find the nearest valid.
 
-        float    searchScale = std::round(scale * 120.0);
+        float    searchScale = std::round(m_scale * 120.0);
         bool     found       = false;
 
         double   scaleZero = searchScale / 120.0;
 
-        Vector2D logicalZero = vecPixelSize / scaleZero;
+        Vector2D logicalZero = m_pixelSize / scaleZero;
         if (logicalZero == logicalZero.round())
-            scale = scaleZero;
+            m_scale = scaleZero;
         else {
             for (size_t i = 1; i < 90; ++i) {
                 double   scaleUp   = (searchScale + i) / 120.0;
                 double   scaleDown = (searchScale - i) / 120.0;
 
-                Vector2D logicalUp   = vecPixelSize / scaleUp;
-                Vector2D logicalDown = vecPixelSize / scaleDown;
+                Vector2D logicalUp   = m_pixelSize / scaleUp;
+                Vector2D logicalDown = m_pixelSize / scaleDown;
 
                 if (logicalUp == logicalUp.round()) {
                     found       = true;
@@ -794,48 +794,48 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
             if (!found) {
                 if (autoScale)
-                    scale = std::round(scaleZero);
+                    m_scale = std::round(scaleZero);
                 else {
-                    Debug::log(ERR, "Invalid scale passed to monitor, {} failed to find a clean divisor", scale);
-                    g_pConfigManager->addParseError("Invalid scale passed to monitor " + szName + ", failed to find a clean divisor");
-                    scale = getDefaultScale();
+                    Debug::log(ERR, "Invalid scale passed to monitor, {} failed to find a clean divisor", m_scale);
+                    g_pConfigManager->addParseError("Invalid scale passed to monitor " + m_name + ", failed to find a clean divisor");
+                    m_scale = getDefaultScale();
                 }
             } else {
                 if (!autoScale) {
-                    Debug::log(ERR, "Invalid scale passed to monitor, {} found suggestion {}", scale, searchScale);
+                    Debug::log(ERR, "Invalid scale passed to monitor, {} found suggestion {}", m_scale, searchScale);
                     g_pConfigManager->addParseError(
-                        std::format("Invalid scale passed to monitor {}, failed to find a clean divisor. Suggested nearest scale: {:5f}", szName, searchScale));
-                    scale = getDefaultScale();
+                        std::format("Invalid scale passed to monitor {}, failed to find a clean divisor. Suggested nearest scale: {:5f}", m_name, searchScale));
+                    m_scale = getDefaultScale();
                 } else
-                    scale = searchScale;
+                    m_scale = searchScale;
             }
         }
     }
 
-    output->scheduleFrame();
+    m_output->scheduleFrame();
 
-    if (!state.commit())
-        Debug::log(ERR, "Couldn't commit output named {}", output->name);
+    if (!m_state.commit())
+        Debug::log(ERR, "Couldn't commit output named {}", m_output->name);
 
-    Vector2D xfmd      = transform % 2 == 1 ? Vector2D{vecPixelSize.y, vecPixelSize.x} : vecPixelSize;
-    vecSize            = (xfmd / scale).round();
-    vecTransformedSize = xfmd;
+    Vector2D xfmd     = m_transform % 2 == 1 ? Vector2D{m_pixelSize.y, m_pixelSize.x} : m_pixelSize;
+    m_size            = (xfmd / m_scale).round();
+    m_transformedSize = xfmd;
 
-    if (createdByUser) {
-        CBox transformedBox = {0, 0, vecTransformedSize.x, vecTransformedSize.y};
-        transformedBox.transform(wlTransformToHyprutils(invertTransform(transform)), vecTransformedSize.x, vecTransformedSize.y);
+    if (m_createdByUser) {
+        CBox transformedBox = {0, 0, m_transformedSize.x, m_transformedSize.y};
+        transformedBox.transform(wlTransformToHyprutils(invertTransform(m_transform)), m_transformedSize.x, m_transformedSize.y);
 
-        vecPixelSize = Vector2D(transformedBox.width, transformedBox.height);
+        m_pixelSize = Vector2D(transformedBox.width, transformedBox.height);
     }
 
     updateMatrix();
 
-    if (WAS10B != enabled10bit || OLDRES != vecPixelSize)
-        g_pHyprOpenGL->destroyMonitorResources(self);
+    if (WAS10B != m_enabled10bit || OLDRES != m_pixelSize)
+        g_pHyprOpenGL->destroyMonitorResources(m_self);
 
     g_pCompositor->arrangeMonitors();
 
-    damage.setSize(vecTransformedSize);
+    m_damage.setSize(m_transformedSize);
 
     // Set scale for all surfaces on this monitor, needed for some clients
     // but not on unsafe state to avoid crashes
@@ -845,28 +845,28 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         }
     }
     // updato us
-    g_pHyprRenderer->arrangeLayersForMonitor(ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(m_id);
 
     // reload to fix mirrors
     g_pConfigManager->m_wantsMonitorReload = true;
 
-    Debug::log(LOG, "Monitor {} data dump: res {:X}@{:.2f}Hz, scale {:.2f}, transform {}, pos {:X}, 10b {}", szName, vecPixelSize, refreshRate, scale, (int)transform, vecPosition,
-               (int)enabled10bit);
+    Debug::log(LOG, "Monitor {} data dump: res {:X}@{:.2f}Hz, scale {:.2f}, transform {}, pos {:X}, 10b {}", m_name, m_pixelSize, m_refreshRate, m_scale, (int)m_transform,
+               m_position, (int)m_enabled10bit);
 
     EMIT_HOOK_EVENT("monitorLayoutChanged", nullptr);
 
-    events.modeChanged.emit();
+    m_events.modeChanged.emit();
 
     return true;
 }
 
 void CMonitor::addDamage(const pixman_region32_t* rg) {
     static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
-    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
-        damage.damageEntire();
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
-    } else if (damage.damage(rg))
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == m_self) {
+        m_damage.damageEntire();
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    } else if (m_damage.damage(rg))
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }
 
 void CMonitor::addDamage(const CRegion& rg) {
@@ -875,13 +875,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() == self) {
-        damage.damageEntire();
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == m_self) {
+        m_damage.damageEntire();
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
     }
 
-    if (damage.damage(box))
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    if (m_damage.damage(box))
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }
 
 bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
@@ -889,13 +889,13 @@ bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
     static auto PMINRR   = CConfigValue<Hyprlang::INT>("cursor:min_refresh_rate");
 
     // skip scheduling extra frames for fullsreen apps with vrr
-    const bool shouldSkip = activeWorkspace && activeWorkspace->m_hasFullscreenWindow && activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN &&
-        (*PNOBREAK == 1 || (*PNOBREAK == 2 && activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && output->state->state().adaptiveSync;
+    const bool shouldSkip = m_activeWorkspace && m_activeWorkspace->m_hasFullscreenWindow && m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN &&
+        (*PNOBREAK == 1 || (*PNOBREAK == 2 && m_activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && m_output->state->state().adaptiveSync;
 
     // keep requested minimum refresh rate
-    if (shouldSkip && *PMINRR && lastPresentationTimer.getMillis() > 1000.0f / *PMINRR) {
+    if (shouldSkip && *PMINRR && m_lastPresentationTimer.getMillis() > 1000.0f / *PMINRR) {
         // damage whole screen because some previous cursor box damages were skipped
-        damage.damageEntire();
+        m_damage.damageEntire();
         return false;
     }
 
@@ -903,7 +903,7 @@ bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
 }
 
 bool CMonitor::isMirror() {
-    return pMirrorOf != nullptr;
+    return m_mirrorOf != nullptr;
 }
 
 bool CMonitor::matchesStaticSelector(const std::string& selector) const {
@@ -911,10 +911,10 @@ bool CMonitor::matchesStaticSelector(const std::string& selector) const {
         // match by description
         const auto DESCRIPTIONSELECTOR = trim(selector.substr(5));
 
-        return szDescription.starts_with(DESCRIPTIONSELECTOR) || szShortDescription.starts_with(DESCRIPTIONSELECTOR);
+        return m_description.starts_with(DESCRIPTIONSELECTOR) || m_shortDescription.starts_with(DESCRIPTIONSELECTOR);
     } else {
         // match by selector
-        return szName == selector;
+        return m_name == selector;
     }
 }
 
@@ -923,7 +923,7 @@ WORKSPACEID CMonitor::findAvailableDefaultWS() {
         if (g_pCompositor->getWorkspaceByID(i))
             continue;
 
-        if (const auto BOUND = g_pConfigManager->getBoundMonitorStringForWS(std::to_string(i)); !BOUND.empty() && BOUND != szName)
+        if (const auto BOUND = g_pConfigManager->getBoundMonitorStringForWS(std::to_string(i)); !BOUND.empty() && BOUND != m_name)
             continue;
 
         return i;
@@ -936,10 +936,10 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
     // Workspace
     std::string newDefaultWorkspaceName = "";
     int64_t     wsID                    = WORKSPACE_INVALID;
-    if (g_pConfigManager->getDefaultWorkspaceFor(szName).empty())
+    if (g_pConfigManager->getDefaultWorkspaceFor(m_name).empty())
         wsID = findAvailableDefaultWS();
     else {
-        const auto ws           = getWorkspaceIDNameFromString(g_pConfigManager->getDefaultWorkspaceFor(szName));
+        const auto ws           = getWorkspaceIDNameFromString(g_pConfigManager->getDefaultWorkspaceFor(m_name));
         wsID                    = ws.id;
         newDefaultWorkspaceName = ws.name;
     }
@@ -948,7 +948,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
         wsID                    = g_pCompositor->m_workspaces.size() + 1;
         newDefaultWorkspaceName = std::to_string(wsID);
 
-        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"{}\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(szName));
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"{}\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(m_name));
     }
 
     auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(wsID);
@@ -957,18 +957,18 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
 
     if (PNEWWORKSPACE) {
         // workspace exists, move it to the newly connected monitor
-        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, self.lock());
-        activeWorkspace = PNEWWORKSPACE;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, m_self.lock());
+        m_activeWorkspace = PNEWWORKSPACE;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
         PNEWWORKSPACE->startAnim(true, true, true);
     } else {
         if (newDefaultWorkspaceName == "")
             newDefaultWorkspaceName = std::to_string(wsID);
 
-        PNEWWORKSPACE = g_pCompositor->m_workspaces.emplace_back(CWorkspace::create(wsID, self.lock(), newDefaultWorkspaceName));
+        PNEWWORKSPACE = g_pCompositor->m_workspaces.emplace_back(CWorkspace::create(wsID, m_self.lock(), newDefaultWorkspaceName));
     }
 
-    activeWorkspace = PNEWWORKSPACE;
+    m_activeWorkspace = PNEWWORKSPACE;
 
     PNEWWORKSPACE->setActive(true);
     PNEWWORKSPACE->m_visible     = true;
@@ -978,7 +978,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
 void CMonitor::setMirror(const std::string& mirrorOf) {
     const auto PMIRRORMON = g_pCompositor->getMonitorFromString(mirrorOf);
 
-    if (PMIRRORMON == pMirrorOf)
+    if (PMIRRORMON == m_mirrorOf)
         return;
 
     if (PMIRRORMON && PMIRRORMON->isMirror()) {
@@ -986,7 +986,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         return;
     }
 
-    if (PMIRRORMON == self) {
+    if (PMIRRORMON == m_self) {
         Debug::log(ERR, "Cannot mirror self!");
         return;
     }
@@ -994,19 +994,19 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
     if (!PMIRRORMON) {
         // disable mirroring
 
-        if (pMirrorOf) {
-            pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == self; }));
+        if (m_mirrorOf) {
+            m_mirrorOf->m_mirrors.erase(std::find_if(m_mirrorOf->m_mirrors.begin(), m_mirrorOf->m_mirrors.end(), [&](const auto& other) { return other == m_self; }));
 
             // unlock software for mirrored monitor
-            g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf.lock());
+            g_pPointerManager->unlockSoftwareForMonitor(m_mirrorOf.lock());
         }
 
-        pMirrorOf.reset();
+        m_mirrorOf.reset();
 
         // set rule
-        const auto RULE = g_pConfigManager->getMonitorRuleFor(self.lock());
+        const auto RULE = g_pConfigManager->getMonitorRuleFor(m_self.lock());
 
-        vecPosition = RULE.offset;
+        m_position = RULE.offset;
 
         // push to mvmonitors
 
@@ -1014,7 +1014,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
 
         // find the wrap
         for (auto& m : g_pCompositor->m_realMonitors) {
-            if (m->ID == ID) {
+            if (m->m_id == m_id) {
                 thisWrapper = &m;
                 break;
             }
@@ -1041,7 +1041,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         // move all the WS
         std::vector<PHLWORKSPACE> wspToMove;
         for (auto const& w : g_pCompositor->m_workspaces) {
-            if (w->m_monitor == self || !w->m_monitor)
+            if (w->m_monitor == m_self || !w->m_monitor)
                 wspToMove.push_back(w);
         }
 
@@ -1050,16 +1050,16 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
             w->startAnim(true, true, true);
         }
 
-        activeWorkspace.reset();
+        m_activeWorkspace.reset();
 
-        vecPosition = PMIRRORMON->vecPosition;
+        m_position = PMIRRORMON->m_position;
 
-        pMirrorOf = PMIRRORMON;
+        m_mirrorOf = PMIRRORMON;
 
-        pMirrorOf->mirrors.push_back(self);
+        m_mirrorOf->m_mirrors.push_back(m_self);
 
         // remove from mvmonitors
-        std::erase_if(g_pCompositor->m_monitors, [&](const auto& other) { return other == self; });
+        std::erase_if(g_pCompositor->m_monitors, [&](const auto& other) { return other == m_self; });
 
         g_pCompositor->arrangeMonitors();
 
@@ -1071,17 +1071,17 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         g_pPointerManager->lockSoftwareForMonitor(PMIRRORMON);
     }
 
-    events.modeChanged.emit();
+    m_events.modeChanged.emit();
 }
 
 float CMonitor::getDefaultScale() {
-    if (!m_bEnabled)
+    if (!m_enabled)
         return 1;
 
     static constexpr double MMPERINCH = 25.4;
 
-    const auto              DIAGONALPX = sqrt(pow(vecPixelSize.x, 2) + pow(vecPixelSize.y, 2));
-    const auto              DIAGONALIN = sqrt(pow(output->physicalSize.x / MMPERINCH, 2) + pow(output->physicalSize.y / MMPERINCH, 2));
+    const auto              DIAGONALPX = sqrt(pow(m_pixelSize.x, 2) + pow(m_pixelSize.y, 2));
+    const auto              DIAGONALIN = sqrt(pow(m_output->physicalSize.x / MMPERINCH, 2) + pow(m_output->physicalSize.y / MMPERINCH, 2));
 
     const auto              PPI = DIAGONALPX / DIAGONALIN;
 
@@ -1097,22 +1097,22 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         return;
 
     if (pWorkspace->m_isSpecialWorkspace) {
-        if (activeSpecialWorkspace != pWorkspace) {
+        if (m_activeSpecialWorkspace != pWorkspace) {
             Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id {}", pWorkspace->m_id);
             setSpecialWorkspace(pWorkspace);
         }
         return;
     }
 
-    if (pWorkspace == activeWorkspace)
+    if (pWorkspace == m_activeWorkspace)
         return;
 
-    const auto POLDWORKSPACE = activeWorkspace;
+    const auto POLDWORKSPACE = m_activeWorkspace;
     if (POLDWORKSPACE)
         POLDWORKSPACE->m_visible = false;
     pWorkspace->m_visible = true;
 
-    activeWorkspace = pWorkspace;
+    m_activeWorkspace = pWorkspace;
 
     if (!internal) {
         const auto ANIMTOLEFT = POLDWORKSPACE && pWorkspace->m_id > POLDWORKSPACE->m_id;
@@ -1126,8 +1126,8 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
                 w->moveToWorkspace(pWorkspace);
         }
 
-        if (!noFocus && !g_pCompositor->m_lastMonitor->activeSpecialWorkspace &&
-            !(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == self)) {
+        if (!noFocus && !g_pCompositor->m_lastMonitor->m_activeSpecialWorkspace &&
+            !(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == m_self)) {
             static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
             auto        pWindow      = pWorkspace->m_hasFullscreenWindow ? pWorkspace->getFullscreenWindow() : pWorkspace->getLastFocusedWindow();
 
@@ -1148,23 +1148,23 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         if (!noMouseMove)
             g_pInputManager->simulateMouseMovement();
 
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
         g_pEventManager->postEvent(SHyprIPCEvent{"workspace", pWorkspace->m_name});
         g_pEventManager->postEvent(SHyprIPCEvent{"workspacev2", std::format("{},{}", pWorkspace->m_id, pWorkspace->m_name)});
         EMIT_HOOK_EVENT("workspace", pWorkspace);
     }
 
-    g_pHyprRenderer->damageMonitor(self.lock());
+    g_pHyprRenderer->damageMonitor(m_self.lock());
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
 
-    g_pConfigManager->ensureVRR(self.lock());
+    g_pConfigManager->ensureVRR(m_self.lock());
 
     g_pCompositor->updateSuspendedStates();
 
-    if (activeSpecialWorkspace)
-        g_pCompositor->updateFullscreenFadeOnWorkspace(activeSpecialWorkspace);
+    if (m_activeSpecialWorkspace)
+        g_pCompositor->updateFullscreenFadeOnWorkspace(m_activeSpecialWorkspace);
 }
 
 void CMonitor::changeWorkspace(const WORKSPACEID& id, bool internal, bool noMouseMove, bool noFocus) {
@@ -1172,83 +1172,83 @@ void CMonitor::changeWorkspace(const WORKSPACEID& id, bool internal, bool noMous
 }
 
 void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
-    if (activeSpecialWorkspace == pWorkspace)
+    if (m_activeSpecialWorkspace == pWorkspace)
         return;
 
-    g_pHyprRenderer->damageMonitor(self.lock());
+    g_pHyprRenderer->damageMonitor(m_self.lock());
 
     if (!pWorkspace) {
         // remove special if exists
-        if (activeSpecialWorkspace) {
-            activeSpecialWorkspace->m_visible = false;
-            activeSpecialWorkspace->startAnim(false, false);
-            g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + szName});
-            g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + szName});
+        if (m_activeSpecialWorkspace) {
+            m_activeSpecialWorkspace->m_visible = false;
+            m_activeSpecialWorkspace->startAnim(false, false);
+            g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + m_name});
+            g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + m_name});
         }
-        activeSpecialWorkspace.reset();
+        m_activeSpecialWorkspace.reset();
 
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
-        if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == self)) {
-            if (const auto PLAST = activeWorkspace->getLastFocusedWindow(); PLAST)
+        if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == m_self)) {
+            if (const auto PLAST = m_activeWorkspace->getLastFocusedWindow(); PLAST)
                 g_pCompositor->focusWindow(PLAST);
             else
                 g_pInputManager->refocus();
         }
 
-        g_pCompositor->updateFullscreenFadeOnWorkspace(activeWorkspace);
+        g_pCompositor->updateFullscreenFadeOnWorkspace(m_activeWorkspace);
 
-        g_pConfigManager->ensureVRR(self.lock());
+        g_pConfigManager->ensureVRR(m_self.lock());
 
         g_pCompositor->updateSuspendedStates();
 
         return;
     }
 
-    if (activeSpecialWorkspace) {
-        activeSpecialWorkspace->m_visible = false;
-        activeSpecialWorkspace->startAnim(false, false);
+    if (m_activeSpecialWorkspace) {
+        m_activeSpecialWorkspace->m_visible = false;
+        m_activeSpecialWorkspace->startAnim(false, false);
     }
 
     bool animate = true;
     //close if open elsewhere
     const auto PMONITORWORKSPACEOWNER = pWorkspace->m_monitor.lock();
-    if (const auto PMWSOWNER = pWorkspace->m_monitor.lock(); PMWSOWNER && PMWSOWNER->activeSpecialWorkspace == pWorkspace) {
-        PMWSOWNER->activeSpecialWorkspace.reset();
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMWSOWNER->ID);
-        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMWSOWNER->szName});
-        g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + PMWSOWNER->szName});
+    if (const auto PMWSOWNER = pWorkspace->m_monitor.lock(); PMWSOWNER && PMWSOWNER->m_activeSpecialWorkspace == pWorkspace) {
+        PMWSOWNER->m_activeSpecialWorkspace.reset();
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMWSOWNER->m_id);
+        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMWSOWNER->m_name});
+        g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + PMWSOWNER->m_name});
 
-        const auto PACTIVEWORKSPACE = PMWSOWNER->activeWorkspace;
+        const auto PACTIVEWORKSPACE = PMWSOWNER->m_activeWorkspace;
         g_pCompositor->updateFullscreenFadeOnWorkspace(PACTIVEWORKSPACE);
 
         animate = false;
     }
 
     // open special
-    pWorkspace->m_monitor             = self;
-    activeSpecialWorkspace            = pWorkspace;
-    activeSpecialWorkspace->m_visible = true;
+    pWorkspace->m_monitor               = m_self;
+    m_activeSpecialWorkspace            = pWorkspace;
+    m_activeSpecialWorkspace->m_visible = true;
     if (animate)
         pWorkspace->startAnim(true, true);
 
     for (auto const& w : g_pCompositor->m_windows) {
         if (w->m_workspace == pWorkspace) {
-            w->m_monitor = self;
+            w->m_monitor = m_self;
             w->updateSurfaceScaleTransformDetails();
             w->setAnimationsToMove();
 
             const auto MIDDLE = w->middle();
-            if (w->m_isFloating && !VECINRECT(MIDDLE, vecPosition.x, vecPosition.y, vecPosition.x + vecSize.x, vecPosition.y + vecSize.y) && !w->isX11OverrideRedirect()) {
+            if (w->m_isFloating && !VECINRECT(MIDDLE, m_position.x, m_position.y, m_position.x + m_size.x, m_position.y + m_size.y) && !w->isX11OverrideRedirect()) {
                 // if it's floating and the middle isnt on the current mon, move it to the center
                 const auto PMONFROMMIDDLE = g_pCompositor->getMonitorFromVector(MIDDLE);
                 Vector2D   pos            = w->m_realPosition->goal();
-                if (!VECINRECT(MIDDLE, PMONFROMMIDDLE->vecPosition.x, PMONFROMMIDDLE->vecPosition.y, PMONFROMMIDDLE->vecPosition.x + PMONFROMMIDDLE->vecSize.x,
-                               PMONFROMMIDDLE->vecPosition.y + PMONFROMMIDDLE->vecSize.y)) {
+                if (!VECINRECT(MIDDLE, PMONFROMMIDDLE->m_position.x, PMONFROMMIDDLE->m_position.y, PMONFROMMIDDLE->m_position.x + PMONFROMMIDDLE->m_size.x,
+                               PMONFROMMIDDLE->m_position.y + PMONFROMMIDDLE->m_size.y)) {
                     // not on any monitor, center
                     pos = middle() / 2.f - w->m_realSize->goal() / 2.f;
                 } else
-                    pos = pos - PMONFROMMIDDLE->vecPosition + vecPosition;
+                    pos = pos - PMONFROMMIDDLE->m_position + m_position;
 
                 *w->m_realPosition = pos;
                 w->m_position      = pos;
@@ -1256,23 +1256,23 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
         }
     }
 
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
-    if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == self)) {
+    if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == m_self)) {
         if (const auto PLAST = pWorkspace->getLastFocusedWindow(); PLAST)
             g_pCompositor->focusWindow(PLAST);
         else
             g_pInputManager->refocus();
     }
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_name + "," + szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_id) + "," + pWorkspace->m_name + "," + szName});
+    g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_name + "," + m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_id) + "," + pWorkspace->m_name + "," + m_name});
 
-    g_pHyprRenderer->damageMonitor(self.lock());
+    g_pHyprRenderer->damageMonitor(m_self.lock());
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
 
-    g_pConfigManager->ensureVRR(self.lock());
+    g_pConfigManager->ensureVRR(m_self.lock());
 
     g_pCompositor->updateSuspendedStates();
 }
@@ -1282,19 +1282,19 @@ void CMonitor::setSpecialWorkspace(const WORKSPACEID& id) {
 }
 
 void CMonitor::moveTo(const Vector2D& pos) {
-    vecPosition = pos;
+    m_position = pos;
 }
 
 SWorkspaceIDName CMonitor::getPrevWorkspaceIDName(const WORKSPACEID id) {
-    while (!prevWorkSpaces.empty()) {
-        const int PREVID = prevWorkSpaces.top();
-        prevWorkSpaces.pop();
+    while (!m_prevWorkSpaces.empty()) {
+        const int PREVID = m_prevWorkSpaces.top();
+        m_prevWorkSpaces.pop();
         if (PREVID == id) // skip same workspace
             continue;
 
         // recheck if previous workspace's was moved to another monitor
         const auto ws = g_pCompositor->getWorkspaceByID(PREVID);
-        if (ws && ws->monitorID() == ID)
+        if (ws && ws->monitorID() == m_id)
             return {.id = PREVID, .name = ws->m_name};
     }
 
@@ -1302,66 +1302,66 @@ SWorkspaceIDName CMonitor::getPrevWorkspaceIDName(const WORKSPACEID id) {
 }
 
 void CMonitor::addPrevWorkspaceID(const WORKSPACEID id) {
-    if (!prevWorkSpaces.empty() && prevWorkSpaces.top() == id)
+    if (!m_prevWorkSpaces.empty() && m_prevWorkSpaces.top() == id)
         return;
 
-    prevWorkSpaces.emplace(id);
+    m_prevWorkSpaces.emplace(id);
 }
 
 Vector2D CMonitor::middle() {
-    return vecPosition + vecSize / 2.f;
+    return m_position + m_size / 2.f;
 }
 
 void CMonitor::updateMatrix() {
-    projMatrix = Mat3x3::identity();
-    if (transform != WL_OUTPUT_TRANSFORM_NORMAL)
-        projMatrix.translate(vecPixelSize / 2.0).transform(wlTransformToHyprutils(transform)).translate(-vecTransformedSize / 2.0);
+    m_projMatrix = Mat3x3::identity();
+    if (m_transform != WL_OUTPUT_TRANSFORM_NORMAL)
+        m_projMatrix.translate(m_pixelSize / 2.0).transform(wlTransformToHyprutils(m_transform)).translate(-m_transformedSize / 2.0);
 }
 
 WORKSPACEID CMonitor::activeWorkspaceID() {
-    return activeWorkspace ? activeWorkspace->m_id : 0;
+    return m_activeWorkspace ? m_activeWorkspace->m_id : 0;
 }
 
 WORKSPACEID CMonitor::activeSpecialWorkspaceID() {
-    return activeSpecialWorkspace ? activeSpecialWorkspace->m_id : 0;
+    return m_activeSpecialWorkspace ? m_activeSpecialWorkspace->m_id : 0;
 }
 
 CBox CMonitor::logicalBox() {
-    return {vecPosition, vecSize};
+    return {m_position, m_size};
 }
 
 void CMonitor::scheduleDone() {
-    if (doneScheduled)
+    if (m_doneScheduled)
         return;
 
-    doneScheduled = true;
+    m_doneScheduled = true;
 
-    g_pEventLoopManager->doLater([M = self] {
+    g_pEventLoopManager->doLater([M = m_self] {
         if (!M) // if M is gone, we got destroyed, doesn't matter.
             return;
 
-        if (!PROTO::outputs.contains(M->szName))
+        if (!PROTO::outputs.contains(M->m_name))
             return;
 
-        PROTO::outputs.at(M->szName)->sendDone();
-        M->doneScheduled = false;
+        PROTO::outputs.at(M->m_name)->sendDone();
+        M->m_doneScheduled = false;
     });
 }
 
 void CMonitor::setCTM(const Mat3x3& ctm_) {
-    ctm        = ctm_;
-    ctmUpdated = true;
-    g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::scheduleFrameReason::AQ_SCHEDULE_NEEDS_FRAME);
+    m_ctm        = ctm_;
+    m_ctmUpdated = true;
+    g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::scheduleFrameReason::AQ_SCHEDULE_NEEDS_FRAME);
 }
 
 bool CMonitor::attemptDirectScanout() {
-    if (!mirrors.empty() || isMirror() || g_pHyprRenderer->m_bDirectScanoutBlocked)
+    if (!m_mirrors.empty() || isMirror() || g_pHyprRenderer->m_bDirectScanoutBlocked)
         return false; // do not DS if this monitor is being mirrored. Will break the functionality.
 
-    if (g_pPointerManager->softwareLockedFor(self.lock()))
+    if (g_pPointerManager->softwareLockedFor(m_self.lock()))
         return false;
 
-    const auto PCANDIDATE = solitaryClient.lock();
+    const auto PCANDIDATE = m_solitaryClient.lock();
 
     if (!PCANDIDATE)
         return false;
@@ -1371,7 +1371,7 @@ bool CMonitor::attemptDirectScanout() {
     if (!PSURFACE || !PSURFACE->current.texture || !PSURFACE->current.buffer)
         return false;
 
-    if (PSURFACE->current.bufferSize != vecPixelSize || PSURFACE->current.transform != transform)
+    if (PSURFACE->current.bufferSize != m_pixelSize || PSURFACE->current.transform != m_transform)
         return false;
 
     // we can't scanout shm buffers.
@@ -1383,22 +1383,22 @@ bool CMonitor::attemptDirectScanout() {
 
     auto PBUFFER = PSURFACE->current.buffer.buffer;
 
-    if (PBUFFER == output->state->state().buffer) {
-        PSURFACE->presentFeedback(Time::steadyNow(), self.lock());
+    if (PBUFFER == m_output->state->state().buffer) {
+        PSURFACE->presentFeedback(Time::steadyNow(), m_self.lock());
 
-        if (scanoutNeedsCursorUpdate) {
-            if (!state.test()) {
+        if (m_scanoutNeedsCursorUpdate) {
+            if (!m_state.test()) {
                 Debug::log(TRACE, "attemptDirectScanout: failed basic test");
                 return false;
             }
 
-            if (!output->commit()) {
+            if (!m_output->commit()) {
                 Debug::log(TRACE, "attemptDirectScanout: failed to commit cursor update");
-                lastScanout.reset();
+                m_lastScanout.reset();
                 return false;
             }
 
-            scanoutNeedsCursorUpdate = false;
+            m_scanoutNeedsCursorUpdate = false;
         }
 
         return true;
@@ -1408,44 +1408,44 @@ bool CMonitor::attemptDirectScanout() {
     // and comes from the appropriate device. This may implode on multi-gpu!!
 
     // entering into scanout, so save monitor format
-    if (lastScanout.expired())
-        prevDrmFormat = drmFormat;
+    if (m_lastScanout.expired())
+        m_prevDrmFormat = m_drmFormat;
 
-    if (drmFormat != params.format) {
-        output->state->setFormat(params.format);
-        drmFormat = params.format;
+    if (m_drmFormat != params.format) {
+        m_output->state->setFormat(params.format);
+        m_drmFormat = params.format;
     }
 
-    output->state->setBuffer(PBUFFER);
-    output->state->setPresentationMode(tearingState.activelyTearing ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
-                                                                      Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
+    m_output->state->setBuffer(PBUFFER);
+    m_output->state->setPresentationMode(m_tearingState.activelyTearing ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
+                                                                          Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
 
-    if (!state.test()) {
+    if (!m_state.test()) {
         Debug::log(TRACE, "attemptDirectScanout: failed basic test");
         return false;
     }
 
-    PSURFACE->presentFeedback(Time::steadyNow(), self.lock());
+    PSURFACE->presentFeedback(Time::steadyNow(), m_self.lock());
 
-    output->state->addDamage(PSURFACE->current.accumulateBufferDamage());
-    output->state->resetExplicitFences();
+    m_output->state->addDamage(PSURFACE->current.accumulateBufferDamage());
+    m_output->state->resetExplicitFences();
 
     // no need to do explicit sync here as surface current can only ever be ready to read
 
-    bool ok = output->commit();
+    bool ok = m_output->commit();
 
     if (!ok) {
         Debug::log(TRACE, "attemptDirectScanout: failed to scanout surface");
-        lastScanout.reset();
+        m_lastScanout.reset();
         return false;
     }
 
-    if (lastScanout.expired()) {
-        lastScanout = PCANDIDATE;
+    if (m_lastScanout.expired()) {
+        m_lastScanout = PCANDIDATE;
         Debug::log(LOG, "Entered a direct scanout to {:x}: \"{}\"", (uintptr_t)PCANDIDATE.get(), PCANDIDATE->m_title);
     }
 
-    scanoutNeedsCursorUpdate = false;
+    m_scanoutNeedsCursorUpdate = false;
 
     if (!PBUFFER->lockedByBackend || PBUFFER->hlEvents.backendRelease)
         return true;
@@ -1459,16 +1459,17 @@ bool CMonitor::attemptDirectScanout() {
 }
 
 void CMonitor::debugLastPresentation(const std::string& message) {
-    Debug::log(TRACE, "{} (last presentation {} - {} fps)", message, lastPresentationTimer.getMillis(),
-               lastPresentationTimer.getMillis() > 0 ? 1000.0f / lastPresentationTimer.getMillis() : 0.0f);
+    Debug::log(TRACE, "{} (last presentation {} - {} fps)", message, m_lastPresentationTimer.getMillis(),
+               m_lastPresentationTimer.getMillis() > 0 ? 1000.0f / m_lastPresentationTimer.getMillis() : 0.0f);
 }
 
 void CMonitor::onMonitorFrame() {
     if ((g_pCompositor->m_aqBackend->hasSession() && !g_pCompositor->m_aqBackend->session->active) || !g_pCompositor->m_sessionActive || g_pCompositor->m_unsafeState) {
         Debug::log(WARN, "Attempted to render frame on inactive session!");
 
-        if (g_pCompositor->m_unsafeState &&
-            std::ranges::any_of(g_pCompositor->m_monitors.begin(), g_pCompositor->m_monitors.end(), [&](auto& m) { return m->output != g_pCompositor->m_unsafeOutput->output; })) {
+        if (g_pCompositor->m_unsafeState && std::ranges::any_of(g_pCompositor->m_monitors.begin(), g_pCompositor->m_monitors.end(), [&](auto& m) {
+                return m->m_output != g_pCompositor->m_unsafeOutput->m_output;
+            })) {
             // restore from unsafe state
             g_pCompositor->leaveUnsafeState();
         }
@@ -1476,57 +1477,57 @@ void CMonitor::onMonitorFrame() {
         return; // cannot draw on session inactive (different tty)
     }
 
-    if (!m_bEnabled)
+    if (!m_enabled)
         return;
 
-    g_pHyprRenderer->recheckSolitaryForMonitor(self.lock());
+    g_pHyprRenderer->recheckSolitaryForMonitor(m_self.lock());
 
-    tearingState.busy = false;
+    m_tearingState.busy = false;
 
-    if (tearingState.activelyTearing && solitaryClient.lock() /* can be invalidated by a recheck */) {
+    if (m_tearingState.activelyTearing && m_solitaryClient.lock() /* can be invalidated by a recheck */) {
 
-        if (!tearingState.frameScheduledWhileBusy)
+        if (!m_tearingState.frameScheduledWhileBusy)
             return; // we did not schedule a frame yet to be displayed, but we are tearing. Why render?
 
-        tearingState.nextRenderTorn          = true;
-        tearingState.frameScheduledWhileBusy = false;
+        m_tearingState.nextRenderTorn          = true;
+        m_tearingState.frameScheduledWhileBusy = false;
     }
 
     static auto PENABLERAT = CConfigValue<Hyprlang::INT>("misc:render_ahead_of_time");
     static auto PRATSAFE   = CConfigValue<Hyprlang::INT>("misc:render_ahead_safezone");
 
-    lastPresentationTimer.reset();
+    m_lastPresentationTimer.reset();
 
-    if (*PENABLERAT && !tearingState.nextRenderTorn) {
-        if (!RATScheduled) {
+    if (*PENABLERAT && !m_tearingState.nextRenderTorn) {
+        if (!m_ratsScheduled) {
             // render
-            g_pHyprRenderer->renderMonitor(self.lock());
+            g_pHyprRenderer->renderMonitor(m_self.lock());
         }
 
-        RATScheduled = false;
+        m_ratsScheduled = false;
 
-        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(self.lock());
+        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(m_self.lock());
 
-        if (max + *PRATSAFE > 1000.0 / refreshRate)
+        if (max + *PRATSAFE > 1000.0 / m_refreshRate)
             return;
 
-        const auto MSLEFT = 1000.0 / refreshRate - lastPresentationTimer.getMillis();
+        const auto MSLEFT = (1000.0 / m_refreshRate) - m_lastPresentationTimer.getMillis();
 
-        RATScheduled = true;
+        m_ratsScheduled = true;
 
         const auto ESTRENDERTIME = std::ceil(avg + *PRATSAFE);
         const auto TIMETOSLEEP   = std::floor(MSLEFT - ESTRENDERTIME);
 
         if (MSLEFT < 1 || MSLEFT < ESTRENDERTIME || TIMETOSLEEP < 1)
-            g_pHyprRenderer->renderMonitor(self.lock());
+            g_pHyprRenderer->renderMonitor(m_self.lock());
         else
-            wl_event_source_timer_update(renderTimer, TIMETOSLEEP);
+            wl_event_source_timer_update(m_renderTimer, TIMETOSLEEP);
     } else
-        g_pHyprRenderer->renderMonitor(self.lock());
+        g_pHyprRenderer->renderMonitor(m_self.lock());
 }
 
 void CMonitor::onCursorMovedOnMonitor() {
-    if (!tearingState.activelyTearing || !solitaryClient || !g_pHyprRenderer->shouldRenderCursor())
+    if (!m_tearingState.activelyTearing || !m_solitaryClient || !g_pHyprRenderer->shouldRenderCursor())
         return;
 
     // submit a frame immediately. This will only update the cursor pos.
@@ -1540,41 +1541,41 @@ void CMonitor::onCursorMovedOnMonitor() {
     // and throws a "nO pRoP cAn Be ChAnGeD dUrInG AsYnC fLiP" on crtc_x
     // this will throw too but fix it if we use sw cursors
 
-    tearingState.frameScheduledWhileBusy = true;
+    m_tearingState.frameScheduledWhileBusy = true;
 }
 
-CMonitorState::CMonitorState(CMonitor* owner) : m_pOwner(owner) {
+CMonitorState::CMonitorState(CMonitor* owner) : m_owner(owner) {
     ;
 }
 
 void CMonitorState::ensureBufferPresent() {
-    const auto STATE = m_pOwner->output->state->state();
+    const auto STATE = m_owner->m_output->state->state();
     if (!STATE.enabled) {
         Debug::log(TRACE, "CMonitorState::ensureBufferPresent: Ignoring, monitor is not enabled");
         return;
     }
 
     if (STATE.buffer) {
-        if (const auto params = STATE.buffer->dmabuf(); params.success && params.format == m_pOwner->drmFormat)
+        if (const auto params = STATE.buffer->dmabuf(); params.success && params.format == m_owner->m_drmFormat)
             return;
     }
 
     // this is required for modesetting being possible and might be missing in case of first tests in the renderer
     // where we test modes and buffers
     Debug::log(LOG, "CMonitorState::ensureBufferPresent: no buffer or mismatched format, attaching one from the swapchain for modeset being possible");
-    m_pOwner->output->state->setBuffer(m_pOwner->output->swapchain->next(nullptr));
-    m_pOwner->output->swapchain->rollback(); // restore the counter, don't advance the swapchain
+    m_owner->m_output->state->setBuffer(m_owner->m_output->swapchain->next(nullptr));
+    m_owner->m_output->swapchain->rollback(); // restore the counter, don't advance the swapchain
 }
 
 bool CMonitorState::commit() {
     if (!updateSwapchain())
         return false;
 
-    EMIT_HOOK_EVENT("preMonitorCommit", m_pOwner->self.lock());
+    EMIT_HOOK_EVENT("preMonitorCommit", m_owner->m_self.lock());
 
     ensureBufferPresent();
 
-    bool ret = m_pOwner->output->commit();
+    bool ret = m_owner->m_output->commit();
     return ret;
 }
 
@@ -1584,20 +1585,20 @@ bool CMonitorState::test() {
 
     ensureBufferPresent();
 
-    return m_pOwner->output->test();
+    return m_owner->m_output->test();
 }
 
 bool CMonitorState::updateSwapchain() {
-    auto        options = m_pOwner->output->swapchain->currentOptions();
-    const auto& STATE   = m_pOwner->output->state->state();
+    auto        options = m_owner->m_output->swapchain->currentOptions();
+    const auto& STATE   = m_owner->m_output->state->state();
     const auto& MODE    = STATE.mode ? STATE.mode : STATE.customMode;
     if (!MODE) {
         Debug::log(WARN, "updateSwapchain: No mode?");
         return true;
     }
-    options.format  = m_pOwner->drmFormat;
+    options.format  = m_owner->m_drmFormat;
     options.scanout = true;
     options.length  = 2;
     options.size    = MODE->pixelSize;
-    return m_pOwner->output->swapchain->reconfigure(options);
+    return m_owner->m_output->swapchain->reconfigure(options);
 }
diff --git a/src/helpers/Monitor.hpp b/src/helpers/Monitor.hpp
index 88252ab4..31777b0c 100644
--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -71,7 +71,7 @@ class CMonitorState {
   private:
     void      ensureBufferPresent();
 
-    CMonitor* m_pOwner = nullptr;
+    CMonitor* m_owner = nullptr;
 };
 
 class CMonitor {
@@ -79,84 +79,82 @@ class CMonitor {
     CMonitor(SP<Aquamarine::IOutput> output);
     ~CMonitor();
 
-    Vector2D                    vecPosition         = Vector2D(-1, -1); // means unset
-    Vector2D                    vecXWaylandPosition = Vector2D(-1, -1); // means unset
-    Vector2D                    vecSize             = Vector2D(0, 0);
-    Vector2D                    vecPixelSize        = Vector2D(0, 0);
-    Vector2D                    vecTransformedSize  = Vector2D(0, 0);
-
-    bool                        primary = false;
-
-    MONITORID                   ID                     = MONITOR_INVALID;
-    PHLWORKSPACE                activeWorkspace        = nullptr;
-    PHLWORKSPACE                activeSpecialWorkspace = nullptr;
-    float                       setScale               = 1; // scale set by cfg
-    float                       scale                  = 1; // real scale
-
-    std::string                 szName             = "";
-    std::string                 szDescription      = "";
-    std::string                 szShortDescription = "";
-
-    Vector2D                    vecReservedTopLeft     = Vector2D(0, 0);
-    Vector2D                    vecReservedBottomRight = Vector2D(0, 0);
-
-    drmModeModeInfo             customDrmMode = {};
-
-    CMonitorState               state;
-    CDamageRing                 damage;
-
-    SP<Aquamarine::IOutput>     output;
-    float                       refreshRate     = 60; // Hz
-    int                         forceFullFrames = 0;
-    bool                        scheduledRecalc = false;
-    wl_output_transform         transform       = WL_OUTPUT_TRANSFORM_NORMAL;
-    float                       xwaylandScale   = 1.f;
-    Mat3x3                      projMatrix;
-    std::optional<Vector2D>     forceSize;
-    SP<Aquamarine::SOutputMode> currentMode;
-    SP<Aquamarine::CSwapchain>  cursorSwapchain;
-    uint32_t                    drmFormat     = DRM_FORMAT_INVALID;
-    uint32_t                    prevDrmFormat = DRM_FORMAT_INVALID;
-
-    bool                        dpmsStatus       = true;
-    bool                        vrrActive        = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
-    bool                        enabled10bit     = false; // as above, this can be TRUE even if 10 bit failed.
-    eCMType                     cmType           = CM_SRGB;
-    float                       sdrSaturation    = 1.0f;
-    float                       sdrBrightness    = 1.0f;
-    bool                        createdByUser    = false;
-    bool                        isUnsafeFallback = false;
-
-    bool                        pendingFrame    = false; // if we schedule a frame during rendering, reschedule it after
-    bool                        renderingActive = false;
-
-    wl_event_source*            renderTimer  = nullptr; // for RAT
-    bool                        RATScheduled = false;
-    CTimer                      lastPresentationTimer;
-
-    bool                        isBeingLeased = false;
-
-    SMonitorRule                activeMonitorRule;
+    Vector2D                    m_position         = Vector2D(-1, -1); // means unset
+    Vector2D                    m_xwaylandPosition = Vector2D(-1, -1); // means unset
+    Vector2D                    m_size             = Vector2D(0, 0);
+    Vector2D                    m_pixelSize        = Vector2D(0, 0);
+    Vector2D                    m_transformedSize  = Vector2D(0, 0);
+
+    MONITORID                   m_id                     = MONITOR_INVALID;
+    PHLWORKSPACE                m_activeWorkspace        = nullptr;
+    PHLWORKSPACE                m_activeSpecialWorkspace = nullptr;
+    float                       m_setScale               = 1; // scale set by cfg
+    float                       m_scale                  = 1; // real scale
+
+    std::string                 m_name             = "";
+    std::string                 m_description      = "";
+    std::string                 m_shortDescription = "";
+
+    Vector2D                    m_reservedTopLeft     = Vector2D(0, 0);
+    Vector2D                    m_reservedBottomRight = Vector2D(0, 0);
+
+    drmModeModeInfo             m_customDrmMode = {};
+
+    CMonitorState               m_state;
+    CDamageRing                 m_damage;
+
+    SP<Aquamarine::IOutput>     m_output;
+    float                       m_refreshRate     = 60; // Hz
+    int                         m_forceFullFrames = 0;
+    bool                        m_scheduledRecalc = false;
+    wl_output_transform         m_transform       = WL_OUTPUT_TRANSFORM_NORMAL;
+    float                       m_xwaylandScale   = 1.f;
+    Mat3x3                      m_projMatrix;
+    std::optional<Vector2D>     m_forceSize;
+    SP<Aquamarine::SOutputMode> m_currentMode;
+    SP<Aquamarine::CSwapchain>  m_cursorSwapchain;
+    uint32_t                    m_drmFormat     = DRM_FORMAT_INVALID;
+    uint32_t                    m_prevDrmFormat = DRM_FORMAT_INVALID;
+
+    bool                        m_dpmsStatus       = true;
+    bool                        m_vrrActive        = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
+    bool                        m_enabled10bit     = false; // as above, this can be TRUE even if 10 bit failed.
+    eCMType                     m_cmType           = CM_SRGB;
+    float                       m_sdrSaturation    = 1.0f;
+    float                       m_sdrBrightness    = 1.0f;
+    bool                        m_createdByUser    = false;
+    bool                        m_isUnsafeFallback = false;
+
+    bool                        m_pendingFrame    = false; // if we schedule a frame during rendering, reschedule it after
+    bool                        m_renderingActive = false;
+
+    wl_event_source*            m_renderTimer   = nullptr; // for RAT
+    bool                        m_ratsScheduled = false;
+    CTimer                      m_lastPresentationTimer;
+
+    bool                        m_isBeingLeased = false;
+
+    SMonitorRule                m_activeMonitorRule;
 
     // explicit sync
-    Hyprutils::OS::CFileDescriptor inFence; // TODO: remove when aq uses CFileDescriptor
+    Hyprutils::OS::CFileDescriptor m_inFence; // TODO: remove when aq uses CFileDescriptor
 
-    PHLMONITORREF                  self;
+    PHLMONITORREF                  m_self;
 
     // mirroring
-    PHLMONITORREF              pMirrorOf;
-    std::vector<PHLMONITORREF> mirrors;
+    PHLMONITORREF              m_mirrorOf;
+    std::vector<PHLMONITORREF> m_mirrors;
 
     // ctm
-    Mat3x3 ctm        = Mat3x3::identity();
-    bool   ctmUpdated = false;
+    Mat3x3 m_ctm        = Mat3x3::identity();
+    bool   m_ctmUpdated = false;
 
     // for tearing
-    PHLWINDOWREF solitaryClient;
+    PHLWINDOWREF m_solitaryClient;
 
     // for direct scanout
-    PHLWINDOWREF lastScanout;
-    bool         scanoutNeedsCursorUpdate = false;
+    PHLWINDOWREF m_lastScanout;
+    bool         m_scanoutNeedsCursorUpdate = false;
 
     struct {
         bool canTear         = false;
@@ -165,7 +163,7 @@ class CMonitor {
 
         bool busy                    = false;
         bool frameScheduledWhileBusy = false;
-    } tearingState;
+    } m_tearingState;
 
     struct {
         CSignal destroy;
@@ -173,9 +171,9 @@ class CMonitor {
         CSignal disconnect;
         CSignal dpmsChanged;
         CSignal modeChanged;
-    } events;
+    } m_events;
 
-    std::array<std::vector<PHLLSREF>, 4> m_aLayerSurfaceLayers;
+    std::array<std::vector<PHLLSREF>, 4> m_layerSurfaceLayers;
 
     // methods
     void                                onConnect(bool noRule);
@@ -207,15 +205,15 @@ class CMonitor {
     void                                debugLastPresentation(const std::string& message);
     void                                onMonitorFrame();
 
-    bool                                m_bEnabled             = false;
-    bool                                m_bRenderingInitPassed = false;
+    bool                                m_enabled             = false;
+    bool                                m_renderingInitPassed = false;
     WP<CWindow>                         m_previousFSWindow;
-    NColorManagement::SImageDescription imageDescription;
+    NColorManagement::SImageDescription m_imageDescription;
 
     // For the list lookup
 
     bool operator==(const CMonitor& rhs) {
-        return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName;
+        return m_position == rhs.m_position && m_size == rhs.m_size && m_name == rhs.m_name;
     }
 
     // workspace previous per monitor functionality
@@ -226,8 +224,8 @@ class CMonitor {
     void                    setupDefaultWS(const SMonitorRule&);
     WORKSPACEID             findAvailableDefaultWS();
 
-    bool                    doneScheduled = false;
-    std::stack<WORKSPACEID> prevWorkSpaces;
+    bool                    m_doneScheduled = false;
+    std::stack<WORKSPACEID> m_prevWorkSpaces;
 
     struct {
         CHyprSignalListener frame;
@@ -236,5 +234,5 @@ class CMonitor {
         CHyprSignalListener needsFrame;
         CHyprSignalListener presented;
         CHyprSignalListener commit;
-    } listeners;
+    } m_listeners;
 };
diff --git a/src/helpers/sync/SyncTimeline.cpp b/src/helpers/sync/SyncTimeline.cpp
index edb2b190..1b089caa 100644
--- a/src/helpers/sync/SyncTimeline.cpp
+++ b/src/helpers/sync/SyncTimeline.cpp
@@ -7,11 +7,11 @@
 using namespace Hyprutils::OS;
 
 SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) {
-    auto timeline   = SP<CSyncTimeline>(new CSyncTimeline);
-    timeline->drmFD = drmFD_;
-    timeline->self  = timeline;
+    auto timeline     = SP<CSyncTimeline>(new CSyncTimeline);
+    timeline->m_drmFD = drmFD_;
+    timeline->m_self  = timeline;
 
-    if (drmSyncobjCreate(drmFD_, 0, &timeline->handle)) {
+    if (drmSyncobjCreate(drmFD_, 0, &timeline->m_handle)) {
         Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj??");
         return nullptr;
     }
@@ -20,12 +20,12 @@ SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) {
 }
 
 SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobjFD) {
-    auto timeline       = SP<CSyncTimeline>(new CSyncTimeline);
-    timeline->drmFD     = drmFD_;
-    timeline->syncobjFd = std::move(drmSyncobjFD);
-    timeline->self      = timeline;
+    auto timeline         = SP<CSyncTimeline>(new CSyncTimeline);
+    timeline->m_drmFD     = drmFD_;
+    timeline->m_syncobjFD = std::move(drmSyncobjFD);
+    timeline->m_self      = timeline;
 
-    if (drmSyncobjFDToHandle(drmFD_, timeline->syncobjFd.get(), &timeline->handle)) {
+    if (drmSyncobjFDToHandle(drmFD_, timeline->m_syncobjFD.get(), &timeline->m_handle)) {
         Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj from fd??");
         return nullptr;
     }
@@ -34,10 +34,10 @@ SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobj
 }
 
 CSyncTimeline::~CSyncTimeline() {
-    if (handle == 0)
+    if (m_handle == 0)
         return;
 
-    drmSyncobjDestroy(drmFD, handle);
+    drmSyncobjDestroy(m_drmFD, m_handle);
 }
 
 std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) {
@@ -48,7 +48,7 @@ std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) {
 #endif
 
     uint32_t signaled = 0;
-    int      ret      = drmSyncobjTimelineWait(drmFD, &handle, &point, 1, 0, flags, &signaled);
+    int      ret      = drmSyncobjTimelineWait(m_drmFD, &m_handle, &point, 1, 0, flags, &signaled);
     if (ret != 0 && ret != -ETIME_ERR) {
         Debug::log(ERR, "CSyncTimeline::check: drmSyncobjTimelineWait failed");
         return std::nullopt;
@@ -65,7 +65,7 @@ bool CSyncTimeline::addWaiter(const std::function<void()>& waiter, uint64_t poin
         return false;
     }
 
-    if (drmSyncobjEventfd(drmFD, handle, point, eventFd.get(), flags)) {
+    if (drmSyncobjEventfd(m_drmFD, m_handle, point, eventFd.get(), flags)) {
         Debug::log(ERR, "CSyncTimeline::addWaiter: drmSyncobjEventfd failed");
         return false;
     }
@@ -79,58 +79,58 @@ CFileDescriptor CSyncTimeline::exportAsSyncFileFD(uint64_t src) {
     int      sync = -1;
 
     uint32_t syncHandle = 0;
-    if (drmSyncobjCreate(drmFD, 0, &syncHandle)) {
+    if (drmSyncobjCreate(m_drmFD, 0, &syncHandle)) {
         Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjCreate failed");
         return {};
     }
 
-    if (drmSyncobjTransfer(drmFD, syncHandle, 0, handle, src, 0)) {
+    if (drmSyncobjTransfer(m_drmFD, syncHandle, 0, m_handle, src, 0)) {
         Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjTransfer failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return {};
     }
 
-    if (drmSyncobjExportSyncFile(drmFD, syncHandle, &sync)) {
+    if (drmSyncobjExportSyncFile(m_drmFD, syncHandle, &sync)) {
         Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjExportSyncFile failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return {};
     }
 
-    drmSyncobjDestroy(drmFD, syncHandle);
+    drmSyncobjDestroy(m_drmFD, syncHandle);
     return CFileDescriptor{sync};
 }
 
 bool CSyncTimeline::importFromSyncFileFD(uint64_t dst, CFileDescriptor& fd) {
     uint32_t syncHandle = 0;
 
-    if (drmSyncobjCreate(drmFD, 0, &syncHandle)) {
+    if (drmSyncobjCreate(m_drmFD, 0, &syncHandle)) {
         Debug::log(ERR, "importFromSyncFileFD: drmSyncobjCreate failed");
         return false;
     }
 
-    if (drmSyncobjImportSyncFile(drmFD, syncHandle, fd.get())) {
+    if (drmSyncobjImportSyncFile(m_drmFD, syncHandle, fd.get())) {
         Debug::log(ERR, "importFromSyncFileFD: drmSyncobjImportSyncFile failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return false;
     }
 
-    if (drmSyncobjTransfer(drmFD, handle, dst, syncHandle, 0, 0)) {
+    if (drmSyncobjTransfer(m_drmFD, m_handle, dst, syncHandle, 0, 0)) {
         Debug::log(ERR, "importFromSyncFileFD: drmSyncobjTransfer failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return false;
     }
 
-    drmSyncobjDestroy(drmFD, syncHandle);
+    drmSyncobjDestroy(m_drmFD, syncHandle);
     return true;
 }
 
 bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint) {
-    if (drmFD != from->drmFD) {
-        Debug::log(ERR, "CSyncTimeline::transfer: cannot transfer timelines between gpus, {} -> {}", from->drmFD, drmFD);
+    if (m_drmFD != from->m_drmFD) {
+        Debug::log(ERR, "CSyncTimeline::transfer: cannot transfer timelines between gpus, {} -> {}", from->m_drmFD, m_drmFD);
         return false;
     }
 
-    if (drmSyncobjTransfer(drmFD, handle, toPoint, from->handle, fromPoint, 0)) {
+    if (drmSyncobjTransfer(m_drmFD, m_handle, toPoint, from->m_handle, fromPoint, 0)) {
         Debug::log(ERR, "CSyncTimeline::transfer: drmSyncobjTransfer failed");
         return false;
     }
@@ -139,6 +139,6 @@ bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_
 }
 
 void CSyncTimeline::signal(uint64_t point) {
-    if (drmSyncobjTimelineSignal(drmFD, &handle, &point, 1))
+    if (drmSyncobjTimelineSignal(m_drmFD, &m_handle, &point, 1))
         Debug::log(ERR, "CSyncTimeline::signal: drmSyncobjTimelineSignal failed");
 }
diff --git a/src/helpers/sync/SyncTimeline.hpp b/src/helpers/sync/SyncTimeline.hpp
index 51012c85..37d5b301 100644
--- a/src/helpers/sync/SyncTimeline.hpp
+++ b/src/helpers/sync/SyncTimeline.hpp
@@ -31,10 +31,10 @@ class CSyncTimeline {
     bool                           transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint);
     void                           signal(uint64_t point);
 
-    int                            drmFD = -1;
-    Hyprutils::OS::CFileDescriptor syncobjFd;
-    uint32_t                       handle = 0;
-    WP<CSyncTimeline>              self;
+    int                            m_drmFD = -1;
+    Hyprutils::OS::CFileDescriptor m_syncobjFD;
+    uint32_t                       m_handle = 0;
+    WP<CSyncTimeline>              m_self;
 
   private:
     CSyncTimeline() = default;
diff --git a/src/hyprerror/HyprError.cpp b/src/hyprerror/HyprError.cpp
index 72036ff8..c8000649 100644
--- a/src/hyprerror/HyprError.cpp
+++ b/src/hyprerror/HyprError.cpp
@@ -49,11 +49,11 @@ void CHyprError::createQueued() {
 
     const auto PMONITOR = g_pCompositor->m_monitors.front();
 
-    const auto SCALE = PMONITOR->scale;
+    const auto SCALE = PMONITOR->m_scale;
 
-    const auto FONTSIZE = std::clamp((int)(10.f * ((PMONITOR->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
+    const auto FONTSIZE = std::clamp((int)(10.f * ((PMONITOR->m_pixelSize.x * SCALE) / 1920.f)), 8, 40);
 
-    const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+    const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
 
     const auto CAIRO = cairo_create(CAIROSURFACE);
 
@@ -76,13 +76,13 @@ void CHyprError::createQueued() {
 
     const double PAD = 10 * SCALE;
 
-    const double WIDTH  = PMONITOR->vecPixelSize.x - PAD * 2;
+    const double WIDTH  = PMONITOR->m_pixelSize.x - PAD * 2;
     const double HEIGHT = (FONTSIZE + 2 * (FONTSIZE / 10.0)) * (VISLINECOUNT + EXTRALINES) + 3;
     const double RADIUS = PAD > HEIGHT / 2 ? HEIGHT / 2 - 1 : PAD;
     const double X      = PAD;
-    const double Y      = TOPBAR ? PAD : PMONITOR->vecPixelSize.y - HEIGHT - PAD;
+    const double Y      = TOPBAR ? PAD : PMONITOR->m_pixelSize.y - HEIGHT - PAD;
 
-    m_bDamageBox = {0, 0, (int)PMONITOR->vecPixelSize.x, (int)HEIGHT + (int)PAD * 2};
+    m_bDamageBox = {0, 0, (int)PMONITOR->m_pixelSize.x, (int)HEIGHT + (int)PAD * 2};
 
     cairo_new_sub_path(CAIRO);
     cairo_arc(CAIRO, X + WIDTH - RADIUS, Y + RADIUS, RADIUS, -90 * DEGREES, 0 * DEGREES);
@@ -152,7 +152,7 @@ void CHyprError::createQueued() {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
 #endif
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     // delete cairo
     cairo_destroy(CAIRO);
@@ -164,7 +164,7 @@ void CHyprError::createQueued() {
 
     g_pHyprRenderer->damageMonitor(PMONITOR);
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
 }
 
 void CHyprError::draw() {
@@ -183,7 +183,7 @@ void CHyprError::draw() {
                 m_szQueued   = "";
 
                 for (auto& m : g_pCompositor->m_monitors) {
-                    g_pHyprRenderer->arrangeLayersForMonitor(m->ID);
+                    g_pHyprRenderer->arrangeLayersForMonitor(m->m_id);
                 }
 
                 return;
@@ -196,10 +196,10 @@ void CHyprError::draw() {
 
     const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor;
 
-    CBox       monbox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    CBox       monbox = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
 
-    m_bDamageBox.x = (int)PMONITOR->vecPosition.x;
-    m_bDamageBox.y = (int)PMONITOR->vecPosition.y;
+    m_bDamageBox.x = (int)PMONITOR->m_position.x;
+    m_bDamageBox.y = (int)PMONITOR->m_position.y;
 
     if (m_fFadeOpacity->isBeingAnimated() || m_bMonitorChanged)
         g_pHyprRenderer->damageBox(m_bDamageBox);
diff --git a/src/layout/DwindleLayout.cpp b/src/layout/DwindleLayout.cpp
index 5ebd14ce..020a200a 100644
--- a/src/layout/DwindleLayout.cpp
+++ b/src/layout/DwindleLayout.cpp
@@ -115,10 +115,10 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     }
 
     // for gaps outer
-    const bool DISPLAYLEFT   = STICKS(pNode->box.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
-    const bool DISPLAYRIGHT  = STICKS(pNode->box.x + pNode->box.w, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
-    const bool DISPLAYTOP    = STICKS(pNode->box.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
-    const bool DISPLAYBOTTOM = STICKS(pNode->box.y + pNode->box.h, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
+    const bool DISPLAYLEFT   = STICKS(pNode->box.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
+    const bool DISPLAYRIGHT  = STICKS(pNode->box.x + pNode->box.w, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
+    const bool DISPLAYTOP    = STICKS(pNode->box.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
+    const bool DISPLAYBOTTOM = STICKS(pNode->box.y + pNode->box.h, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
 
     const auto PWINDOW = pNode->pWindow.lock();
     // get specific gaps and rules for this workspace,
@@ -245,8 +245,8 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
     const auto        MOUSECOORDS   = m_vOverrideFocalPoint.value_or(g_pInputManager->getMouseCoordsInternal());
     const auto        MONFROMCURSOR = g_pCompositor->getMonitorFromVector(MOUSECOORDS);
 
-    if (PMONITOR->ID == MONFROMCURSOR->ID &&
-        (PNODE->workspaceID == PMONITOR->activeWorkspaceID() || (g_pCompositor->isWorkspaceSpecial(PNODE->workspaceID) && PMONITOR->activeSpecialWorkspace)) && !*PUSEACTIVE) {
+    if (PMONITOR->m_id == MONFROMCURSOR->m_id &&
+        (PNODE->workspaceID == PMONITOR->activeWorkspaceID() || (g_pCompositor->isWorkspaceSpecial(PNODE->workspaceID) && PMONITOR->m_activeSpecialWorkspace)) && !*PUSEACTIVE) {
         OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowUnified(MOUSECOORDS, RESERVED_EXTENTS | INPUT_EXTENTS | SKIP_FULLSCREEN_PRIORITY));
 
         if (!OPENINGON && g_pCompositor->isPointOnReservedArea(MOUSECOORDS, PMONITOR))
@@ -266,7 +266,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
     } else
         OPENINGON = getFirstNodeOnWorkspace(pWindow->workspaceID());
 
-    Debug::log(LOG, "OPENINGON: {}, Monitor: {}", OPENINGON, PMONITOR->ID);
+    Debug::log(LOG, "OPENINGON: {}, Monitor: {}", OPENINGON, PMONITOR->m_id);
 
     if (OPENINGON && OPENINGON->workspaceID != PNODE->workspaceID) {
         // special workspace handling
@@ -274,7 +274,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
     }
 
     // first, check if OPENINGON isn't too big.
-    const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->box.w, OPENINGON->box.h) : PMONITOR->vecSize;
+    const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->box.w, OPENINGON->box.h) : PMONITOR->m_size;
     if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) {
         // we can't continue. make it floating.
         pWindow->m_isFloating = true;
@@ -295,7 +295,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
 
     // if it's the first, it's easy. Make it fullscreen.
     if (!OPENINGON || OPENINGON->pWindow.lock() == pWindow) {
-        PNODE->box = CBox{PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight};
+        PNODE->box = CBox{PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
 
         applyNodeDataToWindow(PNODE);
 
@@ -487,15 +487,15 @@ void CHyprDwindleLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
 void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
 
-    if (!PMONITOR || !PMONITOR->activeWorkspace)
+    if (!PMONITOR || !PMONITOR->m_activeWorkspace)
         return; // ???
 
     g_pHyprRenderer->damageMonitor(PMONITOR);
 
-    if (PMONITOR->activeSpecialWorkspace)
-        calculateWorkspace(PMONITOR->activeSpecialWorkspace);
+    if (PMONITOR->m_activeSpecialWorkspace)
+        calculateWorkspace(PMONITOR->m_activeSpecialWorkspace);
 
-    calculateWorkspace(PMONITOR->activeWorkspace);
+    calculateWorkspace(PMONITOR->m_activeWorkspace);
 }
 
 void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
@@ -509,12 +509,12 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
         const auto PFULLWINDOW = pWorkspace->getFullscreenWindow();
 
         if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
-            *PFULLWINDOW->m_realPosition = PMONITOR->vecPosition;
-            *PFULLWINDOW->m_realSize     = PMONITOR->vecSize;
+            *PFULLWINDOW->m_realPosition = PMONITOR->m_position;
+            *PFULLWINDOW->m_realSize     = PMONITOR->m_size;
         } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) {
             SDwindleNodeData fakeNode;
             fakeNode.pWindow        = PFULLWINDOW;
-            fakeNode.box            = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight};
+            fakeNode.box            = {PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
             fakeNode.workspaceID    = pWorkspace->m_id;
             PFULLWINDOW->m_position = fakeNode.box.pos();
             PFULLWINDOW->m_size     = fakeNode.box.size();
@@ -530,7 +530,7 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
     const auto TOPNODE = getMasterNodeOnWorkspace(pWorkspace->m_id);
 
     if (TOPNODE) {
-        TOPNODE->box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight};
+        TOPNODE->box = {PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
         TOPNODE->recalcSizePosRecursive();
     }
 }
@@ -567,10 +567,10 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
 
     // get some data about our window
     const auto PMONITOR      = PWINDOW->m_monitor.lock();
-    const bool DISPLAYLEFT   = STICKS(PWINDOW->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
-    const bool DISPLAYRIGHT  = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
-    const bool DISPLAYTOP    = STICKS(PWINDOW->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
-    const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
+    const bool DISPLAYLEFT   = STICKS(PWINDOW->m_position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
+    const bool DISPLAYRIGHT  = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
+    const bool DISPLAYTOP    = STICKS(PWINDOW->m_position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
+    const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
 
     if (PWINDOW->m_isPseudotiled) {
         if (!m_PseudoDragFlags.started) {
@@ -766,8 +766,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu
     } else {
         // apply new pos and size being monitors' box
         if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) {
-            *pWindow->m_realPosition = PMONITOR->vecPosition;
-            *pWindow->m_realSize     = PMONITOR->vecSize;
+            *pWindow->m_realPosition = PMONITOR->m_position;
+            *pWindow->m_realSize     = PMONITOR->m_size;
         } else {
             // This is a massive hack.
             // We make a fake "only" node and apply
@@ -775,7 +775,7 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu
 
             SDwindleNodeData fakeNode;
             fakeNode.pWindow     = pWindow;
-            fakeNode.box         = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight};
+            fakeNode.box         = {PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
             fakeNode.workspaceID = pWindow->workspaceID();
             pWindow->m_position  = fakeNode.box.pos();
             pWindow->m_size      = fakeNode.box.size();
@@ -821,7 +821,7 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
 
     Vector2D   focalPoint;
 
-    const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{pWindow->m_monitor->vecPosition, pWindow->m_monitor->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
+    const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{pWindow->m_monitor->m_position, pWindow->m_monitor->m_size} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
 
     switch (dir[0]) {
         case 't':
@@ -842,7 +842,7 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
     const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint);
 
     if (PMONITORFOCAL != pWindow->m_monitor) {
-        pWindow->moveToWorkspace(PMONITORFOCAL->activeWorkspace);
+        pWindow->moveToWorkspace(PMONITORFOCAL->m_activeWorkspace);
         pWindow->m_monitor = PMONITORFOCAL;
     }
 
@@ -1087,13 +1087,13 @@ Vector2D CHyprDwindleLayout::predictSizeForNewWindowTiled() {
     PHLWINDOW candidate = g_pCompositor->m_lastWindow.lock();
 
     if (!candidate)
-        candidate = g_pCompositor->m_lastMonitor->activeWorkspace->getFirstWindow();
+        candidate = g_pCompositor->m_lastMonitor->m_activeWorkspace->getFirstWindow();
 
     // create a fake node
     SDwindleNodeData node;
 
     if (!candidate)
-        return g_pCompositor->m_lastMonitor->vecSize;
+        return g_pCompositor->m_lastMonitor->m_size;
     else {
         const auto PNODE = getNodeFromWindow(candidate);
 
diff --git a/src/layout/IHyprLayout.cpp b/src/layout/IHyprLayout.cpp
index ac04157b..0eb38e3d 100644
--- a/src/layout/IHyprLayout.cpp
+++ b/src/layout/IHyprLayout.cpp
@@ -27,7 +27,7 @@ void IHyprLayout::onWindowCreated(PHLWINDOW pWindow, eDirection direction) {
         pWindow->m_lastFloatingSize = STOREDSIZE.value();
     } else if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
         const auto PMONITOR         = pWindow->m_monitor.lock();
-        pWindow->m_lastFloatingSize = PMONITOR->vecSize / 2.f;
+        pWindow->m_lastFloatingSize = PMONITOR->m_size / 2.f;
     } else
         pWindow->m_lastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
 
@@ -128,18 +128,18 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
 
         // reject any windows with size <= 5x5
         if (pWindow->m_realSize->goal().x <= 5 || pWindow->m_realSize->goal().y <= 5)
-            *pWindow->m_realSize = PMONITOR->vecSize / 2.f;
+            *pWindow->m_realSize = PMONITOR->m_size / 2.f;
 
         if (pWindow->m_isX11 && pWindow->isX11OverrideRedirect()) {
 
             if (pWindow->m_xwaylandSurface->geometry.x != 0 && pWindow->m_xwaylandSurface->geometry.y != 0)
                 *pWindow->m_realPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_xwaylandSurface->geometry.pos());
             else
-                *pWindow->m_realPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_realSize->goal().x) / 2.f,
-                                                    PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_realSize->goal().y) / 2.f);
+                *pWindow->m_realPosition = Vector2D(PMONITOR->m_position.x + (PMONITOR->m_size.x - pWindow->m_realSize->goal().x) / 2.f,
+                                                    PMONITOR->m_position.y + (PMONITOR->m_size.y - pWindow->m_realSize->goal().y) / 2.f);
         } else {
-            *pWindow->m_realPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_realSize->goal().x) / 2.f,
-                                                PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_realSize->goal().y) / 2.f);
+            *pWindow->m_realPosition = Vector2D(PMONITOR->m_position.x + (PMONITOR->m_size.x - pWindow->m_realSize->goal().x) / 2.f,
+                                                PMONITOR->m_position.y + (PMONITOR->m_size.y - pWindow->m_realSize->goal().y) / 2.f);
         }
     } else {
         // we respect the size.
@@ -165,20 +165,20 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
                 *pWindow->m_realPosition = pWindow->m_xdgSurface->toplevel->parent->window->m_realPosition->goal() +
                     pWindow->m_xdgSurface->toplevel->parent->window->m_realSize->goal() / 2.F - desiredGeometry.size() / 2.F;
             else
-                *pWindow->m_realPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.F - desiredGeometry.size() / 2.F;
+                *pWindow->m_realPosition = PMONITOR->m_position + PMONITOR->m_size / 2.F - desiredGeometry.size() / 2.F;
         } else {
             // if it is, we respect where it wants to put itself, but apply monitor offset if outside
             // most of these are popups
 
-            if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID)
-                *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition;
+            if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->m_id != PMONITOR->m_id)
+                *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->m_position + PMONITOR->m_position;
             else
                 *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
         }
     }
 
     if (*PXWLFORCESCALEZERO && pWindow->m_isX11)
-        *pWindow->m_realSize = pWindow->m_realSize->goal() / PMONITOR->scale;
+        *pWindow->m_realSize = pWindow->m_realSize->goal() / PMONITOR->m_scale;
 
     if (pWindow->m_X11DoesntWantBorders || (pWindow->m_isX11 && pWindow->isX11OverrideRedirect())) {
         pWindow->m_realPosition->warp();
@@ -468,32 +468,30 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA
         const double BORDERDIFF = OVERLAP ? DRAGGINGBORDERSIZE : 0;
         const auto   MON        = DRAGGINGWINDOW->m_monitor.lock();
 
-        SRange       monX = {MON->vecPosition.x + MON->vecReservedTopLeft.x + DRAGGINGBORDERSIZE,
-                             MON->vecPosition.x + MON->vecSize.x - MON->vecReservedBottomRight.x - DRAGGINGBORDERSIZE};
-        SRange       monY = {MON->vecPosition.y + MON->vecReservedTopLeft.y + DRAGGINGBORDERSIZE,
-                             MON->vecPosition.y + MON->vecSize.y - MON->vecReservedBottomRight.y - DRAGGINGBORDERSIZE};
+        SRange monX = {MON->m_position.x + MON->m_reservedTopLeft.x + DRAGGINGBORDERSIZE, MON->m_position.x + MON->m_size.x - MON->m_reservedBottomRight.x - DRAGGINGBORDERSIZE};
+        SRange monY = {MON->m_position.y + MON->m_reservedTopLeft.y + DRAGGINGBORDERSIZE, MON->m_position.y + MON->m_size.y - MON->m_reservedBottomRight.y - DRAGGINGBORDERSIZE};
 
         if (CORNER & (CORNER_TOPLEFT | CORNER_BOTTOMLEFT) &&
-            ((MON->vecReservedTopLeft.x > 0 && canSnap(sourceX.start, monX.start, GAPSIZE)) ||
-             canSnap(sourceX.start, (monX.start -= MON->vecReservedTopLeft.x + BORDERDIFF), GAPSIZE))) {
+            ((MON->m_reservedTopLeft.x > 0 && canSnap(sourceX.start, monX.start, GAPSIZE)) ||
+             canSnap(sourceX.start, (monX.start -= MON->m_reservedTopLeft.x + BORDERDIFF), GAPSIZE))) {
             SNAP(sourceX.start, sourceX.end, monX.start);
             snaps |= SNAP_LEFT;
         }
         if (CORNER & (CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT) &&
-            ((MON->vecReservedBottomRight.x > 0 && canSnap(sourceX.end, monX.end, GAPSIZE)) ||
-             canSnap(sourceX.end, (monX.end += MON->vecReservedBottomRight.x + BORDERDIFF), GAPSIZE))) {
+            ((MON->m_reservedBottomRight.x > 0 && canSnap(sourceX.end, monX.end, GAPSIZE)) ||
+             canSnap(sourceX.end, (monX.end += MON->m_reservedBottomRight.x + BORDERDIFF), GAPSIZE))) {
             SNAP(sourceX.end, sourceX.start, monX.end);
             snaps |= SNAP_RIGHT;
         }
         if (CORNER & (CORNER_TOPLEFT | CORNER_TOPRIGHT) &&
-            ((MON->vecReservedTopLeft.y > 0 && canSnap(sourceY.start, monY.start, GAPSIZE)) ||
-             canSnap(sourceY.start, (monY.start -= MON->vecReservedTopLeft.y + BORDERDIFF), GAPSIZE))) {
+            ((MON->m_reservedTopLeft.y > 0 && canSnap(sourceY.start, monY.start, GAPSIZE)) ||
+             canSnap(sourceY.start, (monY.start -= MON->m_reservedTopLeft.y + BORDERDIFF), GAPSIZE))) {
             SNAP(sourceY.start, sourceY.end, monY.start);
             snaps |= SNAP_UP;
         }
         if (CORNER & (CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT) &&
-            ((MON->vecReservedBottomRight.y > 0 && canSnap(sourceY.end, monY.end, GAPSIZE)) ||
-             canSnap(sourceY.end, (monY.end += MON->vecReservedBottomRight.y + BORDERDIFF), GAPSIZE))) {
+            ((MON->m_reservedBottomRight.y > 0 && canSnap(sourceY.end, monY.end, GAPSIZE)) ||
+             canSnap(sourceY.end, (monY.end += MON->m_reservedBottomRight.y + BORDERDIFF), GAPSIZE))) {
             SNAP(sourceY.end, sourceY.start, monY.end);
             snaps |= SNAP_DOWN;
         }
@@ -555,7 +553,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
 
     const auto  TIMERDELTA    = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count();
     const auto  MSDELTA       = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - MSTIMER).count();
-    const auto  MSMONITOR     = 1000.0 / g_pHyprRenderer->m_pMostHzMonitor->refreshRate;
+    const auto  MSMONITOR     = 1000.0 / g_pHyprRenderer->m_pMostHzMonitor->m_refreshRate;
     static int  totalMs       = 0;
     bool        canSkipUpdate = true;
 
@@ -688,7 +686,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
 
     if (PMONITOR && !SPECIAL) {
         DRAGGINGWINDOW->m_monitor = PMONITOR;
-        DRAGGINGWINDOW->moveToWorkspace(PMONITOR->activeWorkspace);
+        DRAGGINGWINDOW->moveToWorkspace(PMONITOR->m_activeWorkspace);
         DRAGGINGWINDOW->updateGroupOutputs();
 
         DRAGGINGWINDOW->updateToplevel();
@@ -719,10 +717,10 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
     if (!TILED) {
         const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_realPosition->value() + pWindow->m_realSize->value() / 2.f);
         pWindow->m_monitor = PNEWMON;
-        pWindow->moveToWorkspace(PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace);
+        pWindow->moveToWorkspace(PNEWMON->m_activeSpecialWorkspace ? PNEWMON->m_activeSpecialWorkspace : PNEWMON->m_activeWorkspace);
         pWindow->updateGroupOutputs();
 
-        const auto PWORKSPACE = PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace;
+        const auto PWORKSPACE = PNEWMON->m_activeSpecialWorkspace ? PNEWMON->m_activeSpecialWorkspace : PNEWMON->m_activeWorkspace;
 
         if (PWORKSPACE->m_hasFullscreenWindow)
             g_pCompositor->setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE);
@@ -899,11 +897,11 @@ Vector2D IHyprLayout::predictSizeForNewWindowFloating(PHLWINDOW pWindow) { // ge
 
                 const auto  MAXSIZE = pWindow->requestedMaxSize();
 
-                const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->vecSize.x) :
-                                                        stringToPercentage(SIZEXSTR, g_pCompositor->m_lastMonitor->vecSize.x);
+                const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->m_size.x) :
+                                                        stringToPercentage(SIZEXSTR, g_pCompositor->m_lastMonitor->m_size.x);
 
-                const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->vecSize.y) :
-                                                        stringToPercentage(SIZEYSTR, g_pCompositor->m_lastMonitor->vecSize.y);
+                const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->m_size.y) :
+                                                        stringToPercentage(SIZEYSTR, g_pCompositor->m_lastMonitor->m_size.y);
 
                 sizeOverride = {SIZEX, SIZEY};
 
diff --git a/src/layout/MasterLayout.cpp b/src/layout/MasterLayout.cpp
index 6c7f6d1a..53f3f823 100644
--- a/src/layout/MasterLayout.cpp
+++ b/src/layout/MasterLayout.cpp
@@ -205,7 +205,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
         PNODE->percMaster = lastSplitPercent;
 
         // first, check if it isn't too big.
-        if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->vecSize.x * lastSplitPercent || MAXSIZE.y < PMONITOR->vecSize.y) {
+        if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->m_size.x * lastSplitPercent || MAXSIZE.y < PMONITOR->m_size.y) {
             // we can't continue. make it floating.
             pWindow->m_isFloating = true;
             m_lMasterNodesData.remove(*PNODE);
@@ -218,7 +218,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
 
         // first, check if it isn't too big.
         if (const auto MAXSIZE = pWindow->requestedMaxSize();
-            MAXSIZE.x < PMONITOR->vecSize.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->vecSize.y * (1.f / (WINDOWSONWORKSPACE - 1))) {
+            MAXSIZE.x < PMONITOR->m_size.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->m_size.y * (1.f / (WINDOWSONWORKSPACE - 1))) {
             // we can't continue. make it floating.
             pWindow->m_isFloating = true;
             m_lMasterNodesData.remove(*PNODE);
@@ -284,15 +284,15 @@ void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
 void CHyprMasterLayout::recalculateMonitor(const MONITORID& monid) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
 
-    if (!PMONITOR || !PMONITOR->activeWorkspace)
+    if (!PMONITOR || !PMONITOR->m_activeWorkspace)
         return;
 
     g_pHyprRenderer->damageMonitor(PMONITOR);
 
-    if (PMONITOR->activeSpecialWorkspace)
-        calculateWorkspace(PMONITOR->activeSpecialWorkspace);
+    if (PMONITOR->m_activeSpecialWorkspace)
+        calculateWorkspace(PMONITOR->m_activeSpecialWorkspace);
 
-    calculateWorkspace(PMONITOR->activeWorkspace);
+    calculateWorkspace(PMONITOR->m_activeWorkspace);
 }
 
 void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
@@ -306,13 +306,13 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
         const auto PFULLWINDOW = pWorkspace->getFullscreenWindow();
 
         if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
-            *PFULLWINDOW->m_realPosition = PMONITOR->vecPosition;
-            *PFULLWINDOW->m_realSize     = PMONITOR->vecSize;
+            *PFULLWINDOW->m_realPosition = PMONITOR->m_position;
+            *PFULLWINDOW->m_realSize     = PMONITOR->m_size;
         } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) {
             SMasterNodeData fakeNode;
             fakeNode.pWindow                = PFULLWINDOW;
-            fakeNode.position               = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
-            fakeNode.size                   = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+            fakeNode.position               = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
+            fakeNode.size                   = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
             fakeNode.workspaceID            = pWorkspace->m_id;
             PFULLWINDOW->m_position         = fakeNode.position;
             PFULLWINDOW->m_size             = fakeNode.size;
@@ -340,8 +340,8 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
     const auto   MASTERS      = getMastersOnWorkspace(pWorkspace->m_id);
     const auto   WINDOWS      = getNodesOnWorkspace(pWorkspace->m_id);
     const auto   STACKWINDOWS = WINDOWS - MASTERS;
-    const auto   WSSIZE       = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
-    const auto   WSPOS        = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+    const auto   WSSIZE       = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
+    const auto   WSPOS        = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
 
     if (orientation == ORIENTATION_CENTER) {
         if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) {
@@ -426,7 +426,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
             nextX += WIDTH;
         }
     } else { // orientation left, right or center
-        float WIDTH       = *PIGNORERESERVED && centerMasterWindow ? PMONITOR->vecSize.x : WSSIZE.x;
+        float WIDTH       = *PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_size.x : WSSIZE.x;
         float heightLeft  = WSSIZE.y;
         int   mastersLeft = MASTERS;
         float nextX       = 0;
@@ -438,7 +438,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
         if (orientation == ORIENTATION_RIGHT) {
             nextX = WSSIZE.x - WIDTH;
         } else if (centerMasterWindow) {
-            nextX = ((*PIGNORERESERVED && centerMasterWindow ? PMONITOR->vecSize.x : WSSIZE.x) - WIDTH) / 2;
+            nextX = ((*PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_size.x : WSSIZE.x) - WIDTH) / 2;
         }
 
         for (auto& nd : m_lMasterNodesData) {
@@ -455,7 +455,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
             }
 
             nd.size     = Vector2D(WIDTH, HEIGHT);
-            nd.position = (*PIGNORERESERVED && centerMasterWindow ? PMONITOR->vecPosition : WSPOS) + Vector2D(nextX, nextY);
+            nd.position = (*PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_position : WSPOS) + Vector2D(nextX, nextY);
             applyNodeDataToWindow(&nd);
 
             mastersLeft--;
@@ -530,7 +530,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
             nextY += HEIGHT;
         }
     } else { // slaves for centered master window(s)
-        const float WIDTH       = ((*PIGNORERESERVED ? PMONITOR->vecSize.x : WSSIZE.x) - PMASTERNODE->size.x) / 2.0;
+        const float WIDTH       = ((*PIGNORERESERVED ? PMONITOR->m_size.x : WSSIZE.x) - PMASTERNODE->size.x) / 2.0;
         float       heightLeft  = 0;
         float       heightLeftL = WSSIZE.y;
         float       heightLeftR = WSSIZE.y;
@@ -573,7 +573,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
                 continue;
 
             if (onRight) {
-                nextX      = WIDTH + PMASTERNODE->size.x - (*PIGNORERESERVED ? PMONITOR->vecReservedTopLeft.x : 0);
+                nextX      = WIDTH + PMASTERNODE->size.x - (*PIGNORERESERVED ? PMONITOR->m_reservedTopLeft.x : 0);
                 nextY      = nextYR;
                 heightLeft = heightLeftR;
                 slavesLeft = slavesLeftR;
@@ -598,7 +598,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
                 }
             }
 
-            nd.size     = Vector2D(*PIGNORERESERVED ? (WIDTH - (onRight ? PMONITOR->vecReservedBottomRight.x : PMONITOR->vecReservedTopLeft.x)) : WIDTH, HEIGHT);
+            nd.size     = Vector2D(*PIGNORERESERVED ? (WIDTH - (onRight ? PMONITOR->m_reservedBottomRight.x : PMONITOR->m_reservedTopLeft.x)) : WIDTH, HEIGHT);
             nd.position = WSPOS + Vector2D(nextX, nextY);
             applyNodeDataToWindow(&nd);
 
@@ -636,10 +636,10 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     }
 
     // for gaps outer
-    const bool DISPLAYLEFT   = STICKS(pNode->position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
-    const bool DISPLAYRIGHT  = STICKS(pNode->position.x + pNode->size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
-    const bool DISPLAYTOP    = STICKS(pNode->position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
-    const bool DISPLAYBOTTOM = STICKS(pNode->position.y + pNode->size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
+    const bool DISPLAYLEFT   = STICKS(pNode->position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
+    const bool DISPLAYRIGHT  = STICKS(pNode->position.x + pNode->size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
+    const bool DISPLAYTOP    = STICKS(pNode->position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
+    const bool DISPLAYBOTTOM = STICKS(pNode->position.y + pNode->size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
 
     const auto PWINDOW = pNode->pWindow.lock();
     // get specific gaps and rules for this workspace,
@@ -737,10 +737,10 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
     static auto  SLAVECOUNTFORCENTER = CConfigValue<Hyprlang::INT>("master:slave_count_for_center_master");
     static auto  PSMARTRESIZING      = CConfigValue<Hyprlang::INT>("master:smart_resizing");
 
-    const bool   DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
-    const bool   DISPLAYRIGHT  = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
-    const bool   DISPLAYTOP    = STICKS(PWINDOW->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
-    const bool   DISPLAYLEFT   = STICKS(PWINDOW->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
+    const bool   DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
+    const bool   DISPLAYRIGHT  = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
+    const bool   DISPLAYTOP    = STICKS(PWINDOW->m_position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
+    const bool   DISPLAYLEFT   = STICKS(PWINDOW->m_position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
 
     const bool   LEFT = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT;
     const bool   TOP  = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT;
@@ -760,12 +760,12 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
     m_bForceWarps = true;
 
     switch (orientation) {
-        case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->vecSize.x; break;
-        case ORIENTATION_RIGHT: delta = -pixResize.x / PMONITOR->vecSize.x; break;
-        case ORIENTATION_BOTTOM: delta = -pixResize.y / PMONITOR->vecSize.y; break;
-        case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->vecSize.y; break;
+        case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->m_size.x; break;
+        case ORIENTATION_RIGHT: delta = -pixResize.x / PMONITOR->m_size.x; break;
+        case ORIENTATION_BOTTOM: delta = -pixResize.y / PMONITOR->m_size.y; break;
+        case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->m_size.y; break;
         case ORIENTATION_CENTER:
-            delta = pixResize.x / PMONITOR->vecSize.x;
+            delta = pixResize.x / PMONITOR->m_size.x;
             if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) {
                 if (!NONE || !PNODE->isMaster)
                     delta *= 2;
@@ -776,7 +776,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
         default: UNREACHABLE();
     }
 
-    const auto workspaceIdForResizing = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID();
+    const auto workspaceIdForResizing = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID();
     for (auto& n : m_lMasterNodesData) {
         if (n.isMaster && n.workspaceID == workspaceIdForResizing)
             n.percMaster = std::clamp(n.percMaster + delta, 0.05, 0.95);
@@ -786,7 +786,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
     const bool isStackVertical = orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT || orientation == ORIENTATION_CENTER;
 
     const auto RESIZEDELTA = isStackVertical ? pixResize.y : pixResize.x;
-    const auto WSSIZE      = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+    const auto WSSIZE      = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
 
     auto       nodesInSameColumn = PNODE->isMaster ? MASTERS : STACKWINDOWS;
     if (orientation == ORIENTATION_CENTER && !PNODE->isMaster)
@@ -856,7 +856,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
         }
     }
 
-    recalculateMonitor(PMONITOR->ID);
+    recalculateMonitor(PMONITOR->m_id);
 
     m_bForceWarps = false;
 }
@@ -889,8 +889,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul
     } else {
         // apply new pos and size being monitors' box
         if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) {
-            *pWindow->m_realPosition = PMONITOR->vecPosition;
-            *pWindow->m_realSize     = PMONITOR->vecSize;
+            *pWindow->m_realPosition = PMONITOR->m_position;
+            *pWindow->m_realSize     = PMONITOR->m_size;
         } else {
             // This is a massive hack.
             // We make a fake "only" node and apply
@@ -898,8 +898,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul
 
             SMasterNodeData fakeNode;
             fakeNode.pWindow                = pWindow;
-            fakeNode.position               = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
-            fakeNode.size                   = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+            fakeNode.position               = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
+            fakeNode.size                   = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
             fakeNode.workspaceID            = pWindow->workspaceID();
             pWindow->m_position             = fakeNode.position;
             pWindow->m_size                 = fakeNode.size;
@@ -1446,22 +1446,22 @@ Vector2D CHyprMasterLayout::predictSizeForNewWindowTiled() {
     if (!g_pCompositor->m_lastMonitor)
         return {};
 
-    const int NODES = getNodesOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id);
+    const int NODES = getNodesOnWorkspace(g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id);
 
     if (NODES <= 0)
-        return g_pCompositor->m_lastMonitor->vecSize;
+        return g_pCompositor->m_lastMonitor->m_size;
 
-    const auto MASTER = getMasterNodeOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id);
+    const auto MASTER = getMasterNodeOnWorkspace(g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id);
     if (!MASTER) // wtf
         return {};
 
     if (*PNEWSTATUS == "master") {
         return MASTER->size;
     } else {
-        const auto SLAVES = NODES - getMastersOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id);
+        const auto SLAVES = NODES - getMastersOnWorkspace(g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id);
 
         // TODO: make this better
-        return {g_pCompositor->m_lastMonitor->vecSize.x - MASTER->size.x, g_pCompositor->m_lastMonitor->vecSize.y / (SLAVES + 1)};
+        return {g_pCompositor->m_lastMonitor->m_size.x - MASTER->size.x, g_pCompositor->m_lastMonitor->m_size.y / (SLAVES + 1)};
     }
 
     return {};
diff --git a/src/managers/AnimationManager.cpp b/src/managers/AnimationManager.cpp
index c9b270e2..0d3aa9c7 100644
--- a/src/managers/AnimationManager.cpp
+++ b/src/managers/AnimationManager.cpp
@@ -21,7 +21,7 @@ static int wlTick(SP<CEventLoopTimer> self, void* data) {
         g_pAnimationManager->onTicked();
 
     if (g_pCompositor->m_sessionActive && g_pAnimationManager && g_pHookSystem && !g_pCompositor->m_unsafeState &&
-        std::ranges::any_of(g_pCompositor->m_monitors, [](const auto& mon) { return mon->m_bEnabled && mon->output; })) {
+        std::ranges::any_of(g_pCompositor->m_monitors, [](const auto& mon) { return mon->m_enabled && mon->m_output; })) {
         g_pAnimationManager->tick();
         EMIT_HOOK_EVENT("tick", nullptr);
     }
@@ -64,7 +64,7 @@ static void updateColorVariable(CAnimatedVariable<CHyprColor>& av, const float P
     const auto&                L1 = av.begun().asOkLab();
     const auto&                L2 = av.goal().asOkLab();
 
-    static const auto          lerp = [](const float one, const float two, const float progress) -> float { return one + (two - one) * progress; };
+    static const auto          lerp = [](const float one, const float two, const float progress) -> float { return one + ((two - one) * progress); };
 
     const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{
         .l = lerp(L1.l, L2.l, POINTY),
@@ -117,7 +117,7 @@ static void handleUpdate(CAnimatedVariable<VarType>& av, bool warp) {
                 // still doing the full damage hack for floating because sometimes when the window
                 // goes through multiple monitors the last rendered frame is missing damage somehow??
                 const CBox windowBoxNoOffset = w->getFullWindowBoundingBox();
-                const CBox monitorBox        = {PMONITOR->vecPosition, PMONITOR->vecSize};
+                const CBox monitorBox        = {PMONITOR->m_position, PMONITOR->m_size};
                 if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors
                     g_pHyprRenderer->damageWindow(w, true);
             }
@@ -262,9 +262,9 @@ void CHyprAnimationManager::scheduleTick() {
         return;
     }
 
-    float       refreshDelayMs = std::floor(1000.f / PMOSTHZ->refreshRate);
+    float       refreshDelayMs = std::floor(1000.f / PMOSTHZ->m_refreshRate);
 
-    const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(Time::steadyNow() - PMOSTHZ->lastPresentationTimer.chrono()).count() / 1000.F;
+    const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(Time::steadyNow() - PMOSTHZ->m_lastPresentationTimer.chrono()).count() / 1000.F;
 
     const auto  TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it
 
@@ -308,13 +308,13 @@ void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force,
 
     if (force != "") {
         if (force == "bottom")
-            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y);
+            posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y + PMONITOR->m_size.y);
         else if (force == "left")
             posOffset = GOALPOS - Vector2D(GOALSIZE.x, 0.0);
         else if (force == "right")
             posOffset = GOALPOS + Vector2D(GOALSIZE.x, 0.0);
         else
-            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y);
+            posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y - GOALSIZE.y);
 
         if (!close)
             pWindow->m_realPosition->setValue(posOffset);
@@ -327,10 +327,10 @@ void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force,
     const auto MIDPOINT = GOALPOS + GOALSIZE / 2.f;
 
     // check sides it touches
-    const bool DISPLAYLEFT   = STICKS(pWindow->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
-    const bool DISPLAYRIGHT  = STICKS(pWindow->m_position.x + pWindow->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
-    const bool DISPLAYTOP    = STICKS(pWindow->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
-    const bool DISPLAYBOTTOM = STICKS(pWindow->m_position.y + pWindow->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
+    const bool DISPLAYLEFT   = STICKS(pWindow->m_position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
+    const bool DISPLAYRIGHT  = STICKS(pWindow->m_position.x + pWindow->m_size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
+    const bool DISPLAYTOP    = STICKS(pWindow->m_position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
+    const bool DISPLAYBOTTOM = STICKS(pWindow->m_position.y + pWindow->m_size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
 
     if (DISPLAYBOTTOM && DISPLAYTOP) {
         if (DISPLAYLEFT && DISPLAYRIGHT) {
@@ -345,10 +345,10 @@ void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force,
     } else if (DISPLAYBOTTOM) {
         posOffset = GOALPOS + Vector2D(0.0, GOALSIZE.y);
     } else {
-        if (MIDPOINT.y > PMONITOR->vecPosition.y + PMONITOR->vecSize.y / 2.f)
-            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y);
+        if (MIDPOINT.y > PMONITOR->m_position.y + PMONITOR->m_size.y / 2.f)
+            posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y + PMONITOR->m_size.y);
         else
-            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y);
+            posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y - GOALSIZE.y);
     }
 
     if (!close)
diff --git a/src/managers/CursorManager.cpp b/src/managers/CursorManager.cpp
index 9a949283..b7c2e4e2 100644
--- a/src/managers/CursorManager.cpp
+++ b/src/managers/CursorManager.cpp
@@ -291,8 +291,8 @@ void CCursorManager::updateTheme() {
     float       highestScale   = 1.0;
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        if (m->scale > highestScale)
-            highestScale = m->scale;
+        if (m->m_scale > highestScale)
+            highestScale = m->m_scale;
     }
 
     m_fCursorScale = highestScale;
@@ -308,7 +308,7 @@ void CCursorManager::updateTheme() {
     }
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        m->forceFullFrames = 5;
+        m->m_forceFullFrames = 5;
         g_pCompositor->scheduleFrameForMonitor(m, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
     }
 }
diff --git a/src/managers/KeybindManager.cpp b/src/managers/KeybindManager.cpp
index 7d07a717..1bd7e1a2 100644
--- a/src/managers/KeybindManager.cpp
+++ b/src/managers/KeybindManager.cpp
@@ -49,16 +49,16 @@ static std::vector<std::pair<std::string, std::string>> getHyprlandLaunchEnv(PHL
         return {};
 
     const auto PMONITOR = g_pCompositor->m_lastMonitor;
-    if (!PMONITOR || !PMONITOR->activeWorkspace)
+    if (!PMONITOR || !PMONITOR->m_activeWorkspace)
         return {};
 
     std::vector<std::pair<std::string, std::string>> result;
 
     if (!pInitialWorkspace) {
-        if (PMONITOR->activeSpecialWorkspace)
-            pInitialWorkspace = PMONITOR->activeSpecialWorkspace;
+        if (PMONITOR->m_activeSpecialWorkspace)
+            pInitialWorkspace = PMONITOR->m_activeSpecialWorkspace;
         else
-            pInitialWorkspace = PMONITOR->activeWorkspace;
+            pInitialWorkspace = PMONITOR->m_activeWorkspace;
     }
 
     result.push_back(std::make_pair<>("HL_INITIAL_WORKSPACE_TOKEN",
@@ -349,13 +349,13 @@ bool CKeybindManager::tryMoveFocusToMonitor(PHLMONITOR monitor) {
     static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
     static auto PNOWARPS     = CConfigValue<Hyprlang::INT>("cursor:no_warps");
 
-    const auto  PWORKSPACE        = g_pCompositor->m_lastMonitor->activeWorkspace;
-    const auto  PNEWMAINWORKSPACE = monitor->activeWorkspace;
+    const auto  PWORKSPACE        = g_pCompositor->m_lastMonitor->m_activeWorkspace;
+    const auto  PNEWMAINWORKSPACE = monitor->m_activeWorkspace;
 
     g_pInputManager->unconstrainMouse();
     PNEWMAINWORKSPACE->rememberPrevWorkspace(PWORKSPACE);
 
-    const auto PNEWWORKSPACE = monitor->activeSpecialWorkspace ? monitor->activeSpecialWorkspace : PNEWMAINWORKSPACE;
+    const auto PNEWWORKSPACE = monitor->m_activeSpecialWorkspace ? monitor->m_activeSpecialWorkspace : PNEWMAINWORKSPACE;
 
     const auto PNEWWINDOW = PNEWWORKSPACE->getLastFocusedWindow();
     if (PNEWWINDOW) {
@@ -1196,7 +1196,7 @@ SDispatchResult CKeybindManager::centerWindow(std::string args) {
 
     auto       RESERVEDOFFSET = Vector2D();
     if (args == "1")
-        RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;
+        RESERVEDOFFSET = (PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight) / 2.f;
 
     *PWINDOW->m_realPosition = PMONITOR->middle() - PWINDOW->m_realSize->goal() / 2.f + RESERVEDOFFSET;
     PWINDOW->m_position      = PWINDOW->m_realPosition->goal();
@@ -1256,7 +1256,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) {
     if (!PMONITOR)
         return {.success = false, .error = "Last monitor not found"};
 
-    const auto PCURRENTWORKSPACE = PMONITOR->activeWorkspace;
+    const auto PCURRENTWORKSPACE = PMONITOR->m_activeWorkspace;
     const bool EXPLICITPREVIOUS  = args.contains("previous");
 
     const auto& [workspaceToChangeTo, workspaceName] = getWorkspaceToChangeFromArgs(args, PCURRENTWORKSPACE, PMONITOR);
@@ -1284,7 +1284,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) {
     auto pWorkspaceToChangeTo = g_pCompositor->getWorkspaceByID(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo);
     if (!pWorkspaceToChangeTo)
         pWorkspaceToChangeTo =
-            g_pCompositor->createNewWorkspace(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo, PMONITOR->ID, BISWORKSPACECURRENT ? PPREVWS.name : workspaceName);
+            g_pCompositor->createNewWorkspace(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo, PMONITOR->m_id, BISWORKSPACECURRENT ? PPREVWS.name : workspaceName);
 
     if (!BISWORKSPACECURRENT && pWorkspaceToChangeTo->m_isSpecialWorkspace) {
         PMONITOR->setSpecialWorkspace(pWorkspaceToChangeTo);
@@ -1561,9 +1561,9 @@ SDispatchResult CKeybindManager::moveFocusTo(std::string args) {
         return {.success = false, .error = "last window has no monitor?"};
 
     if (arg == 'l' || arg == 'r') {
-        if (STICKS(PLASTWINDOW->m_position.x, PMONITOR->vecPosition.x) && STICKS(PLASTWINDOW->m_size.x, PMONITOR->vecSize.x))
+        if (STICKS(PLASTWINDOW->m_position.x, PMONITOR->m_position.x) && STICKS(PLASTWINDOW->m_size.x, PMONITOR->m_size.x))
             return {.success = false, .error = "move does not make sense, would return back"};
-    } else if (STICKS(PLASTWINDOW->m_position.y, PMONITOR->vecPosition.y) && STICKS(PLASTWINDOW->m_size.y, PMONITOR->vecSize.y))
+    } else if (STICKS(PLASTWINDOW->m_position.y, PMONITOR->m_position.y) && STICKS(PLASTWINDOW->m_size.y, PMONITOR->m_size.y))
         return {.success = false, .error = "move does not make sense, would return back"};
 
     CBox box = PMONITOR->logicalBox();
@@ -1588,8 +1588,8 @@ SDispatchResult CKeybindManager::moveFocusTo(std::string args) {
             break;
     }
 
-    const auto PWINDOWCANDIDATE = g_pCompositor->getWindowInDirection(box, PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace, arg,
-                                                                      PLASTWINDOW, PLASTWINDOW->m_isFloating);
+    const auto PWINDOWCANDIDATE = g_pCompositor->getWindowInDirection(box, PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace,
+                                                                      arg, PLASTWINDOW, PLASTWINDOW->m_isFloating);
     if (PWINDOWCANDIDATE)
         switchToWindow(PWINDOWCANDIDATE);
 
@@ -1661,9 +1661,9 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
             return {.success = false, .error = std::format("Monitor {} not found", args.substr(4))};
 
         if (silent)
-            moveActiveToWorkspaceSilent(PNEWMONITOR->activeWorkspace->getConfigName());
+            moveActiveToWorkspaceSilent(PNEWMONITOR->m_activeWorkspace->getConfigName());
         else
-            moveActiveToWorkspace(PNEWMONITOR->activeWorkspace->getConfigName());
+            moveActiveToWorkspace(PNEWMONITOR->m_activeWorkspace->getConfigName());
 
         return {};
     }
@@ -1687,12 +1687,12 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
         const auto           BORDERSIZE = PLASTWINDOW->getRealBorderSize();
 
         switch (arg) {
-            case 'l': vPosx = PMONITOR->vecReservedTopLeft.x + BORDERSIZE + PMONITOR->vecPosition.x; break;
-            case 'r': vPosx = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PLASTWINDOW->m_realSize->goal().x - BORDERSIZE + PMONITOR->vecPosition.x; break;
+            case 'l': vPosx = PMONITOR->m_reservedTopLeft.x + BORDERSIZE + PMONITOR->m_position.x; break;
+            case 'r': vPosx = PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x - PLASTWINDOW->m_realSize->goal().x - BORDERSIZE + PMONITOR->m_position.x; break;
             case 't':
-            case 'u': vPosy = PMONITOR->vecReservedTopLeft.y + BORDERSIZE + PMONITOR->vecPosition.y; break;
+            case 'u': vPosy = PMONITOR->m_reservedTopLeft.y + BORDERSIZE + PMONITOR->m_position.y; break;
             case 'b':
-            case 'd': vPosy = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PLASTWINDOW->m_realSize->goal().y - BORDERSIZE + PMONITOR->vecPosition.y; break;
+            case 'd': vPosy = PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y - PLASTWINDOW->m_realSize->goal().y - BORDERSIZE + PMONITOR->m_position.y; break;
         }
 
         *PLASTWINDOW->m_realPosition = Vector2D(vPosx.value_or(PLASTWINDOW->m_realPosition->goal().x), vPosy.value_or(PLASTWINDOW->m_realPosition->goal().y));
@@ -1720,7 +1720,7 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
     if (!PMONITORTOCHANGETO)
         return {.success = false, .error = "Nowhere to move active window to"};
 
-    const auto PWORKSPACE = PMONITORTOCHANGETO->activeWorkspace;
+    const auto PWORKSPACE = PMONITORTOCHANGETO->m_activeWorkspace;
     if (silent)
         moveActiveToWorkspaceSilent(PWORKSPACE->getConfigName());
     else
@@ -1919,7 +1919,7 @@ SDispatchResult CKeybindManager::moveCursor(std::string args) {
 SDispatchResult CKeybindManager::workspaceOpt(std::string args) {
 
     // current workspace
-    const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+    const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
     if (!PWORKSPACE)
         return {.success = false, .error = "Workspace not found"}; // ????
@@ -1966,7 +1966,7 @@ SDispatchResult CKeybindManager::workspaceOpt(std::string args) {
     }
 
     // recalc mon
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_lastMonitor->ID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_lastMonitor->m_id);
 
     return {};
 }
@@ -2012,7 +2012,7 @@ SDispatchResult CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args)
     }
 
     // get the current workspace
-    const auto PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+    const auto PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
     if (!PCURRENTWORKSPACE) {
         Debug::log(ERR, "moveCurrentWorkspaceToMonitor invalid workspace!");
         return {.success = false, .error = "moveCurrentWorkspaceToMonitor invalid workspace!"};
@@ -2073,7 +2073,7 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args
     auto pWorkspace = g_pCompositor->getWorkspaceByID(workspaceID);
 
     if (!pWorkspace) {
-        pWorkspace = g_pCompositor->createNewWorkspace(workspaceID, PCURRMONITOR->ID, workspaceName);
+        pWorkspace = g_pCompositor->createNewWorkspace(workspaceID, PCURRMONITOR->m_id, workspaceName);
         // we can skip the moving, since it's already on the current monitor
         changeworkspace(pWorkspace->getConfigName());
         return {};
@@ -2086,7 +2086,7 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args
         // Workspace to focus is previous workspace
         pWorkspace = g_pCompositor->getWorkspaceByID(PREVWS.id);
         if (!pWorkspace)
-            pWorkspace = g_pCompositor->createNewWorkspace(PREVWS.id, PCURRMONITOR->ID, PREVWS.name);
+            pWorkspace = g_pCompositor->createNewWorkspace(PREVWS.id, PCURRMONITOR->m_id, PREVWS.name);
 
         workspaceID = pWorkspace->m_id;
     }
@@ -2137,13 +2137,13 @@ SDispatchResult CKeybindManager::toggleSpecialWorkspace(std::string args) {
         Debug::log(LOG, "Toggling special workspace {} to closed", workspaceID);
         PMONITOR->setSpecialWorkspace(nullptr);
 
-        focusedWorkspace = PMONITOR->activeWorkspace;
+        focusedWorkspace = PMONITOR->m_activeWorkspace;
     } else {
         Debug::log(LOG, "Toggling special workspace {} to open", workspaceID);
         auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceID);
 
         if (!PSPECIALWORKSPACE)
-            PSPECIALWORKSPACE = g_pCompositor->createNewWorkspace(workspaceID, PMONITOR->ID, workspaceName);
+            PSPECIALWORKSPACE = g_pCompositor->createNewWorkspace(workspaceID, PMONITOR->m_id, workspaceName);
 
         PMONITOR->setSpecialWorkspace(PSPECIALWORKSPACE);
 
@@ -2167,7 +2167,7 @@ SDispatchResult CKeybindManager::forceRendererReload(std::string args) {
     bool overAgain = false;
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        if (!m->output)
+        if (!m->m_output)
             continue;
 
         auto rule = g_pConfigManager->getMonitorRuleFor(m);
@@ -2274,7 +2274,7 @@ SDispatchResult CKeybindManager::resizeWindow(std::string args) {
 SDispatchResult CKeybindManager::circleNext(std::string arg) {
     if (g_pCompositor->m_lastWindow.expired()) {
         // if we have a clear focus, find the first window and get the next focusable.
-        const auto PWS = g_pCompositor->m_lastMonitor->activeWorkspace;
+        const auto PWS = g_pCompositor->m_lastMonitor->m_activeWorkspace;
         if (PWS && PWS->getWindows() > 0) {
             const auto PWINDOW = PWS->getFirstWindow();
             switchToWindow(PWINDOW);
@@ -2319,8 +2319,8 @@ SDispatchResult CKeybindManager::focusWindow(std::string regexp) {
 
     updateRelativeCursorCoords();
 
-    if (g_pCompositor->m_lastMonitor && g_pCompositor->m_lastMonitor->activeWorkspace != PWINDOW->m_workspace &&
-        g_pCompositor->m_lastMonitor->activeSpecialWorkspace != PWINDOW->m_workspace) {
+    if (g_pCompositor->m_lastMonitor && g_pCompositor->m_lastMonitor->m_activeWorkspace != PWINDOW->m_workspace &&
+        g_pCompositor->m_lastMonitor->m_activeSpecialWorkspace != PWINDOW->m_workspace) {
         Debug::log(LOG, "Fake executing workspace to move focus");
         changeworkspace(PWORKSPACE->getConfigName());
     }
@@ -2670,19 +2670,19 @@ SDispatchResult CKeybindManager::dpms(std::string arg) {
 
     for (auto const& m : g_pCompositor->m_monitors) {
 
-        if (!port.empty() && m->szName != port)
+        if (!port.empty() && m->m_name != port)
             continue;
 
         if (isToggle)
-            enable = !m->dpmsStatus;
+            enable = !m->m_dpmsStatus;
 
-        m->output->state->resetExplicitFences();
-        m->output->state->setEnabled(enable);
+        m->m_output->state->resetExplicitFences();
+        m->m_output->state->setEnabled(enable);
 
-        m->dpmsStatus = enable;
+        m->m_dpmsStatus = enable;
 
-        if (!m->state.commit()) {
-            Debug::log(ERR, "Couldn't commit output {}", m->szName);
+        if (!m->m_state.commit()) {
+            Debug::log(ERR, "Couldn't commit output {}", m->m_name);
             res.success = false;
             res.error   = "Couldn't commit output {}";
         }
@@ -2690,7 +2690,7 @@ SDispatchResult CKeybindManager::dpms(std::string arg) {
         if (enable)
             g_pHyprRenderer->damageMonitor(m);
 
-        m->events.dpmsChanged.emit();
+        m->m_events.dpmsChanged.emit();
     }
 
     g_pCompositor->m_dpmsStateOn = enable;
@@ -2774,7 +2774,7 @@ SDispatchResult CKeybindManager::pinActive(std::string args) {
         return {.success = false, .error = "pin: window not found"};
     }
 
-    PWINDOW->m_workspace = PMONITOR->activeWorkspace;
+    PWINDOW->m_workspace = PMONITOR->m_activeWorkspace;
 
     PWINDOW->updateDynamicRules();
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
@@ -3274,7 +3274,7 @@ SDispatchResult CKeybindManager::setProp(std::string args) {
     }
 
     for (auto const& m : g_pCompositor->m_monitors)
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
 
     return {};
 }
diff --git a/src/managers/PointerManager.cpp b/src/managers/PointerManager.cpp
index 1c9036bf..1dcc0107 100644
--- a/src/managers/PointerManager.cpp
+++ b/src/managers/PointerManager.cpp
@@ -29,9 +29,9 @@ CPointerManager::CPointerManager() {
 
         onMonitorLayoutChange();
 
-        PMONITOR->events.modeChanged.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr);
-        PMONITOR->events.disconnect.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr);
-        PMONITOR->events.destroy.registerStaticListener(
+        PMONITOR->m_events.modeChanged.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr);
+        PMONITOR->m_events.disconnect.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr);
+        PMONITOR->m_events.destroy.registerStaticListener(
             [this](void* owner, std::any data) {
                 if (g_pCompositor && !g_pCompositor->m_isShuttingDown)
                     std::erase_if(monitorStates, [](const auto& other) { return other->monitor.expired(); });
@@ -179,7 +179,7 @@ void CPointerManager::recheckEnteredOutputs() {
     auto box = getCursorBoxGlobal();
 
     for (auto const& s : monitorStates) {
-        if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_bEnabled)
+        if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_enabled)
             continue;
 
         const bool overlaps = box.overlaps(s->monitor->logicalBox());
@@ -191,14 +191,15 @@ void CPointerManager::recheckEnteredOutputs() {
                 continue;
 
             currentCursorImage.surface->resource()->enter(s->monitor.lock());
-            PROTO::fractional->sendScale(currentCursorImage.surface->resource(), s->monitor->scale);
-            g_pCompositor->setPreferredScaleForSurface(currentCursorImage.surface->resource(), s->monitor->scale);
+            PROTO::fractional->sendScale(currentCursorImage.surface->resource(), s->monitor->m_scale);
+            g_pCompositor->setPreferredScaleForSurface(currentCursorImage.surface->resource(), s->monitor->m_scale);
         } else if (s->entered && !overlaps) {
             s->entered = false;
 
             // if we are using hw cursors, prevent
             // the cursor from being stuck at the last point.
-            if (!s->hardwareFailed && (s->monitor->output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
+            if (!s->hardwareFailed &&
+                (s->monitor->m_output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
                 setHWCursorBuffer(s, nullptr);
 
             if (!currentCursorImage.surface)
@@ -232,7 +233,7 @@ void CPointerManager::resetCursorImage(bool apply) {
     currentCursorImage.hotspot = {0, 0};
 
     for (auto const& s : monitorStates) {
-        if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_bEnabled)
+        if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_enabled)
             continue;
 
         s->entered = false;
@@ -242,14 +243,14 @@ void CPointerManager::resetCursorImage(bool apply) {
         return;
 
     for (auto const& ms : monitorStates) {
-        if (!ms->monitor || !ms->monitor->m_bEnabled || !ms->monitor->dpmsStatus) {
+        if (!ms->monitor || !ms->monitor->m_enabled || !ms->monitor->m_dpmsStatus) {
             Debug::log(TRACE, "Not updating hw cursors: disabled / dpms off display");
             continue;
         }
 
         if (ms->cursorFrontBuffer) {
-            if (ms->monitor->output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER)
-                ms->monitor->output->setCursor(nullptr, {});
+            if (ms->monitor->m_output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER)
+                ms->monitor->m_output->setCursor(nullptr, {});
             ms->cursorFrontBuffer = nullptr;
         }
     }
@@ -259,7 +260,7 @@ void CPointerManager::updateCursorBackend() {
     const auto CURSORBOX = getCursorBoxGlobal();
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        if (!m->m_bEnabled || !m->dpmsStatus) {
+        if (!m->m_enabled || !m->m_dpmsStatus) {
             Debug::log(TRACE, "Not updating hw cursors: disabled / dpms off display");
             continue;
         }
@@ -275,7 +276,7 @@ void CPointerManager::updateCursorBackend() {
         }
 
         if (state->softwareLocks > 0 || g_pConfigManager->shouldUseSoftwareCursors(m) || !attemptHardwareCursor(state)) {
-            Debug::log(TRACE, "Output {} rejected hardware cursors, falling back to sw", m->szName);
+            Debug::log(TRACE, "Output {} rejected hardware cursors, falling back to sw", m->m_name);
             state->box            = getCursorBoxLogicalForMonitor(state->monitor.lock());
             state->hardwareFailed = true;
 
@@ -305,11 +306,11 @@ void CPointerManager::onCursorMoved() {
         auto CROSSES = !m->logicalBox().intersection(CURSORBOX).empty();
 
         if (!CROSSES && state->cursorFrontBuffer) {
-            Debug::log(TRACE, "onCursorMoved for output {}: cursor left the viewport, removing it from the backend", m->szName);
+            Debug::log(TRACE, "onCursorMoved for output {}: cursor left the viewport, removing it from the backend", m->m_name);
             setHWCursorBuffer(state, nullptr);
             continue;
         } else if (CROSSES && !state->cursorFrontBuffer) {
-            Debug::log(TRACE, "onCursorMoved for output {}: cursor entered the output, but no front buffer, forcing recalc", m->szName);
+            Debug::log(TRACE, "onCursorMoved for output {}: cursor entered the output, but no front buffer, forcing recalc", m->m_name);
             recalc = true;
         }
 
@@ -322,9 +323,9 @@ void CPointerManager::onCursorMoved() {
             continue;
 
         const auto CURSORPOS = getCursorPosForMonitor(m);
-        m->output->moveCursor(CURSORPOS, m->shouldSkipScheduleFrameOnMouseEvent());
+        m->m_output->moveCursor(CURSORPOS, m->shouldSkipScheduleFrameOnMouseEvent());
 
-        state->monitor->scanoutNeedsCursorUpdate = true;
+        state->monitor->m_scanoutNeedsCursorUpdate = true;
     }
 
     if (recalc)
@@ -332,13 +333,13 @@ void CPointerManager::onCursorMoved() {
 }
 
 bool CPointerManager::attemptHardwareCursor(SP<CPointerManager::SMonitorPointerState> state) {
-    auto output = state->monitor->output;
+    auto output = state->monitor->m_output;
 
     if (!(output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
         return false;
 
     const auto CURSORPOS = getCursorPosForMonitor(state->monitor.lock());
-    state->monitor->output->moveCursor(CURSORPOS, state->monitor->shouldSkipScheduleFrameOnMouseEvent());
+    state->monitor->m_output->moveCursor(CURSORPOS, state->monitor->shouldSkipScheduleFrameOnMouseEvent());
 
     auto texture = getCurrentCursorTexture();
 
@@ -369,14 +370,14 @@ bool CPointerManager::attemptHardwareCursor(SP<CPointerManager::SMonitorPointerS
 }
 
 bool CPointerManager::setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquamarine::IBuffer> buf) {
-    if (!(state->monitor->output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
+    if (!(state->monitor->m_output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
         return false;
 
     const auto HOTSPOT = transformedHotspot(state->monitor.lock());
 
-    Debug::log(TRACE, "[pointer] hw transformed hotspot for {}: {}", state->monitor->szName, HOTSPOT);
+    Debug::log(TRACE, "[pointer] hw transformed hotspot for {}: {}", state->monitor->m_name, HOTSPOT);
 
-    if (!state->monitor->output->setCursor(buf, HOTSPOT))
+    if (!state->monitor->m_output->setCursor(buf, HOTSPOT))
         return false;
 
     state->cursorFrontBuffer = buf;
@@ -384,13 +385,13 @@ bool CPointerManager::setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquam
     if (!state->monitor->shouldSkipScheduleFrameOnMouseEvent())
         g_pCompositor->scheduleFrameForMonitor(state->monitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
 
-    state->monitor->scanoutNeedsCursorUpdate = true;
+    state->monitor->m_scanoutNeedsCursorUpdate = true;
 
     return true;
 }
 
 SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager::SMonitorPointerState> state, SP<CTexture> texture) {
-    auto        maxSize    = state->monitor->output->cursorPlaneSize();
+    auto        maxSize    = state->monitor->m_output->cursorPlaneSize();
     auto const& cursorSize = currentCursorImage.size;
 
     static auto PCPUBUFFER = CConfigValue<Hyprlang::INT>("cursor:use_cpu_buffer");
@@ -408,14 +409,14 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
     } else
         maxSize = cursorSize;
 
-    if (!state->monitor->cursorSwapchain || maxSize != state->monitor->cursorSwapchain->currentOptions().size ||
-        shouldUseCpuBuffer != (state->monitor->cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) {
+    if (!state->monitor->m_cursorSwapchain || maxSize != state->monitor->m_cursorSwapchain->currentOptions().size ||
+        shouldUseCpuBuffer != (state->monitor->m_cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) {
 
-        if (!state->monitor->cursorSwapchain || shouldUseCpuBuffer != (state->monitor->cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) {
+        if (!state->monitor->m_cursorSwapchain || shouldUseCpuBuffer != (state->monitor->m_cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) {
 
-            auto allocator = state->monitor->output->getBackend()->preferredAllocator();
+            auto allocator = state->monitor->m_output->getBackend()->preferredAllocator();
             if (shouldUseCpuBuffer) {
-                for (const auto& a : state->monitor->output->getBackend()->getAllocators()) {
+                for (const auto& a : state->monitor->m_output->getBackend()->getAllocators()) {
                     if (a->type() == Aquamarine::AQ_ALLOCATOR_TYPE_DRM_DUMB) {
                         allocator = a;
                         break;
@@ -423,23 +424,23 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
                 }
             }
 
-            auto backend                    = state->monitor->output->getBackend();
-            auto primary                    = backend->getPrimary();
-            state->monitor->cursorSwapchain = Aquamarine::CSwapchain::create(allocator, primary ? primary.lock() : backend);
+            auto backend                      = state->monitor->m_output->getBackend();
+            auto primary                      = backend->getPrimary();
+            state->monitor->m_cursorSwapchain = Aquamarine::CSwapchain::create(allocator, primary ? primary.lock() : backend);
         }
 
-        auto options     = state->monitor->cursorSwapchain->currentOptions();
+        auto options     = state->monitor->m_cursorSwapchain->currentOptions();
         options.size     = maxSize;
         options.length   = 2;
         options.scanout  = true;
         options.cursor   = true;
-        options.multigpu = state->monitor->output->getBackend()->preferredAllocator()->drmFD() != g_pCompositor->m_drmFD;
+        options.multigpu = state->monitor->m_output->getBackend()->preferredAllocator()->drmFD() != g_pCompositor->m_drmFD;
         // We do not set the format (unless shm). If it's unset (DRM_FORMAT_INVALID) then the swapchain will pick for us,
         // but if it's set, we don't wanna change it.
         if (shouldUseCpuBuffer)
             options.format = DRM_FORMAT_ARGB8888;
 
-        if (!state->monitor->cursorSwapchain->reconfigure(options)) {
+        if (!state->monitor->m_cursorSwapchain->reconfigure(options)) {
             Debug::log(TRACE, "Failed to reconfigure cursor swapchain");
             return nullptr;
         }
@@ -449,11 +450,11 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
     // the current front buffer
     // this flag will be reset in the preRender hook, so when we commit this buffer to KMS
     if (state->cursorRendered)
-        state->monitor->cursorSwapchain->rollback();
+        state->monitor->m_cursorSwapchain->rollback();
 
     state->cursorRendered = true;
 
-    auto buf = state->monitor->cursorSwapchain->next(nullptr);
+    auto buf = state->monitor->m_cursorSwapchain->next(nullptr);
     if (!buf) {
         Debug::log(TRACE, "Failed to acquire a buffer from the cursor swapchain");
         return nullptr;
@@ -519,10 +520,10 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
         cairo_matrix_t matrixPre;
         cairo_matrix_init_identity(&matrixPre);
 
-        const auto TR = state->monitor->transform;
+        const auto TR = state->monitor->m_transform;
 
         // we need to scale the cursor to the right size, because it might not be (esp with XCursor)
-        const auto SCALE = texture->m_vSize / (currentCursorImage.size / currentCursorImage.scale * state->monitor->scale);
+        const auto SCALE = texture->m_vSize / (currentCursorImage.size / currentCursorImage.scale * state->monitor->m_scale);
         cairo_matrix_scale(&matrixPre, SCALE.x, SCALE.y);
 
         if (TR) {
@@ -565,7 +566,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
     g_pHyprRenderer->makeEGLCurrent();
     g_pHyprOpenGL->m_RenderData.pMonitor = state->monitor;
 
-    auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->cursorSwapchain->currentOptions().format);
+    auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->m_cursorSwapchain->currentOptions().format);
     if (!RBO) {
         Debug::log(TRACE, "Failed to create cursor RB with format {}, mod {}", buf->dmabuf().format, buf->dmabuf().modifier);
         return nullptr;
@@ -576,9 +577,9 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
     g_pHyprOpenGL->beginSimple(state->monitor.lock(), {0, 0, INT16_MAX, INT16_MAX}, RBO);
     g_pHyprOpenGL->clear(CHyprColor{0.F, 0.F, 0.F, 0.F});
 
-    CBox xbox = {{}, Vector2D{currentCursorImage.size / currentCursorImage.scale * state->monitor->scale}.round()};
-    Debug::log(TRACE, "[pointer] monitor: {}, size: {}, hw buf: {}, scale: {:.2f}, monscale: {:.2f}, xbox: {}", state->monitor->szName, currentCursorImage.size, cursorSize,
-               currentCursorImage.scale, state->monitor->scale, xbox.size());
+    CBox xbox = {{}, Vector2D{currentCursorImage.size / currentCursorImage.scale * state->monitor->m_scale}.round()};
+    Debug::log(TRACE, "[pointer] monitor: {}, size: {}, hw buf: {}, scale: {:.2f}, monscale: {:.2f}, xbox: {}", state->monitor->m_name, currentCursorImage.size, cursorSize,
+               currentCursorImage.scale, state->monitor->m_scale, xbox.size());
 
     g_pHyprOpenGL->renderTexture(texture, xbox, 1.F);
 
@@ -609,14 +610,14 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
         box.y = overridePos->y;
     }
 
-    if (box.intersection(CBox{{}, {pMonitor->vecSize}}).empty())
+    if (box.intersection(CBox{{}, {pMonitor->m_size}}).empty())
         return;
 
     auto texture = getCurrentCursorTexture();
     if (!texture)
         return;
 
-    box.scale(pMonitor->scale);
+    box.scale(pMonitor->m_scale);
     box.x = std::round(box.x);
     box.y = std::round(box.y);
 
@@ -631,25 +632,25 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
 }
 
 Vector2D CPointerManager::getCursorPosForMonitor(PHLMONITOR pMonitor) {
-    return CBox{pointerPos - pMonitor->vecPosition, {0, 0}}
-               .transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->vecTransformedSize.x / pMonitor->scale,
-                          pMonitor->vecTransformedSize.y / pMonitor->scale)
+    return CBox{pointerPos - pMonitor->m_position, {0, 0}}
+               .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_transformedSize.x / pMonitor->m_scale,
+                          pMonitor->m_transformedSize.y / pMonitor->m_scale)
                .pos() *
-        pMonitor->scale;
+        pMonitor->m_scale;
 }
 
 Vector2D CPointerManager::transformedHotspot(PHLMONITOR pMonitor) {
-    if (!pMonitor->cursorSwapchain)
+    if (!pMonitor->m_cursorSwapchain)
         return {}; // doesn't matter, we have no hw cursor, and this is only for hw cursors
 
-    return CBox{currentCursorImage.hotspot * pMonitor->scale, {0, 0}}
-        .transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->cursorSwapchain->currentOptions().size.x,
-                   pMonitor->cursorSwapchain->currentOptions().size.y)
+    return CBox{currentCursorImage.hotspot * pMonitor->m_scale, {0, 0}}
+        .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_cursorSwapchain->currentOptions().size.x,
+                   pMonitor->m_cursorSwapchain->currentOptions().size.y)
         .pos();
 }
 
 CBox CPointerManager::getCursorBoxLogicalForMonitor(PHLMONITOR pMonitor) {
-    return getCursorBoxGlobal().translate(-pMonitor->vecPosition);
+    return getCursorBoxGlobal().translate(-pMonitor->m_position);
 }
 
 CBox CPointerManager::getCursorBoxGlobal() {
@@ -736,11 +737,11 @@ void CPointerManager::damageIfSoftware() {
     auto b = getCursorBoxGlobal().expand(4);
 
     for (auto const& mw : monitorStates) {
-        if (mw->monitor.expired() || !mw->monitor->output)
+        if (mw->monitor.expired() || !mw->monitor->m_output)
             continue;
 
         if ((mw->softwareLocks > 0 || mw->hardwareFailed || g_pConfigManager->shouldUseSoftwareCursors(mw->monitor.lock())) &&
-            b.overlaps({mw->monitor->vecPosition, mw->monitor->vecSize})) {
+            b.overlaps({mw->monitor->m_position, mw->monitor->m_size})) {
             g_pHyprRenderer->damageBox(b, mw->monitor->shouldSkipScheduleFrameOnMouseEvent());
             break;
         }
@@ -778,7 +779,7 @@ void CPointerManager::warpAbsolute(Vector2D abs, SP<IHID> dev) {
 
     // find x and y size of the entire space
     const auto& MONITORS = g_pCompositor->m_monitors;
-    Vector2D    topLeft = MONITORS.at(0)->vecPosition, bottomRight = MONITORS.at(0)->vecPosition + MONITORS.at(0)->vecSize;
+    Vector2D    topLeft = MONITORS.at(0)->m_position, bottomRight = MONITORS.at(0)->m_position + MONITORS.at(0)->m_size;
     for (size_t i = 1; i < MONITORS.size(); ++i) {
         const auto EXTENT = MONITORS[i]->logicalBox().extent();
         const auto POS    = MONITORS[i]->logicalBox().pos();
@@ -852,10 +853,10 @@ void CPointerManager::warpAbsolute(Vector2D abs, SP<IHID> dev) {
 void CPointerManager::onMonitorLayoutChange() {
     currentMonitorLayout.monitorBoxes.clear();
     for (auto const& m : g_pCompositor->m_monitors) {
-        if (m->isMirror() || !m->m_bEnabled || !m->output)
+        if (m->isMirror() || !m->m_enabled || !m->m_output)
             continue;
 
-        currentMonitorLayout.monitorBoxes.emplace_back(m->vecPosition, m->vecSize);
+        currentMonitorLayout.monitorBoxes.emplace_back(m->m_position, m->m_size);
     }
 
     damageIfSoftware();
diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp
index 7f51d09f..2de13da0 100644
--- a/src/managers/ProtocolManager.cpp
+++ b/src/managers/ProtocolManager.cpp
@@ -84,12 +84,12 @@ void CProtocolManager::onMonitorModeChange(PHLMONITOR pMonitor) {
     // mirrored outputs should have their global removed, as they are not physical parts of the
     // layout.
 
-    if (ISMIRROR && PROTO::outputs.contains(pMonitor->szName))
-        PROTO::outputs.at(pMonitor->szName)->remove();
-    else if (!ISMIRROR && (!PROTO::outputs.contains(pMonitor->szName) || PROTO::outputs.at(pMonitor->szName)->isDefunct())) {
-        if (PROTO::outputs.contains(pMonitor->szName))
-            PROTO::outputs.erase(pMonitor->szName);
-        PROTO::outputs.emplace(pMonitor->szName, makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", pMonitor->szName), pMonitor->self.lock()));
+    if (ISMIRROR && PROTO::outputs.contains(pMonitor->m_name))
+        PROTO::outputs.at(pMonitor->m_name)->remove();
+    else if (!ISMIRROR && (!PROTO::outputs.contains(pMonitor->m_name) || PROTO::outputs.at(pMonitor->m_name)->isDefunct())) {
+        if (PROTO::outputs.contains(pMonitor->m_name))
+            PROTO::outputs.erase(pMonitor->m_name);
+        PROTO::outputs.emplace(pMonitor->m_name, makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", pMonitor->m_name), pMonitor->m_self.lock()));
     }
 
     if (PROTO::colorManagement && g_pCompositor->shouldChangePreferredImageDescription()) {
@@ -115,22 +115,22 @@ CProtocolManager::CProtocolManager() {
         if (M->isMirror() || M == g_pCompositor->m_unsafeOutput)
             return;
 
-        if (PROTO::outputs.contains(M->szName))
-            PROTO::outputs.erase(M->szName);
+        if (PROTO::outputs.contains(M->m_name))
+            PROTO::outputs.erase(M->m_name);
 
-        auto ref = makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", M->szName), M->self.lock());
-        PROTO::outputs.emplace(M->szName, ref);
+        auto ref = makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", M->m_name), M->m_self.lock());
+        PROTO::outputs.emplace(M->m_name, ref);
         ref->self = ref;
 
-        m_mModeChangeListeners[M->szName] = M->events.modeChanged.registerListener([M, this](std::any d) { onMonitorModeChange(M); });
+        m_mModeChangeListeners[M->m_name] = M->m_events.modeChanged.registerListener([M, this](std::any d) { onMonitorModeChange(M); });
     });
 
     static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {
         auto M = std::any_cast<PHLMONITOR>(param);
-        if (!PROTO::outputs.contains(M->szName))
+        if (!PROTO::outputs.contains(M->m_name))
             return;
-        PROTO::outputs.at(M->szName)->remove();
-        m_mModeChangeListeners.erase(M->szName);
+        PROTO::outputs.at(M->m_name)->remove();
+        m_mModeChangeListeners.erase(M->m_name);
     });
 
     // Core
diff --git a/src/managers/SessionLockManager.cpp b/src/managers/SessionLockManager.cpp
index ecca3c96..83a238a6 100644
--- a/src/managers/SessionLockManager.cpp
+++ b/src/managers/SessionLockManager.cpp
@@ -67,8 +67,8 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
         const auto PMONITOR = SURFACE->monitor();
 
         const auto NEWSURFACE  = m_pSessionLock->vSessionLockSurfaces.emplace_back(makeUnique<SSessionLockSurface>(SURFACE)).get();
-        NEWSURFACE->iMonitorID = PMONITOR->ID;
-        PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->scale);
+        NEWSURFACE->iMonitorID = PMONITOR->m_id;
+        PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->m_scale);
     });
 
     m_pSessionLock->listeners.unlock = pLock->events.unlockAndDestroy.registerListener([this](std::any data) {
@@ -138,7 +138,7 @@ void CSessionLockManager::onLockscreenRenderedOnMonitor(uint64_t id) {
     if (!m_pSessionLock || m_pSessionLock->m_hasSentLocked)
         return;
     m_pSessionLock->m_lockedMonitors.emplace(id);
-    const bool LOCKED = std::ranges::all_of(g_pCompositor->m_monitors, [this](auto m) { return m_pSessionLock->m_lockedMonitors.contains(m->ID); });
+    const bool LOCKED = std::ranges::all_of(g_pCompositor->m_monitors, [this](auto m) { return m_pSessionLock->m_lockedMonitors.contains(m->m_id); });
     if (LOCKED && m_pSessionLock->lock->good()) {
         m_pSessionLock->lock->sendLocked();
         m_pSessionLock->m_hasSentLocked = true;
diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp
index c5cf77f5..62852c2f 100644
--- a/src/managers/XWaylandManager.cpp
+++ b/src/managers/XWaylandManager.cpp
@@ -170,9 +170,9 @@ Vector2D CHyprXWaylandManager::waylandToXWaylandCoords(const Vector2D& coord) {
     PHLMONITOR  pMonitor     = nullptr;
     double      bestDistance = __FLT_MAX__;
     for (const auto& m : g_pCompositor->m_monitors) {
-        const auto SIZ = *PXWLFORCESCALEZERO ? m->vecTransformedSize : m->vecSize;
+        const auto SIZ = *PXWLFORCESCALEZERO ? m->m_transformedSize : m->m_size;
 
-        double     distance = vecToRectDistanceSquared(coord, {m->vecPosition.x, m->vecPosition.y}, {m->vecPosition.x + SIZ.x - 1, m->vecPosition.y + SIZ.y - 1});
+        double     distance = vecToRectDistanceSquared(coord, {m->m_position.x, m->m_position.y}, {m->m_position.x + SIZ.x - 1, m->m_position.y + SIZ.y - 1});
 
         if (distance < bestDistance) {
             bestDistance = distance;
@@ -184,12 +184,12 @@ Vector2D CHyprXWaylandManager::waylandToXWaylandCoords(const Vector2D& coord) {
         return Vector2D{};
 
     // get local coords
-    Vector2D result = coord - pMonitor->vecPosition;
+    Vector2D result = coord - pMonitor->m_position;
     // if scaled, scale
     if (*PXWLFORCESCALEZERO)
-        result *= pMonitor->scale;
+        result *= pMonitor->m_scale;
     // add pos
-    result += pMonitor->vecXWaylandPosition;
+    result += pMonitor->m_xwaylandPosition;
 
     return result;
 }
@@ -201,10 +201,10 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
     PHLMONITOR  pMonitor     = nullptr;
     double      bestDistance = __FLT_MAX__;
     for (const auto& m : g_pCompositor->m_monitors) {
-        const auto SIZ = *PXWLFORCESCALEZERO ? m->vecTransformedSize : m->vecSize;
+        const auto SIZ = *PXWLFORCESCALEZERO ? m->m_transformedSize : m->m_size;
 
         double     distance =
-            vecToRectDistanceSquared(coord, {m->vecXWaylandPosition.x, m->vecXWaylandPosition.y}, {m->vecXWaylandPosition.x + SIZ.x - 1, m->vecXWaylandPosition.y + SIZ.y - 1});
+            vecToRectDistanceSquared(coord, {m->m_xwaylandPosition.x, m->m_xwaylandPosition.y}, {m->m_xwaylandPosition.x + SIZ.x - 1, m->m_xwaylandPosition.y + SIZ.y - 1});
 
         if (distance < bestDistance) {
             bestDistance = distance;
@@ -216,12 +216,12 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
         return Vector2D{};
 
     // get local coords
-    Vector2D result = coord - pMonitor->vecXWaylandPosition;
+    Vector2D result = coord - pMonitor->m_xwaylandPosition;
     // if scaled, unscale
     if (*PXWLFORCESCALEZERO)
-        result /= pMonitor->scale;
+        result /= pMonitor->m_scale;
     // add pos
-    result += pMonitor->vecPosition;
+    result += pMonitor->m_position;
 
     return result;
 }
diff --git a/src/managers/input/InputManager.cpp b/src/managers/input/InputManager.cpp
index ab5e59a0..e1856f1d 100644
--- a/src/managers/input/InputManager.cpp
+++ b/src/managers/input/InputManager.cpp
@@ -217,7 +217,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
 
     bool skipFrameSchedule = PMONITOR->shouldSkipScheduleFrameOnMouseEvent();
 
-    if (!PMONITOR->solitaryClient.lock() && g_pHyprRenderer->shouldRenderCursor() && g_pPointerManager->softwareLockedFor(PMONITOR->self.lock()) && !skipFrameSchedule)
+    if (!PMONITOR->m_solitaryClient.lock() && g_pHyprRenderer->shouldRenderCursor() && g_pPointerManager->softwareLockedFor(PMONITOR->m_self.lock()) && !skipFrameSchedule)
         g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE);
 
     // constraints
@@ -252,13 +252,13 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
     if (g_pSessionLockManager->isSessionLocked()) {
 
         // set keyboard focus on session lock surface regardless of layers
-        const auto PSESSIONLOCKSURFACE = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->ID);
+        const auto PSESSIONLOCKSURFACE = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->m_id);
         const auto foundLockSurface    = PSESSIONLOCKSURFACE ? PSESSIONLOCKSURFACE->surface->surface() : nullptr;
 
         g_pCompositor->focusSurface(foundLockSurface);
 
         // search for interactable abovelock surfaces for pointer focus, or use session lock surface if not found
-        for (auto& lsl : PMONITOR->m_aLayerSurfaceLayers | std::views::reverse) {
+        for (auto& lsl : PMONITOR->m_layerSurfaceLayers | std::views::reverse) {
             foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &lsl, &surfaceCoords, &pFoundLayerSurface, true);
 
             if (foundSurface)
@@ -266,7 +266,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
         }
 
         if (!foundSurface) {
-            surfaceCoords = mouseCoords - PMONITOR->vecPosition;
+            surfaceCoords = mouseCoords - PMONITOR->m_position;
             foundSurface  = foundLockSurface;
         }
 
@@ -336,7 +336,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
 
     // overlays are above fullscreen
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
 
     // also IME popups
     if (!foundSurface) {
@@ -349,10 +349,10 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
 
     // also top layers
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface);
 
     // then, we check if the workspace doesnt have a fullscreen window
-    const auto PWORKSPACE   = PMONITOR->activeWorkspace;
+    const auto PWORKSPACE   = PMONITOR->m_activeWorkspace;
     const auto PWINDOWIDEAL = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING);
     if (PWORKSPACE->m_hasFullscreenWindow && !foundSurface && PWORKSPACE->m_fullscreenMode == FSMODE_FULLSCREEN) {
         pFoundWindow = PWORKSPACE->getFullscreenWindow();
@@ -365,7 +365,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
 
         if (PWINDOWIDEAL &&
             ((PWINDOWIDEAL->m_isFloating && PWINDOWIDEAL->m_createdOverFullscreen) /* floating over fullscreen */
-             || (PMONITOR->activeSpecialWorkspace == PWINDOWIDEAL->m_workspace) /* on an open special workspace */))
+             || (PMONITOR->m_activeSpecialWorkspace == PWINDOWIDEAL->m_workspace) /* on an open special workspace */))
             pFoundWindow = PWINDOWIDEAL;
 
         if (!pFoundWindow->m_isX11) {
@@ -381,7 +381,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
     if (!foundSurface) {
         if (PWORKSPACE->m_hasFullscreenWindow && PWORKSPACE->m_fullscreenMode == FSMODE_MAXIMIZED) {
             if (!foundSurface) {
-                if (PMONITOR->activeSpecialWorkspace) {
+                if (PMONITOR->m_activeSpecialWorkspace) {
                     if (pFoundWindow != PWINDOWIDEAL)
                         pFoundWindow = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING);
 
@@ -391,7 +391,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
                 } else {
                     // if we have a maximized window, allow focusing on a bar or something if in reserved area.
                     if (g_pCompositor->isPointOnReservedArea(mouseCoords, PMONITOR)) {
-                        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords,
+                        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords,
                                                                            &pFoundLayerSurface);
                     }
 
@@ -426,13 +426,12 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
 
     // then surfaces below
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords, &pFoundLayerSurface);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords, &pFoundLayerSurface);
 
     if (!foundSurface)
-        foundSurface =
-            g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords, &pFoundLayerSurface);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords, &pFoundLayerSurface);
 
-    if (g_pPointerManager->softwareLockedFor(PMONITOR->self.lock()) > 0 && !skipFrameSchedule)
+    if (g_pPointerManager->softwareLockedFor(PMONITOR->m_self.lock()) > 0 && !skipFrameSchedule)
         g_pCompositor->scheduleFrameForMonitor(g_pCompositor->m_lastMonitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE);
 
     // FIXME: This will be disabled during DnD operations because we do not exactly follow the spec
@@ -1471,14 +1470,14 @@ bool CInputManager::refocusLastWindow(PHLMONITOR pMonitor) {
 
     // then any surfaces above windows on the same monitor
     if (!foundSurface) {
-        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
                                                            &surfaceCoords, &pFoundLayerSurface);
         if (pFoundLayerSurface && pFoundLayerSurface->m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND)
             foundSurface = nullptr;
     }
 
     if (!foundSurface) {
-        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
                                                            &surfaceCoords, &pFoundLayerSurface);
         if (pFoundLayerSurface && pFoundLayerSurface->m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND)
             foundSurface = nullptr;
@@ -1636,7 +1635,7 @@ void CInputManager::setTouchDeviceConfigs(SP<ITouch> dev) {
             PTOUCHDEV->m_boundOutput = bound ? output : "";
             const auto PMONITOR      = bound ? g_pCompositor->getMonitorFromName(output) : nullptr;
             if (PMONITOR) {
-                Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV->m_hlName, PMONITOR->szName);
+                Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV->m_hlName, PMONITOR->m_name);
                 // wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, &PTOUCHDEV->wlr()->base, PMONITOR->output);
             } else if (bound)
                 Debug::log(ERR, "Failed to bind touch device {} to output '{}': monitor not found", PTOUCHDEV->m_hlName, output);
diff --git a/src/managers/input/InputMethodPopup.cpp b/src/managers/input/InputMethodPopup.cpp
index db08c026..d0706bad 100644
--- a/src/managers/input/InputMethodPopup.cpp
+++ b/src/managers/input/InputMethodPopup.cpp
@@ -40,7 +40,7 @@ void CInputPopup::onMap() {
     if (!PMONITOR)
         return;
 
-    PROTO::fractional->sendScale(surface->resource(), PMONITOR->scale);
+    PROTO::fractional->sendScale(surface->resource(), PMONITOR->m_scale);
 }
 
 void CInputPopup::onUnmap() {
@@ -108,12 +108,12 @@ void CInputPopup::updateBox() {
 
     Vector2D   popupOffset(0, 0);
 
-    if (parentBox.y + cursorBoxParent.y + cursorBoxParent.height + currentPopupSize.y > pMonitor->vecPosition.y + pMonitor->vecSize.y)
+    if (parentBox.y + cursorBoxParent.y + cursorBoxParent.height + currentPopupSize.y > pMonitor->m_position.y + pMonitor->m_size.y)
         popupOffset.y -= currentPopupSize.y;
     else
         popupOffset.y = cursorBoxParent.height;
 
-    double popupOverflow = parentBox.x + cursorBoxParent.x + currentPopupSize.x - (pMonitor->vecPosition.x + pMonitor->vecSize.x);
+    double popupOverflow = parentBox.x + cursorBoxParent.x + currentPopupSize.x - (pMonitor->m_position.x + pMonitor->m_size.x);
     if (popupOverflow > 0)
         popupOffset.x -= popupOverflow;
 
@@ -127,15 +127,15 @@ void CInputPopup::updateBox() {
     }
     damageSurface();
 
-    if (const auto PM = g_pCompositor->getMonitorFromCursor(); PM && PM->ID != lastMonitor) {
+    if (const auto PM = g_pCompositor->getMonitorFromCursor(); PM && PM->m_id != lastMonitor) {
         const auto PML = g_pCompositor->getMonitorFromID(lastMonitor);
 
         if (PML)
-            surface->resource()->leave(PML->self.lock());
+            surface->resource()->leave(PML->m_self.lock());
 
-        surface->resource()->enter(PM->self.lock());
+        surface->resource()->enter(PM->m_self.lock());
 
-        lastMonitor = PM->ID;
+        lastMonitor = PM->m_id;
     }
 }
 
diff --git a/src/managers/input/Swipe.cpp b/src/managers/input/Swipe.cpp
index c6916ee0..62c0332a 100644
--- a/src/managers/input/Swipe.cpp
+++ b/src/managers/input/Swipe.cpp
@@ -29,7 +29,7 @@ void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) {
 }
 
 void CInputManager::beginWorkspaceSwipe() {
-    const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+    const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
     Debug::log(LOG, "Starting a swipe from {}", PWORKSPACE->m_name);
 
@@ -40,7 +40,7 @@ void CInputManager::beginWorkspaceSwipe() {
     m_sActiveSwipe.speedPoints     = 0;
 
     if (PWORKSPACE->m_hasFullscreenWindow) {
-        for (auto const& ls : g_pCompositor->m_lastMonitor->m_aLayerSurfaceLayers[2]) {
+        for (auto const& ls : g_pCompositor->m_lastMonitor->m_layerSurfaceLayers[2]) {
             *ls->m_alpha = 1.f;
         }
     }
@@ -79,8 +79,8 @@ void CInputManager::endWorkspaceSwipe() {
     auto         PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);  // not guaranteed if PSWIPENUMBER
 
     const auto   RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->value();
-    const auto   XDISTANCE          = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP;
-    const auto   YDISTANCE          = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP;
+    const auto   XDISTANCE          = m_sActiveSwipe.pMonitor->m_size.x + *PWORKSPACEGAP;
+    const auto   YDISTANCE          = m_sActiveSwipe.pMonitor->m_size.y + *PWORKSPACEGAP;
 
     PHLWORKSPACE pSwitchedTo = nullptr;
 
@@ -122,7 +122,7 @@ void CInputManager::endWorkspaceSwipe() {
         if (PWORKSPACEL)
             m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDLeft);
         else {
-            m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDLeft, m_sActiveSwipe.pMonitor->ID));
+            m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDLeft, m_sActiveSwipe.pMonitor->m_id));
             PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
             PWORKSPACEL->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin);
         }
@@ -149,7 +149,7 @@ void CInputManager::endWorkspaceSwipe() {
         if (PWORKSPACER)
             m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDRight);
         else {
-            m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDRight, m_sActiveSwipe.pMonitor->ID));
+            m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDRight, m_sActiveSwipe.pMonitor->m_id));
             PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
             PWORKSPACER->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin);
         }
@@ -186,7 +186,7 @@ void CInputManager::endWorkspaceSwipe() {
     g_pInputManager->refocus();
 
     // apply alpha
-    for (auto const& ls : g_pCompositor->m_lastMonitor->m_aLayerSurfaceLayers[2]) {
+    for (auto const& ls : g_pCompositor->m_lastMonitor->m_layerSurfaceLayers[2]) {
         *ls->m_alpha = pSwitchedTo->m_hasFullscreenWindow && pSwitchedTo->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
     }
 }
@@ -214,8 +214,8 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
     static auto  PWORKSPACEGAP          = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
 
     const auto   SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX);
-    const auto   XDISTANCE     = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP;
-    const auto   YDISTANCE     = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP;
+    const auto   XDISTANCE     = m_sActiveSwipe.pMonitor->m_size.x + *PWORKSPACEGAP;
+    const auto   YDISTANCE     = m_sActiveSwipe.pMonitor->m_size.y + *PWORKSPACEGAP;
     const auto   ANIMSTYLE     = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle();
     const bool   VERTANIMS     = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert");
     const double d             = m_sActiveSwipe.delta - delta;
diff --git a/src/managers/input/Touch.cpp b/src/managers/input/Touch.cpp
index eab01528..f8964521 100644
--- a/src/managers/input/Touch.cpp
+++ b/src/managers/input/Touch.cpp
@@ -27,7 +27,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
 
     PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_lastMonitor.lock();
 
-    g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true);
+    g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
 
     refocus();
 
@@ -43,11 +43,11 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
         return;
         // TODO: Don't swipe if you touched a floating window.
     } else if (*PSWIPETOUCH && (m_pFoundLSToFocus.expired() || m_pFoundLSToFocus->m_layer <= 1) && !g_pSessionLockManager->isSessionLocked()) {
-        const auto   PWORKSPACE  = PMONITOR->activeWorkspace;
+        const auto   PWORKSPACE  = PMONITOR->m_activeWorkspace;
         const auto   STYLE       = PWORKSPACE->m_renderOffset->getStyle();
         const bool   VERTANIMS   = STYLE == "slidevert" || STYLE.starts_with("slidefadevert");
-        const double TARGETLEFT  = ((VERTANIMS ? gapsOut.m_top : gapsOut.m_left) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x);
-        const double TARGETRIGHT = 1 - (((VERTANIMS ? gapsOut.m_bottom : gapsOut.m_right) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x));
+        const double TARGETLEFT  = ((VERTANIMS ? gapsOut.m_top : gapsOut.m_left) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->m_size.y : PMONITOR->m_size.x);
+        const double TARGETRIGHT = 1 - (((VERTANIMS ? gapsOut.m_bottom : gapsOut.m_right) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->m_size.y : PMONITOR->m_size.x));
         const double POSITION    = (VERTANIMS ? e.pos.y : e.pos.x);
         if (POSITION < TARGETLEFT || POSITION > TARGETRIGHT) {
             beginWorkspaceSwipe();
@@ -62,7 +62,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
     }
 
     if (g_pSessionLockManager->isSessionLocked()) {
-        m_sTouchData.touchFocusLockSurface = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->ID);
+        m_sTouchData.touchFocusLockSurface = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->m_id);
         if (!m_sTouchData.touchFocusLockSurface)
             Debug::log(WARN, "The session is locked but can't find a lock surface");
         else
@@ -77,7 +77,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
     Vector2D local;
 
     if (m_sTouchData.touchFocusLockSurface) {
-        local                           = g_pInputManager->getMouseCoordsInternal() - PMONITOR->vecPosition;
+        local                           = g_pInputManager->getMouseCoordsInternal() - PMONITOR->m_position;
         m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local;
     } else if (!m_sTouchData.touchFocusWindow.expired()) {
         if (m_sTouchData.touchFocusWindow->m_isX11) {
@@ -144,13 +144,13 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
     }
     if (m_sTouchData.touchFocusLockSurface) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusLockSurface->iMonitorID);
-        g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true);
-        auto local = g_pInputManager->getMouseCoordsInternal() - PMONITOR->vecPosition;
+        g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
+        auto local = g_pInputManager->getMouseCoordsInternal() - PMONITOR->m_position;
         g_pSeatManager->sendTouchMotion(e.timeMs, e.touchID, local);
     } else if (validMapped(m_sTouchData.touchFocusWindow)) {
         const auto PMONITOR = m_sTouchData.touchFocusWindow->m_monitor.lock();
 
-        g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true);
+        g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
 
         auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;
         if (m_sTouchData.touchFocusWindow->m_isX11)
@@ -160,7 +160,7 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
     } else if (!m_sTouchData.touchFocusLS.expired()) {
         const auto PMONITOR = m_sTouchData.touchFocusLS->m_monitor.lock();
 
-        g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true);
+        g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
 
         const auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;
 
diff --git a/src/protocols/CTMControl.cpp b/src/protocols/CTMControl.cpp
index 125e717e..a6fad119 100644
--- a/src/protocols/CTMControl.cpp
+++ b/src/protocols/CTMControl.cpp
@@ -40,9 +40,9 @@ CHyprlandCTMControlResource::CHyprlandCTMControlResource(SP<CHyprlandCtmControlM
             }
         }
 
-        ctms[PMONITOR->szName] = MAT;
+        ctms[PMONITOR->m_name] = MAT;
 
-        LOGM(LOG, "CTM set for output {}: {}", PMONITOR->szName, ctms.at(PMONITOR->szName).toString());
+        LOGM(LOG, "CTM set for output {}: {}", PMONITOR->m_name, ctms.at(PMONITOR->m_name).toString());
     });
 
     resource->setCommit([this](CHyprlandCtmControlManagerV1* r) {
@@ -52,12 +52,12 @@ CHyprlandCTMControlResource::CHyprlandCTMControlResource(SP<CHyprlandCtmControlM
         LOGM(LOG, "Committing ctms to outputs");
 
         for (auto& m : g_pCompositor->m_monitors) {
-            if (!ctms.contains(m->szName)) {
+            if (!ctms.contains(m->m_name)) {
                 PROTO::ctm->setCTM(m, Mat3x3::identity());
                 continue;
             }
 
-            PROTO::ctm->setCTM(m, ctms.at(m->szName));
+            PROTO::ctm->setCTM(m, ctms.at(m->m_name));
         }
     });
 }
diff --git a/src/protocols/ColorManagement.cpp b/src/protocols/ColorManagement.cpp
index 29d9d248..812ac4c6 100644
--- a/src/protocols/ColorManagement.cpp
+++ b/src/protocols/ColorManagement.cpp
@@ -235,7 +235,7 @@ CColorManagementOutput::CColorManagementOutput(SP<CWpColorManagementOutputV1> re
         if (!m_monitor.valid())
             RESOURCE->m_resource->sendFailed(WP_IMAGE_DESCRIPTION_V1_CAUSE_NO_OUTPUT, "No output");
         else {
-            RESOURCE->settings = m_monitor->imageDescription;
+            RESOURCE->settings = m_monitor->m_imageDescription;
             RESOURCE->m_resource->sendReady(RESOURCE->settings.updateId());
         }
     });
diff --git a/src/protocols/DRMLease.cpp b/src/protocols/DRMLease.cpp
index 2fd1b890..80c34d23 100644
--- a/src/protocols/DRMLease.cpp
+++ b/src/protocols/DRMLease.cpp
@@ -17,8 +17,8 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
     requested = request->requested;
 
     for (auto const& m : requested) {
-        if (!m->monitor || m->monitor->isBeingLeased) {
-            LOGM(ERR, "Rejecting lease: no monitor or monitor is being leased for {}", (m->monitor ? m->monitor->szName : "null"));
+        if (!m->monitor || m->monitor->m_isBeingLeased) {
+            LOGM(ERR, "Rejecting lease: no monitor or monitor is being leased for {}", (m->monitor ? m->monitor->m_name : "null"));
             resource->sendFinished();
             return;
         }
@@ -29,7 +29,7 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
     LOGM(LOG, "Leasing outputs: {}", [this]() {
         std::string roll;
         for (auto const& o : requested) {
-            roll += std::format("{} ", o->monitor->szName);
+            roll += std::format("{} ", o->monitor->m_name);
         }
         return roll;
     }());
@@ -39,7 +39,7 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
     outputs.reserve(requested.size());
 
     for (auto const& m : requested) {
-        outputs.emplace_back(m->monitor->output);
+        outputs.emplace_back(m->monitor->m_output);
     }
 
     auto aqlease = Aquamarine::CDRMLease::create(outputs);
@@ -52,13 +52,13 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
     lease = aqlease;
 
     for (auto const& m : requested) {
-        m->monitor->isBeingLeased = true;
+        m->monitor->m_isBeingLeased = true;
     }
 
     listeners.destroyLease = lease->events.destroy.registerListener([this](std::any d) {
         for (auto const& m : requested) {
             if (m && m->monitor)
-                m->monitor->isBeingLeased = false;
+                m->monitor->m_isBeingLeased = false;
         }
 
         resource->sendFinished();
@@ -143,7 +143,7 @@ CDRMLeaseConnectorResource::CDRMLeaseConnectorResource(SP<CWpDrmLeaseConnectorV1
 
     resource->setData(this);
 
-    listeners.destroyMonitor = monitor->events.destroy.registerListener([this](std::any d) {
+    listeners.destroyMonitor = monitor->m_events.destroy.registerListener([this](std::any d) {
         resource->sendWithdrawn();
         dead = true;
     });
@@ -154,10 +154,10 @@ bool CDRMLeaseConnectorResource::good() {
 }
 
 void CDRMLeaseConnectorResource::sendData() {
-    resource->sendName(monitor->szName.c_str());
-    resource->sendDescription(monitor->szDescription.c_str());
+    resource->sendName(monitor->m_name.c_str());
+    resource->sendDescription(monitor->m_description.c_str());
 
-    auto AQDRMOutput = (Aquamarine::CDRMOutput*)monitor->output.get();
+    auto AQDRMOutput = (Aquamarine::CDRMOutput*)monitor->m_output.get();
     resource->sendConnectorId(AQDRMOutput->getConnectorID());
 
     resource->sendDone();
@@ -220,7 +220,7 @@ void CDRMLeaseDeviceResource::sendConnector(PHLMONITOR monitor) {
     RESOURCE->parent = self;
     RESOURCE->self   = RESOURCE;
 
-    LOGM(LOG, "Sending new connector {}", monitor->szName);
+    LOGM(LOG, "Sending new connector {}", monitor->m_name);
 
     connectorsSent.emplace_back(RESOURCE);
     PROTO::lease->m_vConnectors.emplace_back(RESOURCE);
@@ -297,11 +297,11 @@ void CDRMLeaseProtocol::offer(PHLMONITOR monitor) {
     if (std::find(primaryDevice->offeredOutputs.begin(), primaryDevice->offeredOutputs.end(), monitor) != primaryDevice->offeredOutputs.end())
         return;
 
-    if (monitor->output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
+    if (monitor->m_output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
         return;
 
-    if (monitor->output->getBackend() != primaryDevice->backend) {
-        LOGM(ERR, "Monitor {} cannot be leased: primaryDevice lease is for a different device", monitor->szName);
+    if (monitor->m_output->getBackend() != primaryDevice->backend) {
+        LOGM(ERR, "Monitor {} cannot be leased: primaryDevice lease is for a different device", monitor->m_name);
         return;
     }
 
diff --git a/src/protocols/ForeignToplevelWlr.cpp b/src/protocols/ForeignToplevelWlr.cpp
index 089c414b..2a2929e5 100644
--- a/src/protocols/ForeignToplevelWlr.cpp
+++ b/src/protocols/ForeignToplevelWlr.cpp
@@ -46,8 +46,8 @@ CForeignToplevelHandleWlr::CForeignToplevelHandleWlr(SP<CZwlrForeignToplevelHand
             if (!wpMonitor.expired()) {
                 const auto monitor = wpMonitor.lock();
 
-                if (PWINDOW->m_workspace != monitor->activeWorkspace) {
-                    g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, monitor->activeWorkspace);
+                if (PWINDOW->m_workspace != monitor->m_activeWorkspace) {
+                    g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, monitor->m_activeWorkspace);
                     g_pCompositor->setActiveMonitor(monitor);
                 }
             }
@@ -145,26 +145,26 @@ wl_resource* CForeignToplevelHandleWlr::res() {
 }
 
 void CForeignToplevelHandleWlr::sendMonitor(PHLMONITOR pMonitor) {
-    if (lastMonitorID == pMonitor->ID)
+    if (lastMonitorID == pMonitor->m_id)
         return;
 
     const auto CLIENT = resource->client();
 
-    if (const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(lastMonitorID); PLASTMONITOR && PROTO::outputs.contains(PLASTMONITOR->szName)) {
-        const auto OLDRESOURCE = PROTO::outputs.at(PLASTMONITOR->szName)->outputResourceFrom(CLIENT);
+    if (const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(lastMonitorID); PLASTMONITOR && PROTO::outputs.contains(PLASTMONITOR->m_name)) {
+        const auto OLDRESOURCE = PROTO::outputs.at(PLASTMONITOR->m_name)->outputResourceFrom(CLIENT);
 
         if LIKELY (OLDRESOURCE)
             resource->sendOutputLeave(OLDRESOURCE->getResource()->resource());
     }
 
-    if (PROTO::outputs.contains(pMonitor->szName)) {
-        const auto NEWRESOURCE = PROTO::outputs.at(pMonitor->szName)->outputResourceFrom(CLIENT);
+    if (PROTO::outputs.contains(pMonitor->m_name)) {
+        const auto NEWRESOURCE = PROTO::outputs.at(pMonitor->m_name)->outputResourceFrom(CLIENT);
 
         if LIKELY (NEWRESOURCE)
             resource->sendOutputEnter(NEWRESOURCE->getResource()->resource());
     }
 
-    lastMonitorID = pMonitor->ID;
+    lastMonitorID = pMonitor->m_id;
 }
 
 void CForeignToplevelHandleWlr::sendState() {
diff --git a/src/protocols/GammaControl.cpp b/src/protocols/GammaControl.cpp
index 0a383e2e..322f0e56 100644
--- a/src/protocols/GammaControl.cpp
+++ b/src/protocols/GammaControl.cpp
@@ -20,7 +20,7 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
 
     pMonitor = OUTPUTRES->monitor;
 
-    if UNLIKELY (!pMonitor || !pMonitor->output) {
+    if UNLIKELY (!pMonitor || !pMonitor->m_output) {
         LOGM(ERR, "No CMonitor");
         resource->sendFailed();
         return;
@@ -33,10 +33,10 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
         }
     }
 
-    gammaSize = pMonitor->output->getGammaSize();
+    gammaSize = pMonitor->m_output->getGammaSize();
 
     if UNLIKELY (gammaSize <= 0) {
-        LOGM(ERR, "Output {} doesn't support gamma", pMonitor->szName);
+        LOGM(ERR, "Output {} doesn't support gamma", pMonitor->m_name);
         resource->sendFailed();
         return;
     }
@@ -54,7 +54,7 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
             return;
         }
 
-        LOGM(LOG, "setGamma for {}", pMonitor->szName);
+        LOGM(LOG, "setGamma for {}", pMonitor->m_name);
 
         // TODO: make CFileDescriptor getflags use F_GETFL
         int fdFlags = fcntl(gammaFd.get(), F_GETFL, 0);
@@ -108,16 +108,16 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
 
     resource->sendGammaSize(gammaSize);
 
-    listeners.monitorDestroy    = pMonitor->events.destroy.registerListener([this](std::any) { this->onMonitorDestroy(); });
-    listeners.monitorDisconnect = pMonitor->events.disconnect.registerListener([this](std::any) { this->onMonitorDestroy(); });
+    listeners.monitorDestroy    = pMonitor->m_events.destroy.registerListener([this](std::any) { this->onMonitorDestroy(); });
+    listeners.monitorDisconnect = pMonitor->m_events.disconnect.registerListener([this](std::any) { this->onMonitorDestroy(); });
 }
 
 CGammaControl::~CGammaControl() {
-    if (!gammaTableSet || !pMonitor || !pMonitor->output)
+    if (!gammaTableSet || !pMonitor || !pMonitor->m_output)
         return;
 
     // reset the LUT if the client dies for whatever reason and doesn't unset the gamma
-    pMonitor->output->state->setGammaLut({});
+    pMonitor->m_output->state->setGammaLut({});
 }
 
 bool CGammaControl::good() {
@@ -125,21 +125,21 @@ bool CGammaControl::good() {
 }
 
 void CGammaControl::applyToMonitor() {
-    if UNLIKELY (!pMonitor || !pMonitor->output)
+    if UNLIKELY (!pMonitor || !pMonitor->m_output)
         return; // ??
 
-    LOGM(LOG, "setting to monitor {}", pMonitor->szName);
+    LOGM(LOG, "setting to monitor {}", pMonitor->m_name);
 
     if (!gammaTableSet) {
-        pMonitor->output->state->setGammaLut({});
+        pMonitor->m_output->state->setGammaLut({});
         return;
     }
 
-    pMonitor->output->state->setGammaLut(gammaTable);
+    pMonitor->m_output->state->setGammaLut(gammaTable);
 
-    if (!pMonitor->state.test()) {
-        LOGM(LOG, "setting to monitor {} failed", pMonitor->szName);
-        pMonitor->output->state->setGammaLut({});
+    if (!pMonitor->m_state.test()) {
+        LOGM(LOG, "setting to monitor {} failed", pMonitor->m_name);
+        pMonitor->m_output->state->setGammaLut({});
     }
 
     g_pHyprRenderer->damageMonitor(pMonitor.lock());
@@ -150,7 +150,7 @@ PHLMONITOR CGammaControl::getMonitor() {
 }
 
 void CGammaControl::onMonitorDestroy() {
-    LOGM(LOG, "Destroying gamma control for {}", pMonitor->szName);
+    LOGM(LOG, "Destroying gamma control for {}", pMonitor->m_name);
     resource->sendFailed();
 }
 
diff --git a/src/protocols/LayerShell.cpp b/src/protocols/LayerShell.cpp
index 0b64e7fd..7f5d366a 100644
--- a/src/protocols/LayerShell.cpp
+++ b/src/protocols/LayerShell.cpp
@@ -22,7 +22,7 @@ CLayerShellResource::CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<C
         return;
 
     current.layer = layer;
-    monitor       = pMonitor ? pMonitor->szName : "";
+    monitor       = pMonitor ? pMonitor->m_name : "";
 
     resource->setDestroy([this](CZwlrLayerSurfaceV1* r) {
         events.destroy.emit();
diff --git a/src/protocols/LinuxDMABUF.cpp b/src/protocols/LinuxDMABUF.cpp
index d42ddf41..2a067bf7 100644
--- a/src/protocols/LinuxDMABUF.cpp
+++ b/src/protocols/LinuxDMABUF.cpp
@@ -436,7 +436,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
                 auto tranche = SDMABUFTranche{
                     .device  = mainDevice,
                     .flags   = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
-                    .formats = mon->output->getRenderFormats(),
+                    .formats = mon->m_output->getRenderFormats(),
                 };
                 tches.emplace_back(std::make_pair<>(mon, tranche));
             }
@@ -446,7 +446,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
                 auto tranche  = SDMABUFTranche{
                      .device  = mainDevice,
                      .flags   = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
-                     .formats = pMonitor->output->getRenderFormats(),
+                     .formats = pMonitor->m_output->getRenderFormats(),
                 };
                 formatTable->monitorTranches.emplace_back(std::make_pair<>(pMonitor, tranche));
                 resetFormatTable();
@@ -500,7 +500,7 @@ void CLinuxDMABufV1Protocol::resetFormatTable() {
             auto       HLSurface = CWLSurface::fromResource(feedback->surface);
             if (auto w = HLSurface->getWindow(); w)
                 if (auto m = w->m_monitor.lock(); m)
-                    mon = m->self.lock();
+                    mon = m->m_self.lock();
 
             if (!mon) {
                 feedback->sendDefaultFeedback();
diff --git a/src/protocols/OutputManagement.cpp b/src/protocols/OutputManagement.cpp
index 1e3835a6..4af7a6e2 100644
--- a/src/protocols/OutputManagement.cpp
+++ b/src/protocols/OutputManagement.cpp
@@ -35,7 +35,7 @@ COutputManager::COutputManager(SP<CZwlrOutputManagerV1> resource_) : resource(re
         if (m == g_pCompositor->m_unsafeOutput)
             continue;
 
-        LOGM(LOG, " | sending output head for {}", m->szName);
+        LOGM(LOG, " | sending output head for {}", m->m_name);
 
         makeAndSendNewHead(m);
     }
@@ -96,7 +96,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_)
     resource->setRelease([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
     resource->setOnDestroy([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
 
-    listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any d) {
+    listeners.monitorDestroy = pMonitor->m_events.destroy.registerListener([this](std::any d) {
         resource->sendFinished();
 
         for (auto const& mw : modes) {
@@ -114,7 +114,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_)
         }
     });
 
-    listeners.monitorModeChange = pMonitor->events.modeChanged.registerListener([this](std::any d) { updateMode(); });
+    listeners.monitorModeChange = pMonitor->m_events.modeChanged.registerListener([this](std::any d) { updateMode(); });
 }
 
 bool COutputHead::good() {
@@ -124,54 +124,54 @@ bool COutputHead::good() {
 void COutputHead::sendAllData() {
     const auto VERSION = resource->version();
 
-    resource->sendName(pMonitor->szName.c_str());
-    resource->sendDescription(pMonitor->szDescription.c_str());
-    if (pMonitor->output->physicalSize.x > 0 && pMonitor->output->physicalSize.y > 0)
-        resource->sendPhysicalSize(pMonitor->output->physicalSize.x, pMonitor->output->physicalSize.y);
-    resource->sendEnabled(pMonitor->m_bEnabled);
+    resource->sendName(pMonitor->m_name.c_str());
+    resource->sendDescription(pMonitor->m_description.c_str());
+    if (pMonitor->m_output->physicalSize.x > 0 && pMonitor->m_output->physicalSize.y > 0)
+        resource->sendPhysicalSize(pMonitor->m_output->physicalSize.x, pMonitor->m_output->physicalSize.y);
+    resource->sendEnabled(pMonitor->m_enabled);
 
-    if (pMonitor->m_bEnabled) {
-        resource->sendPosition(pMonitor->vecPosition.x, pMonitor->vecPosition.y);
-        resource->sendTransform(pMonitor->transform);
-        resource->sendScale(wl_fixed_from_double(pMonitor->scale));
+    if (pMonitor->m_enabled) {
+        resource->sendPosition(pMonitor->m_position.x, pMonitor->m_position.y);
+        resource->sendTransform(pMonitor->m_transform);
+        resource->sendScale(wl_fixed_from_double(pMonitor->m_scale));
     }
 
-    if (!pMonitor->output->make.empty() && VERSION >= 2)
-        resource->sendMake(pMonitor->output->make.c_str());
-    if (!pMonitor->output->model.empty() && VERSION >= 2)
-        resource->sendModel(pMonitor->output->model.c_str());
-    if (!pMonitor->output->serial.empty() && VERSION >= 2)
-        resource->sendSerialNumber(pMonitor->output->serial.c_str());
+    if (!pMonitor->m_output->make.empty() && VERSION >= 2)
+        resource->sendMake(pMonitor->m_output->make.c_str());
+    if (!pMonitor->m_output->model.empty() && VERSION >= 2)
+        resource->sendModel(pMonitor->m_output->model.c_str());
+    if (!pMonitor->m_output->serial.empty() && VERSION >= 2)
+        resource->sendSerialNumber(pMonitor->m_output->serial.c_str());
 
     if (VERSION >= 4)
-        resource->sendAdaptiveSync(pMonitor->vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
+        resource->sendAdaptiveSync(pMonitor->m_vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
 
     // send all available modes
 
     if (modes.empty()) {
-        if (!pMonitor->output->modes.empty()) {
-            for (auto const& m : pMonitor->output->modes) {
+        if (!pMonitor->m_output->modes.empty()) {
+            for (auto const& m : pMonitor->m_output->modes) {
                 makeAndSendNewMode(m);
             }
-        } else if (pMonitor->output->state->state().customMode) {
-            makeAndSendNewMode(pMonitor->output->state->state().customMode);
+        } else if (pMonitor->m_output->state->state().customMode) {
+            makeAndSendNewMode(pMonitor->m_output->state->state().customMode);
         } else
             makeAndSendNewMode(nullptr);
     }
 
     // send current mode
-    if (pMonitor->m_bEnabled) {
+    if (pMonitor->m_enabled) {
         for (auto const& mw : modes) {
             auto m = mw.lock();
 
             if (!m)
                 continue;
 
-            if (m->mode == pMonitor->output->state->state().mode) {
+            if (m->mode == pMonitor->m_output->state->state().mode) {
                 if (m->mode)
-                    LOGM(LOG, "  | sending current mode for {}: {}x{}@{}", pMonitor->szName, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate);
+                    LOGM(LOG, "  | sending current mode for {}: {}x{}@{}", pMonitor->m_name, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate);
                 else
-                    LOGM(LOG, "  | sending current mode for {}: null (fake)", pMonitor->szName);
+                    LOGM(LOG, "  | sending current mode for {}: null (fake)", pMonitor->m_name);
                 resource->sendCurrentMode(m->resource.get());
                 break;
             }
@@ -180,29 +180,29 @@ void COutputHead::sendAllData() {
 }
 
 void COutputHead::updateMode() {
-    resource->sendEnabled(pMonitor->m_bEnabled);
+    resource->sendEnabled(pMonitor->m_enabled);
 
-    if (pMonitor->m_bEnabled) {
-        resource->sendPosition(pMonitor->vecPosition.x, pMonitor->vecPosition.y);
-        resource->sendTransform(pMonitor->transform);
-        resource->sendScale(wl_fixed_from_double(pMonitor->scale));
+    if (pMonitor->m_enabled) {
+        resource->sendPosition(pMonitor->m_position.x, pMonitor->m_position.y);
+        resource->sendTransform(pMonitor->m_transform);
+        resource->sendScale(wl_fixed_from_double(pMonitor->m_scale));
     }
 
     if (resource->version() >= 4)
-        resource->sendAdaptiveSync(pMonitor->vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
+        resource->sendAdaptiveSync(pMonitor->m_vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
 
-    if (pMonitor->m_bEnabled) {
+    if (pMonitor->m_enabled) {
         for (auto const& mw : modes) {
             auto m = mw.lock();
 
             if (!m)
                 continue;
 
-            if (m->mode == pMonitor->currentMode) {
+            if (m->mode == pMonitor->m_currentMode) {
                 if (m->mode)
-                    LOGM(LOG, "  | sending current mode for {}: {}x{}@{}", pMonitor->szName, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate);
+                    LOGM(LOG, "  | sending current mode for {}: {}x{}@{}", pMonitor->m_name, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate);
                 else
-                    LOGM(LOG, "  | sending current mode for {}: null (fake)", pMonitor->szName);
+                    LOGM(LOG, "  | sending current mode for {}: null (fake)", pMonitor->m_name);
                 resource->sendCurrentMode(m->resource.get());
                 break;
             }
@@ -290,7 +290,7 @@ COutputConfiguration::COutputConfiguration(SP<CZwlrOutputConfigurationV1> resour
 
         heads.emplace_back(RESOURCE);
 
-        LOGM(LOG, "enableHead on {}. For now, doing nothing. Waiting for apply().", PMONITOR->szName);
+        LOGM(LOG, "enableHead on {}. For now, doing nothing. Waiting for apply().", PMONITOR->m_name);
     });
 
     resource->setDisableHead([this](CZwlrOutputConfigurationV1* r, wl_resource* outputHead) {
@@ -308,17 +308,17 @@ COutputConfiguration::COutputConfiguration(SP<CZwlrOutputConfigurationV1> resour
             return;
         }
 
-        LOGM(LOG, "disableHead on {}", PMONITOR->szName);
+        LOGM(LOG, "disableHead on {}", PMONITOR->m_name);
 
         SWlrManagerSavedOutputState newState;
-        if (owner->monitorStates.contains(PMONITOR->szName))
-            newState = owner->monitorStates.at(PMONITOR->szName);
+        if (owner->monitorStates.contains(PMONITOR->m_name))
+            newState = owner->monitorStates.at(PMONITOR->m_name);
 
         newState.enabled = false;
 
         g_pConfigManager->m_wantsMonitorReload = true;
 
-        owner->monitorStates[PMONITOR->szName] = newState;
+        owner->monitorStates[PMONITOR->m_name] = newState;
     });
 
     resource->setTest([this](CZwlrOutputConfigurationV1* r) {
@@ -370,11 +370,11 @@ bool COutputConfiguration::applyTestConfiguration(bool test) {
         if (!PMONITOR)
             continue;
 
-        LOGM(LOG, "Saving config for monitor {}", PMONITOR->szName);
+        LOGM(LOG, "Saving config for monitor {}", PMONITOR->m_name);
 
         SWlrManagerSavedOutputState newState;
-        if (owner->monitorStates.contains(PMONITOR->szName))
-            newState = owner->monitorStates.at(PMONITOR->szName);
+        if (owner->monitorStates.contains(PMONITOR->m_name))
+            newState = owner->monitorStates.at(PMONITOR->m_name);
 
         newState.enabled = true;
 
@@ -419,7 +419,7 @@ bool COutputConfiguration::applyTestConfiguration(bool test) {
 
         g_pConfigManager->m_wantsMonitorReload = true;
 
-        owner->monitorStates[PMONITOR->szName] = newState;
+        owner->monitorStates[PMONITOR->m_name] = newState;
     }
 
     LOGM(LOG, "Saved configuration");
@@ -454,7 +454,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
         state.committedProperties |= OUTPUT_HEAD_COMMITTED_MODE;
         state.mode = MODE;
 
-        LOGM(LOG, " | configHead for {}: set mode to {}x{}@{}", pMonitor->szName, MODE->getMode()->pixelSize.x, MODE->getMode()->pixelSize.y, MODE->getMode()->refreshRate);
+        LOGM(LOG, " | configHead for {}: set mode to {}x{}@{}", pMonitor->m_name, MODE->getMode()->pixelSize.x, MODE->getMode()->pixelSize.y, MODE->getMode()->refreshRate);
     });
 
     resource->setSetCustomMode([this](CZwlrOutputConfigurationHeadV1* r, int32_t w, int32_t h, int32_t refresh) {
@@ -474,14 +474,14 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
         }
 
         if (refresh == 0) {
-            LOGM(LOG, " | configHead for {}: refreshRate 0, using old refresh rate of {:.2f}Hz", pMonitor->szName, pMonitor->refreshRate);
-            refresh = std::round(pMonitor->refreshRate * 1000.F);
+            LOGM(LOG, " | configHead for {}: refreshRate 0, using old refresh rate of {:.2f}Hz", pMonitor->m_name, pMonitor->m_refreshRate);
+            refresh = std::round(pMonitor->m_refreshRate * 1000.F);
         }
 
         state.committedProperties |= OUTPUT_HEAD_COMMITTED_CUSTOM_MODE;
         state.customMode = {{w, h}, (uint32_t)refresh};
 
-        LOGM(LOG, " | configHead for {}: set custom mode to {}x{}@{}", pMonitor->szName, w, h, refresh);
+        LOGM(LOG, " | configHead for {}: set custom mode to {}x{}@{}", pMonitor->m_name, w, h, refresh);
     });
 
     resource->setSetPosition([this](CZwlrOutputConfigurationHeadV1* r, int32_t x, int32_t y) {
@@ -498,7 +498,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
         state.committedProperties |= OUTPUT_HEAD_COMMITTED_POSITION;
         state.position = {x, y};
 
-        LOGM(LOG, " | configHead for {}: set pos to {}, {}", pMonitor->szName, x, y);
+        LOGM(LOG, " | configHead for {}: set pos to {}, {}", pMonitor->m_name, x, y);
     });
 
     resource->setSetTransform([this](CZwlrOutputConfigurationHeadV1* r, int32_t transform) {
@@ -520,7 +520,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
         state.committedProperties |= OUTPUT_HEAD_COMMITTED_TRANSFORM;
         state.transform = (wl_output_transform)transform;
 
-        LOGM(LOG, " | configHead for {}: set transform to {}", pMonitor->szName, transform);
+        LOGM(LOG, " | configHead for {}: set transform to {}", pMonitor->m_name, transform);
     });
 
     resource->setSetScale([this](CZwlrOutputConfigurationHeadV1* r, wl_fixed_t scale_) {
@@ -544,7 +544,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
         state.committedProperties |= OUTPUT_HEAD_COMMITTED_SCALE;
         state.scale = scale;
 
-        LOGM(LOG, " | configHead for {}: set scale to {:.2f}", pMonitor->szName, scale);
+        LOGM(LOG, " | configHead for {}: set scale to {:.2f}", pMonitor->m_name, scale);
     });
 
     resource->setSetAdaptiveSync([this](CZwlrOutputConfigurationHeadV1* r, uint32_t as) {
@@ -566,7 +566,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
         state.committedProperties |= OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC;
         state.adaptiveSync = as;
 
-        LOGM(LOG, " | configHead for {}: set adaptiveSync to {}", pMonitor->szName, as);
+        LOGM(LOG, " | configHead for {}: set adaptiveSync to {}", pMonitor->m_name, as);
     });
 }
 
@@ -638,10 +638,10 @@ SP<COutputMode> COutputManagementProtocol::modeFromResource(wl_resource* r) {
 
 SP<SWlrManagerSavedOutputState> COutputManagementProtocol::getOutputStateFor(PHLMONITOR pMonitor) {
     for (auto const& m : m_vManagers) {
-        if (!m->monitorStates.contains(pMonitor->szName))
+        if (!m->monitorStates.contains(pMonitor->m_name))
             continue;
 
-        return makeShared<SWlrManagerSavedOutputState>(m->monitorStates.at(pMonitor->szName));
+        return makeShared<SWlrManagerSavedOutputState>(m->monitorStates.at(pMonitor->m_name));
     }
 
     return nullptr;
diff --git a/src/protocols/OutputPower.cpp b/src/protocols/OutputPower.cpp
index 24106817..55ea0376 100644
--- a/src/protocols/OutputPower.cpp
+++ b/src/protocols/OutputPower.cpp
@@ -13,25 +13,25 @@ COutputPower::COutputPower(SP<CZwlrOutputPowerV1> resource_, PHLMONITOR pMonitor
         if (!pMonitor)
             return;
 
-        pMonitor->dpmsStatus = mode == ZWLR_OUTPUT_POWER_V1_MODE_ON;
+        pMonitor->m_dpmsStatus = mode == ZWLR_OUTPUT_POWER_V1_MODE_ON;
 
-        pMonitor->output->state->setEnabled(mode == ZWLR_OUTPUT_POWER_V1_MODE_ON);
+        pMonitor->m_output->state->setEnabled(mode == ZWLR_OUTPUT_POWER_V1_MODE_ON);
 
-        if (!pMonitor->state.commit())
-            LOGM(ERR, "Couldn't set dpms to {} for {}", pMonitor->dpmsStatus, pMonitor->szName);
+        if (!pMonitor->m_state.commit())
+            LOGM(ERR, "Couldn't set dpms to {} for {}", pMonitor->m_dpmsStatus, pMonitor->m_name);
     });
 
-    resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF);
+    resource->sendMode(pMonitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF);
 
-    listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any v) {
+    listeners.monitorDestroy = pMonitor->m_events.destroy.registerListener([this](std::any v) {
         pMonitor.reset();
         resource->sendFailed();
     });
 
-    listeners.monitorDpms = pMonitor->events.dpmsChanged.registerListener(
-        [this](std::any v) { resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
-    listeners.monitorState = pMonitor->events.modeChanged.registerListener(
-        [this](std::any v) { resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
+    listeners.monitorDpms = pMonitor->m_events.dpmsChanged.registerListener(
+        [this](std::any v) { resource->sendMode(pMonitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
+    listeners.monitorState = pMonitor->m_events.modeChanged.registerListener(
+        [this](std::any v) { resource->sendMode(pMonitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
 }
 
 bool COutputPower::good() {
diff --git a/src/protocols/PresentationTime.cpp b/src/protocols/PresentationTime.cpp
index b8f06cd3..e002bc28 100644
--- a/src/protocols/PresentationTime.cpp
+++ b/src/protocols/PresentationTime.cpp
@@ -43,13 +43,13 @@ bool CPresentationFeedback::good() {
 void CPresentationFeedback::sendQueued(SP<CQueuedPresentationData> data, const Time::steady_tp& when, uint32_t untilRefreshNs, uint64_t seq, uint32_t reportedFlags) {
     auto client = resource->client();
 
-    if LIKELY (PROTO::outputs.contains(data->pMonitor->szName)) {
-        if LIKELY (auto outputResource = PROTO::outputs.at(data->pMonitor->szName)->outputResourceFrom(client); outputResource)
+    if LIKELY (PROTO::outputs.contains(data->pMonitor->m_name)) {
+        if LIKELY (auto outputResource = PROTO::outputs.at(data->pMonitor->m_name)->outputResourceFrom(client); outputResource)
             resource->sendSyncOutput(outputResource->getResource()->resource());
     }
 
     uint32_t flags = 0;
-    if (!data->pMonitor->tearingState.activelyTearing)
+    if (!data->pMonitor->m_tearingState.activelyTearing)
         flags |= WP_PRESENTATION_FEEDBACK_KIND_VSYNC;
     if (data->zeroCopy)
         flags |= WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY;
diff --git a/src/protocols/Screencopy.cpp b/src/protocols/Screencopy.cpp
index 6727bcf4..28523fde 100644
--- a/src/protocols/Screencopy.cpp
+++ b/src/protocols/Screencopy.cpp
@@ -58,15 +58,15 @@ CScreencopyFrame::CScreencopyFrame(SP<CZwlrScreencopyFrameV1> resource_, int32_t
         return;
     }
 
-    dmabufFormat = pMonitor->output->state->state().drmFormat;
+    dmabufFormat = pMonitor->m_output->state->state().drmFormat;
 
     if (box_.width == 0 && box_.height == 0)
-        box = {0, 0, (int)(pMonitor->vecSize.x), (int)(pMonitor->vecSize.y)};
+        box = {0, 0, (int)(pMonitor->m_size.x), (int)(pMonitor->m_size.y)};
     else {
         box = box_;
     }
 
-    box.transform(wlTransformToHyprutils(pMonitor->transform), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y).scale(pMonitor->scale).round();
+    box.transform(wlTransformToHyprutils(pMonitor->m_transform), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y).scale(pMonitor->m_scale).round();
 
     shmStride = NFormatUtils::minStride(PSHMINFO, box.w);
 
@@ -189,7 +189,7 @@ void CScreencopyFrame::share() {
 
 void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
     const auto PERM    = g_pDynamicPermissionManager->clientPermissionMode(resource->client(), PERMISSION_TYPE_SCREENCOPY);
-    auto       TEXTURE = makeShared<CTexture>(pMonitor->output->state->state().buffer);
+    auto       TEXTURE = makeShared<CTexture>(pMonitor->m_output->state->state().buffer);
 
     CRegion    fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
 
@@ -200,9 +200,9 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
     }
 
     if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) {
-        CBox monbox = CBox{0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y}
+        CBox monbox = CBox{0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y}
                           .translate({-box.x, -box.y}) // vvvv kinda ass-backwards but that's how I designed the renderer... sigh.
-                          .transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+                          .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
         g_pHyprOpenGL->setMonitorTransformEnabled(true);
         g_pHyprOpenGL->setRenderModifEnabled(false);
         g_pHyprOpenGL->renderTexture(TEXTURE, monbox, 1);
@@ -210,13 +210,13 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
         g_pHyprOpenGL->setMonitorTransformEnabled(false);
         if (overlayCursor)
             g_pPointerManager->renderSoftwareCursorsFor(pMonitor.lock(), Time::steadyNow(), fakeDamage,
-                                                        g_pInputManager->getMouseCoordsInternal() - pMonitor->vecPosition - box.pos(), true);
+                                                        g_pInputManager->getMouseCoordsInternal() - pMonitor->m_position - box.pos(), true);
     } else if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING)
         g_pHyprOpenGL->clear(Colors::BLACK);
     else {
         g_pHyprOpenGL->clear(Colors::BLACK);
         CBox texbox =
-            CBox{pMonitor->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
+            CBox{pMonitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
         g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
     }
 
@@ -230,7 +230,7 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
 
 bool CScreencopyFrame::copyShm() {
     const auto PERM    = g_pDynamicPermissionManager->clientPermissionMode(resource->client(), PERMISSION_TYPE_SCREENCOPY);
-    auto       TEXTURE = makeShared<CTexture>(pMonitor->output->state->state().buffer);
+    auto       TEXTURE = makeShared<CTexture>(pMonitor->m_output->state->state().buffer);
 
     auto       shm                = buffer->shm();
     auto [pixelData, fmt, bufLen] = buffer->beginDataPtr(0); // no need for end, cuz it's shm
@@ -240,7 +240,7 @@ bool CScreencopyFrame::copyShm() {
     g_pHyprRenderer->makeEGLCurrent();
 
     CFramebuffer fb;
-    fb.alloc(box.w, box.h, pMonitor->output->state->state().drmFormat);
+    fb.alloc(box.w, box.h, pMonitor->m_output->state->state().drmFormat);
 
     if (!g_pHyprRenderer->beginRender(pMonitor.lock(), fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &fb, true)) {
         LOGM(ERR, "Can't copy: failed to begin rendering");
@@ -248,7 +248,7 @@ bool CScreencopyFrame::copyShm() {
     }
 
     if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) {
-        CBox monbox = CBox{0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y}.translate({-box.x, -box.y});
+        CBox monbox = CBox{0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y}.translate({-box.x, -box.y});
         g_pHyprOpenGL->setMonitorTransformEnabled(true);
         g_pHyprOpenGL->setRenderModifEnabled(false);
         g_pHyprOpenGL->renderTexture(TEXTURE, monbox, 1);
@@ -256,13 +256,13 @@ bool CScreencopyFrame::copyShm() {
         g_pHyprOpenGL->setMonitorTransformEnabled(false);
         if (overlayCursor)
             g_pPointerManager->renderSoftwareCursorsFor(pMonitor.lock(), Time::steadyNow(), fakeDamage,
-                                                        g_pInputManager->getMouseCoordsInternal() - pMonitor->vecPosition - box.pos(), true);
+                                                        g_pInputManager->getMouseCoordsInternal() - pMonitor->m_position - box.pos(), true);
     } else if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING)
         g_pHyprOpenGL->clear(Colors::BLACK);
     else {
         g_pHyprOpenGL->clear(Colors::BLACK);
         CBox texbox =
-            CBox{pMonitor->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
+            CBox{pMonitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
         g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
     }
 
diff --git a/src/protocols/SessionLock.cpp b/src/protocols/SessionLock.cpp
index 63ece928..40c73a7b 100644
--- a/src/protocols/SessionLock.cpp
+++ b/src/protocols/SessionLock.cpp
@@ -56,11 +56,11 @@ CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_,
         pSurface.reset();
     });
 
-    PROTO::fractional->sendScale(surface_, pMonitor_->scale);
+    PROTO::fractional->sendScale(surface_, pMonitor_->m_scale);
 
     sendConfigure();
 
-    listeners.monitorMode = pMonitor->events.modeChanged.registerListener([this](std::any data) { sendConfigure(); });
+    listeners.monitorMode = pMonitor->m_events.modeChanged.registerListener([this](std::any data) { sendConfigure(); });
 }
 
 CSessionLockSurface::~CSessionLockSurface() {
@@ -73,7 +73,7 @@ CSessionLockSurface::~CSessionLockSurface() {
 
 void CSessionLockSurface::sendConfigure() {
     const auto SERIAL = g_pSeatManager->nextSerial(g_pSeatManager->seatResourceForClient(resource->client()));
-    resource->sendConfigure(SERIAL, pMonitor->vecSize.x, pMonitor->vecSize.y);
+    resource->sendConfigure(SERIAL, pMonitor->m_size.x, pMonitor->m_size.y);
 }
 
 bool CSessionLockSurface::good() {
diff --git a/src/protocols/ToplevelExport.cpp b/src/protocols/ToplevelExport.cpp
index 51ad8f5d..9496acb2 100644
--- a/src/protocols/ToplevelExport.cpp
+++ b/src/protocols/ToplevelExport.cpp
@@ -114,11 +114,11 @@ CToplevelExportFrame::CToplevelExportFrame(SP<CHyprlandToplevelExportFrameV1> re
         return;
     }
 
-    dmabufFormat = PMONITOR->output->state->state().drmFormat;
+    dmabufFormat = PMONITOR->m_output->state->state().drmFormat;
 
-    box = {0, 0, (int)(pWindow->m_realSize->value().x * PMONITOR->scale), (int)(pWindow->m_realSize->value().y * PMONITOR->scale)};
+    box = {0, 0, (int)(pWindow->m_realSize->value().x * PMONITOR->m_scale), (int)(pWindow->m_realSize->value().y * PMONITOR->m_scale)};
 
-    box.transform(wlTransformToHyprutils(PMONITOR->transform), PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y).round();
+    box.transform(wlTransformToHyprutils(PMONITOR->m_transform), PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y).round();
 
     shmStride = NFormatUtils::minStride(PSHMINFO, box.w);
 
@@ -236,18 +236,18 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
 
     // render the client
     const auto PMONITOR = pWindow->m_monitor.lock();
-    CRegion    fakeDamage{0, 0, PMONITOR->vecPixelSize.x * 10, PMONITOR->vecPixelSize.y * 10};
+    CRegion    fakeDamage{0, 0, PMONITOR->m_pixelSize.x * 10, PMONITOR->m_pixelSize.y * 10};
 
     g_pHyprRenderer->makeEGLCurrent();
 
     CFramebuffer outFB;
-    outFB.alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat);
+    outFB.alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
 
     auto overlayCursor = shouldOverlayCursor();
 
     if (overlayCursor) {
-        g_pPointerManager->lockSoftwareForMonitor(PMONITOR->self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->self.lock());
+        g_pPointerManager->lockSoftwareForMonitor(PMONITOR->m_self.lock());
+        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
     }
 
     if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &outFB))
@@ -262,10 +262,10 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
         g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
 
         if (overlayCursor)
-            g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value());
+            g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value());
     } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
         CBox texbox =
-            CBox{PMONITOR->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
+            CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
         g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
     }
 
@@ -291,21 +291,21 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
     auto glFormat = PFORMAT->flipRB ? GL_BGRA_EXT : GL_RGBA;
 
     auto origin = Vector2D(0, 0);
-    switch (PMONITOR->transform) {
+    switch (PMONITOR->m_transform) {
         case WL_OUTPUT_TRANSFORM_FLIPPED_180:
         case WL_OUTPUT_TRANSFORM_90: {
-            origin.y = PMONITOR->vecPixelSize.y - box.height;
+            origin.y = PMONITOR->m_pixelSize.y - box.height;
             break;
         }
         case WL_OUTPUT_TRANSFORM_FLIPPED_270:
         case WL_OUTPUT_TRANSFORM_180: {
-            origin.x = PMONITOR->vecPixelSize.x - box.width;
-            origin.y = PMONITOR->vecPixelSize.y - box.height;
+            origin.x = PMONITOR->m_pixelSize.x - box.width;
+            origin.y = PMONITOR->m_pixelSize.y - box.height;
             break;
         }
         case WL_OUTPUT_TRANSFORM_FLIPPED:
         case WL_OUTPUT_TRANSFORM_270: {
-            origin.x = PMONITOR->vecPixelSize.x - box.width;
+            origin.x = PMONITOR->m_pixelSize.x - box.width;
             break;
         }
         default: break;
@@ -314,8 +314,8 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
     glReadPixels(origin.x, origin.y, box.width, box.height, glFormat, PFORMAT->glType, pixelData);
 
     if (overlayCursor) {
-        g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->self.lock());
+        g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->m_self.lock());
+        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
     }
 
     outFB.unbind();
@@ -336,8 +336,8 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
     auto       overlayCursor = shouldOverlayCursor();
 
     if (overlayCursor) {
-        g_pPointerManager->lockSoftwareForMonitor(PMONITOR->self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->self.lock());
+        g_pPointerManager->lockSoftwareForMonitor(PMONITOR->m_self.lock());
+        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
     }
 
     if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_TO_BUFFER, buffer.buffer))
@@ -350,10 +350,10 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
         g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
 
         if (overlayCursor)
-            g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value());
+            g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value());
     } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
         CBox texbox =
-            CBox{PMONITOR->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
+            CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
         g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
     }
 
@@ -361,8 +361,8 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
     g_pHyprRenderer->endRender();
 
     if (overlayCursor) {
-        g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->self.lock());
-        g_pPointerManager->damageCursor(PMONITOR->self.lock());
+        g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->m_self.lock());
+        g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
     }
 
     return true;
@@ -450,7 +450,7 @@ void CToplevelExportProtocol::onOutputCommit(PHLMONITOR pMonitor) {
 
         CBox geometry = {PWINDOW->m_realPosition->value().x, PWINDOW->m_realPosition->value().y, PWINDOW->m_realSize->value().x, PWINDOW->m_realSize->value().y};
 
-        if (geometry.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty())
+        if (geometry.intersection({pMonitor->m_position, pMonitor->m_size}).empty())
             continue;
 
         f->share();
diff --git a/src/protocols/XDGOutput.cpp b/src/protocols/XDGOutput.cpp
index e95b9c7d..81c71447 100644
--- a/src/protocols/XDGOutput.cpp
+++ b/src/protocols/XDGOutput.cpp
@@ -65,14 +65,14 @@ void CXDGOutputProtocol::onManagerGetXDGOutput(CZxdgOutputManagerV1* mgr, uint32
         return;
     }
 
-    LOGM(LOG, "New xdg_output for {}: client {:x} ({})", PMONITOR->szName, (uintptr_t)CLIENT, pXDGOutput->isXWayland ? "xwayland" : "not xwayland");
+    LOGM(LOG, "New xdg_output for {}: client {:x} ({})", PMONITOR->m_name, (uintptr_t)CLIENT, pXDGOutput->isXWayland ? "xwayland" : "not xwayland");
 
     const auto XDGVER = pXDGOutput->resource->version();
 
     if (XDGVER >= OUTPUT_NAME_SINCE_VERSION)
-        pXDGOutput->resource->sendName(PMONITOR->szName.c_str());
-    if (XDGVER >= OUTPUT_DESCRIPTION_SINCE_VERSION && !PMONITOR->output->description.empty())
-        pXDGOutput->resource->sendDescription(PMONITOR->output->description.c_str());
+        pXDGOutput->resource->sendName(PMONITOR->m_name.c_str());
+    if (XDGVER >= OUTPUT_DESCRIPTION_SINCE_VERSION && !PMONITOR->m_output->description.empty())
+        pXDGOutput->resource->sendDescription(PMONITOR->m_output->description.c_str());
 
     pXDGOutput->sendDetails();
 
@@ -110,13 +110,13 @@ void CXDGOutput::sendDetails() {
     if UNLIKELY (!monitor || !outputProto || outputProto->isDefunct())
         return;
 
-    const auto POS = isXWayland ? monitor->vecXWaylandPosition : monitor->vecPosition;
+    const auto POS = isXWayland ? monitor->m_xwaylandPosition : monitor->m_position;
     resource->sendLogicalPosition(POS.x, POS.y);
 
     if (*PXWLFORCESCALEZERO && isXWayland)
-        resource->sendLogicalSize(monitor->vecTransformedSize.x, monitor->vecTransformedSize.y);
+        resource->sendLogicalSize(monitor->m_transformedSize.x, monitor->m_transformedSize.y);
     else
-        resource->sendLogicalSize(monitor->vecSize.x, monitor->vecSize.y);
+        resource->sendLogicalSize(monitor->m_size.x, monitor->m_size.y);
 
     if (resource->version() < OUTPUT_DONE_DEPRECATED_SINCE_VERSION)
         resource->sendDone();
diff --git a/src/protocols/XDGShell.cpp b/src/protocols/XDGShell.cpp
index 449348b9..59eca367 100644
--- a/src/protocols/XDGShell.cpp
+++ b/src/protocols/XDGShell.cpp
@@ -196,7 +196,7 @@ CXDGToplevelResource::CXDGToplevelResource(SP<CXdgToplevel> resource_, SP<CXDGSu
     resource->setSetFullscreen([this](CXdgToplevel* r, wl_resource* output) {
         if (output)
             if (const auto PM = CWLOutputResource::fromResource(output)->monitor; PM)
-                state.requestsFullscreenMonitor = PM->ID;
+                state.requestsFullscreenMonitor = PM->m_id;
 
         state.requestsFullscreen = true;
         events.stateChanged.emit();
diff --git a/src/protocols/core/Compositor.cpp b/src/protocols/core/Compositor.cpp
index cf28b240..b58ece97 100644
--- a/src/protocols/core/Compositor.cpp
+++ b/src/protocols/core/Compositor.cpp
@@ -271,21 +271,21 @@ void CWLSurfaceResource::enter(PHLMONITOR monitor) {
     if (std::find(enteredOutputs.begin(), enteredOutputs.end(), monitor) != enteredOutputs.end())
         return;
 
-    if UNLIKELY (!PROTO::outputs.contains(monitor->szName)) {
+    if UNLIKELY (!PROTO::outputs.contains(monitor->m_name)) {
         // can happen on unplug/replug
         LOGM(ERR, "enter() called on a non-existent output global");
         return;
     }
 
-    if UNLIKELY (PROTO::outputs.at(monitor->szName)->isDefunct()) {
+    if UNLIKELY (PROTO::outputs.at(monitor->m_name)->isDefunct()) {
         LOGM(ERR, "enter() called on a defunct output global");
         return;
     }
 
-    auto output = PROTO::outputs.at(monitor->szName)->outputResourceFrom(pClient);
+    auto output = PROTO::outputs.at(monitor->m_name)->outputResourceFrom(pClient);
 
     if UNLIKELY (!output || !output->getResource() || !output->getResource()->resource()) {
-        LOGM(ERR, "Cannot enter surface {:x} to {}, client hasn't bound the output", (uintptr_t)this, monitor->szName);
+        LOGM(ERR, "Cannot enter surface {:x} to {}, client hasn't bound the output", (uintptr_t)this, monitor->m_name);
         return;
     }
 
@@ -298,10 +298,10 @@ void CWLSurfaceResource::leave(PHLMONITOR monitor) {
     if UNLIKELY (std::find(enteredOutputs.begin(), enteredOutputs.end(), monitor) == enteredOutputs.end())
         return;
 
-    auto output = PROTO::outputs.at(monitor->szName)->outputResourceFrom(pClient);
+    auto output = PROTO::outputs.at(monitor->m_name)->outputResourceFrom(pClient);
 
     if UNLIKELY (!output) {
-        LOGM(ERR, "Cannot leave surface {:x} from {}, client hasn't bound the output", (uintptr_t)this, monitor->szName);
+        LOGM(ERR, "Cannot leave surface {:x} from {}, client hasn't bound the output", (uintptr_t)this, monitor->m_name);
         return;
     }
 
diff --git a/src/protocols/core/DataDevice.cpp b/src/protocols/core/DataDevice.cpp
index 8ac5d31d..1cd003f0 100644
--- a/src/protocols/core/DataDevice.cpp
+++ b/src/protocols/core/DataDevice.cpp
@@ -809,7 +809,7 @@ void CWLDataDeviceProtocol::renderDND(PHLMONITOR pMonitor, const Time::steady_tp
 
     surfacePos += dnd.dndSurface->current.offset;
 
-    CBox                         box = CBox{surfacePos, dnd.dndSurface->current.size}.translate(-pMonitor->vecPosition).scale(pMonitor->scale);
+    CBox                         box = CBox{surfacePos, dnd.dndSurface->current.size}.translate(-pMonitor->m_position).scale(pMonitor->m_scale);
 
     CTexPassElement::SRenderData data;
     data.tex = dnd.dndSurface->current.texture;
diff --git a/src/protocols/core/Output.cpp b/src/protocols/core/Output.cpp
index 41e03e78..dfb89ba7 100644
--- a/src/protocols/core/Output.cpp
+++ b/src/protocols/core/Output.cpp
@@ -15,17 +15,17 @@ CWLOutputResource::CWLOutputResource(SP<CWlOutput> resource_, PHLMONITOR pMonito
         return;
 
     resource->setOnDestroy([this](CWlOutput* r) {
-        if (monitor && PROTO::outputs.contains(monitor->szName))
-            PROTO::outputs.at(monitor->szName)->destroyResource(this);
+        if (monitor && PROTO::outputs.contains(monitor->m_name))
+            PROTO::outputs.at(monitor->m_name)->destroyResource(this);
     });
     resource->setRelease([this](CWlOutput* r) {
-        if (monitor && PROTO::outputs.contains(monitor->szName))
-            PROTO::outputs.at(monitor->szName)->destroyResource(this);
+        if (monitor && PROTO::outputs.contains(monitor->m_name))
+            PROTO::outputs.at(monitor->m_name)->destroyResource(this);
     });
 
     if (resource->version() >= 4) {
-        resource->sendName(monitor->szName.c_str());
-        resource->sendDescription(monitor->szDescription.c_str());
+        resource->sendName(monitor->m_name.c_str());
+        resource->sendDescription(monitor->m_description.c_str());
     }
 
     updateState();
@@ -72,21 +72,21 @@ void CWLOutputResource::updateState() {
         return;
 
     if (resource->version() >= 2)
-        resource->sendScale(std::ceil(monitor->scale));
+        resource->sendScale(std::ceil(monitor->m_scale));
 
-    resource->sendMode((wl_output_mode)(WL_OUTPUT_MODE_CURRENT), monitor->vecPixelSize.x, monitor->vecPixelSize.y, monitor->refreshRate * 1000.0);
+    resource->sendMode((wl_output_mode)(WL_OUTPUT_MODE_CURRENT), monitor->m_pixelSize.x, monitor->m_pixelSize.y, monitor->m_refreshRate * 1000.0);
 
-    resource->sendGeometry(0, 0, monitor->output->physicalSize.x, monitor->output->physicalSize.y, (wl_output_subpixel)monitor->output->subpixel, monitor->output->make.c_str(),
-                           monitor->output->model.c_str(), monitor->transform);
+    resource->sendGeometry(0, 0, monitor->m_output->physicalSize.x, monitor->m_output->physicalSize.y, (wl_output_subpixel)monitor->m_output->subpixel,
+                           monitor->m_output->make.c_str(), monitor->m_output->model.c_str(), monitor->m_transform);
 
     if (resource->version() >= 2)
         resource->sendDone();
 }
 
 CWLOutputProtocol::CWLOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name, PHLMONITOR pMonitor) :
-    IWaylandProtocol(iface, ver, name), monitor(pMonitor), szName(pMonitor->szName) {
+    IWaylandProtocol(iface, ver, name), monitor(pMonitor), szName(pMonitor->m_name) {
 
-    listeners.modeChanged = monitor->events.modeChanged.registerListener([this](std::any d) {
+    listeners.modeChanged = monitor->m_events.modeChanged.registerListener([this](std::any d) {
         for (auto const& o : m_vOutputs) {
             o->updateState();
         }
diff --git a/src/render/Framebuffer.cpp b/src/render/Framebuffer.cpp
index 46e7d195..c35b9600 100644
--- a/src/render/Framebuffer.cpp
+++ b/src/render/Framebuffer.cpp
@@ -85,7 +85,7 @@ void CFramebuffer::bind() {
 #endif
 
     if (g_pHyprOpenGL)
-        glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.y);
+        glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.y);
     else
         glViewport(0, 0, m_vSize.x, m_vSize.y);
 }
diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp
index 2a0cbe5a..31fd7b0a 100644
--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -688,14 +688,14 @@ void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP
 
     const auto FBO = rb ? rb->getFB() : fb;
 
-    glViewport(0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+    glViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
 
-    m_RenderData.projection = Mat3x3::outputProjection(pMonitor->vecPixelSize, HYPRUTILS_TRANSFORM_NORMAL);
+    m_RenderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
 
     m_RenderData.monitorProjection = Mat3x3::identity();
-    if (pMonitor->transform != WL_OUTPUT_TRANSFORM_NORMAL) {
-        const Vector2D tfmd = pMonitor->transform % 2 == 1 ? Vector2D{FBO->m_vSize.y, FBO->m_vSize.x} : FBO->m_vSize;
-        m_RenderData.monitorProjection.translate(FBO->m_vSize / 2.0).transform(wlTransformToHyprutils(pMonitor->transform)).translate(-tfmd / 2.0);
+    if (pMonitor->m_transform != WL_OUTPUT_TRANSFORM_NORMAL) {
+        const Vector2D tfmd = pMonitor->m_transform % 2 == 1 ? Vector2D{FBO->m_vSize.y, FBO->m_vSize.x} : FBO->m_vSize;
+        m_RenderData.monitorProjection.translate(FBO->m_vSize / 2.0).transform(wlTransformToHyprutils(pMonitor->m_transform)).translate(-tfmd / 2.0);
     }
 
     m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor];
@@ -738,13 +738,13 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, CFrameb
 
     TRACY_GPU_ZONE("RenderBegin");
 
-    glViewport(0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+    glViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
 
-    m_RenderData.projection = Mat3x3::outputProjection(pMonitor->vecPixelSize, HYPRUTILS_TRANSFORM_NORMAL);
+    m_RenderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
 
-    m_RenderData.monitorProjection = pMonitor->projMatrix;
+    m_RenderData.monitorProjection = pMonitor->m_projMatrix;
 
-    if (m_mMonitorRenderResources.contains(pMonitor) && m_mMonitorRenderResources.at(pMonitor).offloadFB.m_vSize != pMonitor->vecPixelSize)
+    if (m_mMonitorRenderResources.contains(pMonitor) && m_mMonitorRenderResources.at(pMonitor).offloadFB.m_vSize != pMonitor->m_pixelSize)
         destroyMonitorResources(pMonitor);
 
     m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor];
@@ -753,19 +753,19 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, CFrameb
         initShaders();
 
     // ensure a framebuffer for the monitor exists
-    if (m_RenderData.pCurrentMonData->offloadFB.m_vSize != pMonitor->vecPixelSize) {
+    if (m_RenderData.pCurrentMonData->offloadFB.m_vSize != pMonitor->m_pixelSize) {
         m_RenderData.pCurrentMonData->stencilTex->allocate();
 
-        m_RenderData.pCurrentMonData->offloadFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat);
-        m_RenderData.pCurrentMonData->mirrorFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat);
-        m_RenderData.pCurrentMonData->mirrorSwapFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat);
+        m_RenderData.pCurrentMonData->offloadFB.alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
+        m_RenderData.pCurrentMonData->mirrorFB.alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
+        m_RenderData.pCurrentMonData->mirrorSwapFB.alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
 
         m_RenderData.pCurrentMonData->offloadFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
         m_RenderData.pCurrentMonData->mirrorFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
         m_RenderData.pCurrentMonData->mirrorSwapFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
     }
 
-    if (m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated() && m_RenderData.pMonitor->mirrors.empty())
+    if (m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated() && m_RenderData.pMonitor->m_mirrors.empty())
         m_RenderData.pCurrentMonData->monitorMirrorFB.release();
 
     m_RenderData.damage.set(damage_);
@@ -797,23 +797,23 @@ void CHyprOpenGLImpl::end() {
         m_RenderData.damage = m_RenderData.finalDamage;
         m_bEndFrame         = true;
 
-        CBox monbox = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+        CBox monbox = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
 
         if (m_RenderData.mouseZoomFactor != 1.f) {
             const auto ZOOMCENTER = m_RenderData.mouseZoomUseMouse ?
-                (g_pInputManager->getMouseCoordsInternal() - m_RenderData.pMonitor->vecPosition) * m_RenderData.pMonitor->scale :
-                m_RenderData.pMonitor->vecTransformedSize / 2.f;
+                (g_pInputManager->getMouseCoordsInternal() - m_RenderData.pMonitor->m_position) * m_RenderData.pMonitor->m_scale :
+                m_RenderData.pMonitor->m_transformedSize / 2.f;
 
-            monbox.translate(-ZOOMCENTER).scale(m_RenderData.mouseZoomFactor).translate(*PZOOMRIGID ? m_RenderData.pMonitor->vecTransformedSize / 2.0 : ZOOMCENTER);
+            monbox.translate(-ZOOMCENTER).scale(m_RenderData.mouseZoomFactor).translate(*PZOOMRIGID ? m_RenderData.pMonitor->m_transformedSize / 2.0 : ZOOMCENTER);
 
             if (monbox.x > 0)
                 monbox.x = 0;
             if (monbox.y > 0)
                 monbox.y = 0;
-            if (monbox.x + monbox.width < m_RenderData.pMonitor->vecTransformedSize.x)
-                monbox.x = m_RenderData.pMonitor->vecTransformedSize.x - monbox.width;
-            if (monbox.y + monbox.height < m_RenderData.pMonitor->vecTransformedSize.y)
-                monbox.y = m_RenderData.pMonitor->vecTransformedSize.y - monbox.height;
+            if (monbox.x + monbox.width < m_RenderData.pMonitor->m_transformedSize.x)
+                monbox.x = m_RenderData.pMonitor->m_transformedSize.x - monbox.width;
+            if (monbox.y + monbox.height < m_RenderData.pMonitor->m_transformedSize.y)
+                monbox.y = m_RenderData.pMonitor->m_transformedSize.y - monbox.height;
         }
 
         m_bApplyFinalShader = !m_RenderData.blockScreenShader;
@@ -822,7 +822,7 @@ void CHyprOpenGLImpl::end() {
 
         // copy the damaged areas into the mirror buffer
         // we can't use the offloadFB for mirroring, as it contains artifacts from blurring
-        if (!m_RenderData.pMonitor->mirrors.empty() && !m_bFakeFrame)
+        if (!m_RenderData.pMonitor->m_mirrors.empty() && !m_bFakeFrame)
             saveBufferForMirror(monbox);
 
         m_RenderData.outFB->bind();
@@ -1279,8 +1279,8 @@ void CHyprOpenGLImpl::scissor(const CBox& originalBox, bool transform) {
 
     if (transform) {
         CBox       box = originalBox;
-        const auto TR  = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform));
-        box.transform(TR, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
+        const auto TR  = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform));
+        box.transform(TR, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y);
         glScissor(box.x, box.y, box.width, box.height);
         glEnable(GL_SCISSOR_TEST);
         return;
@@ -1342,7 +1342,7 @@ void CHyprOpenGLImpl::renderRectWithBlur(const CBox& box, const CHyprColor& col,
     glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
     scissor(box);
-    CBox MONITORBOX             = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    CBox MONITORBOX             = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
     m_bEndFrame                 = true; // fix transformed
     const auto SAVEDRENDERMODIF = m_RenderData.renderModif;
     m_RenderData.renderModif    = {}; // fix shit
@@ -1370,7 +1370,7 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co
     m_RenderData.renderModif.applyToBox(newBox);
 
     Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
-        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot);
+        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
     Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
 
     glUseProgram(m_shaders->m_shQUAD.program);
@@ -1386,8 +1386,8 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co
     glUniform4f(m_shaders->m_shQUAD.color, col.r * col.a, col.g * col.a, col.b * col.a, col.a);
 
     CBox transformedBox = box;
-    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
-                             m_RenderData.pMonitor->vecTransformedSize.y);
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
+                             m_RenderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -1466,12 +1466,12 @@ void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const NColorManageme
     glUniform1f(shader.dstMaxLuminance, targetImageDescription.luminances.max > 0 ? targetImageDescription.luminances.max : 10000);
     glUniform1f(shader.dstRefLuminance, targetImageDescription.luminances.reference);
     glUniform1f(shader.sdrSaturation,
-                modifySDR && m_RenderData.pMonitor->sdrSaturation > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
-                    m_RenderData.pMonitor->sdrSaturation :
+                modifySDR && m_RenderData.pMonitor->m_sdrSaturation > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
+                    m_RenderData.pMonitor->m_sdrSaturation :
                     1.0f);
     glUniform1f(shader.sdrBrightness,
-                modifySDR && m_RenderData.pMonitor->sdrBrightness > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
-                    m_RenderData.pMonitor->sdrBrightness :
+                modifySDR && m_RenderData.pMonitor->m_sdrBrightness > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
+                    m_RenderData.pMonitor->m_sdrBrightness :
 
                     1.0f);
     const auto cacheKey = std::make_pair(imageDescription.getId(), targetImageDescription.getId());
@@ -1488,7 +1488,7 @@ void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const NColorManageme
 }
 
 void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const SImageDescription& imageDescription) {
-    passCMUniforms(shader, imageDescription, m_RenderData.pMonitor->imageDescription, true);
+    passCMUniforms(shader, imageDescription, m_RenderData.pMonitor->m_imageDescription, true);
 }
 
 void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CBox& box, float alpha, const CRegion& damage, int round, float roundingPower, bool discardActive,
@@ -1511,10 +1511,10 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
     static const auto PENABLECM = CConfigValue<Hyprlang::INT>("render:cm_enabled");
 
     // get the needed transform for this texture
-    const bool TRANSFORMS_MATCH = wlTransformToHyprutils(m_RenderData.pMonitor->transform) == tex->m_eTransform; // FIXME: combine them properly!!!
+    const bool TRANSFORMS_MATCH = wlTransformToHyprutils(m_RenderData.pMonitor->m_transform) == tex->m_eTransform; // FIXME: combine them properly!!!
     eTransform TRANSFORM        = HYPRUTILS_TRANSFORM_NORMAL;
     if (m_bEndFrame || TRANSFORMS_MATCH)
-        TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform));
+        TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform));
 
     Mat3x3     matrix   = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
     Mat3x3     glMatrix = m_RenderData.projection.copy().multiply(matrix);
@@ -1570,11 +1570,11 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
     const auto imageDescription =
         m_RenderData.surface.valid() && m_RenderData.surface->colorManagement.valid() ? m_RenderData.surface->colorManagement->imageDescription() : SImageDescription{};
 
-    const bool skipCM = !*PENABLECM || !m_bCMSupported                   /* CM unsupported or disabled */
-        || (imageDescription == m_RenderData.pMonitor->imageDescription) /* Source and target have the same image description */
-        || ((*PPASS == 1 || (*PPASS == 2 && imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) && m_RenderData.pMonitor->activeWorkspace &&
-            m_RenderData.pMonitor->activeWorkspace->m_hasFullscreenWindow &&
-            m_RenderData.pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) /* Fullscreen window with pass cm enabled */;
+    const bool skipCM = !*PENABLECM || !m_bCMSupported                     /* CM unsupported or disabled */
+        || (imageDescription == m_RenderData.pMonitor->m_imageDescription) /* Source and target have the same image description */
+        || ((*PPASS == 1 || (*PPASS == 2 && imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) && m_RenderData.pMonitor->m_activeWorkspace &&
+            m_RenderData.pMonitor->m_activeWorkspace->m_hasFullscreenWindow &&
+            m_RenderData.pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) /* Fullscreen window with pass cm enabled */;
 
     if (!skipCM && !usingFinalShader && (texType == TEXTURE_RGBA || texType == TEXTURE_RGBX))
         shader = &m_shaders->m_shCM;
@@ -1602,13 +1602,13 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
     }
 
     if (usingFinalShader && shader->wl_output != -1)
-        glUniform1i(shader->wl_output, m_RenderData.pMonitor->ID);
+        glUniform1i(shader->wl_output, m_RenderData.pMonitor->m_id);
     if (usingFinalShader && shader->fullSize != -1)
-        glUniform2f(shader->fullSize, m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y);
+        glUniform2f(shader->fullSize, m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y);
 
     if (CRASHING) {
         glUniform1f(shader->distort, g_pHyprRenderer->m_fCrashingDistort);
-        glUniform2f(shader->fullSize, m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y);
+        glUniform2f(shader->fullSize, m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y);
     }
 
     if (!usingFinalShader) {
@@ -1625,8 +1625,8 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
     }
 
     CBox transformedBox = newBox;
-    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
-                             m_RenderData.pMonitor->vecTransformedSize.y);
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
+                             m_RenderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -1712,7 +1712,7 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<CTexture> tex, const CBox& box)
     m_RenderData.renderModif.applyToBox(newBox);
 
     // get transform
-    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
+    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform));
     Mat3x3     matrix    = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
     Mat3x3     glMatrix  = m_RenderData.projection.copy().multiply(matrix);
 
@@ -1763,7 +1763,7 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<CTexture> tex, const CBox& box, CFra
     m_RenderData.renderModif.applyToBox(newBox);
 
     // get transform
-    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
+    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform));
     Mat3x3     matrix    = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
     Mat3x3     glMatrix  = m_RenderData.projection.copy().multiply(matrix);
 
@@ -1824,8 +1824,8 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
     glDisable(GL_STENCIL_TEST);
 
     // get transforms for the full monitor
-    const auto TRANSFORM  = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform));
-    CBox       MONITORBOX = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    const auto TRANSFORM  = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform));
+    CBox       MONITORBOX = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
     Mat3x3     matrix     = m_RenderData.monitorProjection.projectBox(MONITORBOX, TRANSFORM);
     Mat3x3     glMatrix   = m_RenderData.projection.copy().multiply(matrix);
 
@@ -1837,8 +1837,8 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
 
     // prep damage
     CRegion damage{*originalDamage};
-    damage.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
-                     m_RenderData.pMonitor->vecTransformedSize.y);
+    damage.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
+                     m_RenderData.pMonitor->m_transformedSize.y);
     damage.expand(*PBLURPASSES > 10 ? pow(2, 15) : std::clamp(*PBLURSIZE, (int64_t)1, (int64_t)40) * pow(2, *PBLURPASSES));
 
     // helper
@@ -1866,17 +1866,19 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
         glUseProgram(m_shaders->m_shBLURPREPARE.program);
 
         // From FB to sRGB
-        const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->imageDescription == SImageDescription{};
+        const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->m_imageDescription == SImageDescription{};
         glUniform1i(m_shaders->m_shBLURPREPARE.skipCM, skipCM);
         if (!skipCM) {
-            passCMUniforms(m_shaders->m_shBLURPREPARE, m_RenderData.pMonitor->imageDescription, SImageDescription{});
+            passCMUniforms(m_shaders->m_shBLURPREPARE, m_RenderData.pMonitor->m_imageDescription, SImageDescription{});
             glUniform1f(m_shaders->m_shBLURPREPARE.sdrSaturation,
-                        m_RenderData.pMonitor->sdrSaturation > 0 && m_RenderData.pMonitor->imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
-                            m_RenderData.pMonitor->sdrSaturation :
+                        m_RenderData.pMonitor->m_sdrSaturation > 0 &&
+                                m_RenderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
+                            m_RenderData.pMonitor->m_sdrSaturation :
                             1.0f);
             glUniform1f(m_shaders->m_shBLURPREPARE.sdrBrightness,
-                        m_RenderData.pMonitor->sdrBrightness > 0 && m_RenderData.pMonitor->imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
-                            m_RenderData.pMonitor->sdrBrightness :
+                        m_RenderData.pMonitor->m_sdrBrightness > 0 &&
+                                m_RenderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
+                            m_RenderData.pMonitor->m_sdrBrightness :
                             1.0f);
         }
 
@@ -1935,12 +1937,12 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
 #endif
         glUniform1f(pShader->radius, *PBLURSIZE * a); // this makes the blursize change with a
         if (pShader == &m_shaders->m_shBLUR1) {
-            glUniform2f(m_shaders->m_shBLUR1.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f));
+            glUniform2f(m_shaders->m_shBLUR1.halfpixel, 0.5f / (m_RenderData.pMonitor->m_pixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->m_pixelSize.y / 2.f));
             glUniform1i(m_shaders->m_shBLUR1.passes, *PBLURPASSES);
             glUniform1f(m_shaders->m_shBLUR1.vibrancy, *PBLURVIBRANCY);
             glUniform1f(m_shaders->m_shBLUR1.vibrancy_darkness, *PBLURVIBRANCYDARKNESS);
         } else
-            glUniform2f(m_shaders->m_shBLUR2.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y * 2.f));
+            glUniform2f(m_shaders->m_shBLUR2.halfpixel, 0.5f / (m_RenderData.pMonitor->m_pixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->m_pixelSize.y * 2.f));
         glUniform1i(pShader->tex, 0);
 
         glVertexAttribPointer(pShader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
@@ -2058,7 +2060,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
         return;
 
     // ignore if solitary present, nothing to blur
-    if (!pMonitor->solitaryClient.expired())
+    if (!pMonitor->m_solitaryClient.expired())
         return;
 
     // check if we need to update the blur fb
@@ -2099,7 +2101,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
 
     bool hasWindows = false;
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_workspace == pMonitor->activeWorkspace && !w->isHidden() && w->m_isMapped && (!w->m_isFloating || *PBLURXRAY)) {
+        if (w->m_workspace == pMonitor->m_activeWorkspace && !w->isHidden() && w->m_isMapped && (!w->m_isFloating || *PBLURXRAY)) {
 
             // check if window is valid
             if (!windowShouldBeBlurred(w))
@@ -2111,7 +2113,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
     }
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        for (auto const& lsl : m->m_aLayerSurfaceLayers) {
+        for (auto const& lsl : m->m_layerSurfaceLayers) {
             for (auto const& ls : lsl) {
                 if (!ls->m_layerSurface || ls->m_xray != 1)
                     continue;
@@ -2140,18 +2142,18 @@ void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
     m_RenderData.renderModif    = {}; // fix shit
 
     // make the fake dmg
-    CRegion    fakeDamage{0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    CRegion    fakeDamage{0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
     const auto POUTFB = blurMainFramebufferWithDamage(1, &fakeDamage);
 
     // render onto blurFB
-    m_RenderData.pCurrentMonData->blurFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y,
-                                               m_RenderData.pMonitor->output->state->state().drmFormat);
+    m_RenderData.pCurrentMonData->blurFB.alloc(m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y,
+                                               m_RenderData.pMonitor->m_output->state->state().drmFormat);
     m_RenderData.pCurrentMonData->blurFB.bind();
 
     clear(CHyprColor(0, 0, 0, 0));
 
     m_bEndFrame = true; // fix transformed
-    renderTextureInternalWithDamage(POUTFB->getTexture(), CBox{0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}, 1, fakeDamage, 0,
+    renderTextureInternalWithDamage(POUTFB->getTexture(), CBox{0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y}, 1, fakeDamage, 0,
                                     2.0f, false, true, false);
     m_bEndFrame = false;
 
@@ -2222,7 +2224,8 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f
 
     // amazing hack: the surface has an opaque region!
     CRegion inverseOpaque;
-    if (a >= 1.f && std::round(pSurface->current.size.x * m_RenderData.pMonitor->scale) == box.w && std::round(pSurface->current.size.y * m_RenderData.pMonitor->scale) == box.h) {
+    if (a >= 1.f && std::round(pSurface->current.size.x * m_RenderData.pMonitor->m_scale) == box.w &&
+        std::round(pSurface->current.size.y * m_RenderData.pMonitor->m_scale) == box.h) {
         pixman_box32_t surfbox = {0, 0, pSurface->current.size.x * pSurface->current.scale, pSurface->current.size.y * pSurface->current.scale};
         inverseOpaque          = pSurface->current.opaque;
         inverseOpaque.invert(&surfbox).intersect(0, 0, pSurface->current.size.x * pSurface->current.scale, pSurface->current.size.y * pSurface->current.scale);
@@ -2234,7 +2237,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f
     } else
         inverseOpaque = {0, 0, box.width, box.height};
 
-    inverseOpaque.scale(m_RenderData.pMonitor->scale);
+    inverseOpaque.scale(m_RenderData.pMonitor->m_scale);
 
     //   vvv TODO: layered blur fbs?
     const bool    USENEWOPTIMIZE = shouldUseNewBlurOptimizations(m_RenderData.currentLS.lock(), m_RenderData.currentWindow.lock()) && !blockBlurOptimization;
@@ -2276,16 +2279,16 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f
     const auto LASTBR = m_RenderData.primarySurfaceUVBottomRight;
 
     CBox       transformedBox = box;
-    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
-                             m_RenderData.pMonitor->vecTransformedSize.y);
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
+                             m_RenderData.pMonitor->m_transformedSize.y);
 
-    CBox monitorSpaceBox = {transformedBox.pos().x / m_RenderData.pMonitor->vecPixelSize.x * m_RenderData.pMonitor->vecTransformedSize.x,
-                            transformedBox.pos().y / m_RenderData.pMonitor->vecPixelSize.y * m_RenderData.pMonitor->vecTransformedSize.y,
-                            transformedBox.width / m_RenderData.pMonitor->vecPixelSize.x * m_RenderData.pMonitor->vecTransformedSize.x,
-                            transformedBox.height / m_RenderData.pMonitor->vecPixelSize.y * m_RenderData.pMonitor->vecTransformedSize.y};
+    CBox monitorSpaceBox = {transformedBox.pos().x / m_RenderData.pMonitor->m_pixelSize.x * m_RenderData.pMonitor->m_transformedSize.x,
+                            transformedBox.pos().y / m_RenderData.pMonitor->m_pixelSize.y * m_RenderData.pMonitor->m_transformedSize.y,
+                            transformedBox.width / m_RenderData.pMonitor->m_pixelSize.x * m_RenderData.pMonitor->m_transformedSize.x,
+                            transformedBox.height / m_RenderData.pMonitor->m_pixelSize.y * m_RenderData.pMonitor->m_transformedSize.y};
 
-    m_RenderData.primarySurfaceUVTopLeft     = monitorSpaceBox.pos() / m_RenderData.pMonitor->vecTransformedSize;
-    m_RenderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / m_RenderData.pMonitor->vecTransformedSize;
+    m_RenderData.primarySurfaceUVTopLeft     = monitorSpaceBox.pos() / m_RenderData.pMonitor->m_transformedSize;
+    m_RenderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / m_RenderData.pMonitor->m_transformedSize;
 
     static auto PBLURIGNOREOPACITY = CConfigValue<Hyprlang::INT>("decoration:blur:ignore_opacity");
     setMonitorTransformEnabled(true);
@@ -2327,7 +2330,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     if (borderSize < 1)
         return;
 
-    int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->scale);
+    int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->m_scale);
     scaledBorderSize     = std::round(scaledBorderSize * m_RenderData.renderModif.combinedScale());
 
     // adjust box
@@ -2339,7 +2342,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     round += round == 0 ? 0 : scaledBorderSize;
 
     Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
-        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot);
+        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
     Mat3x3     glMatrix = m_RenderData.projection.copy().multiply(matrix);
 
     const auto BLEND = m_bBlend;
@@ -2347,7 +2350,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 
     glUseProgram(m_shaders->m_shBORDER1.program);
 
-    const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->imageDescription == SImageDescription{};
+    const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->m_imageDescription == SImageDescription{};
     glUniform1i(m_shaders->m_shBORDER1.skipCM, skipCM);
     if (!skipCM)
         passCMUniforms(m_shaders->m_shBORDER1, SImageDescription{});
@@ -2366,8 +2369,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     glUniform1i(m_shaders->m_shBORDER1.gradient2Length, 0);
 
     CBox transformedBox = newBox;
-    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
-                             m_RenderData.pMonitor->vecTransformedSize.y);
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
+                             m_RenderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -2425,7 +2428,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     if (borderSize < 1)
         return;
 
-    int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->scale);
+    int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->m_scale);
     scaledBorderSize     = std::round(scaledBorderSize * m_RenderData.renderModif.combinedScale());
 
     // adjust box
@@ -2437,7 +2440,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     round += round == 0 ? 0 : scaledBorderSize;
 
     Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
-        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot);
+        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
     Mat3x3     glMatrix = m_RenderData.projection.copy().multiply(matrix);
 
     const auto BLEND = m_bBlend;
@@ -2463,8 +2466,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     glUniform1f(m_shaders->m_shBORDER1.gradientLerp, lerp);
 
     CBox transformedBox = newBox;
-    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
-                             m_RenderData.pMonitor->vecTransformedSize.y);
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
+                             m_RenderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -2526,13 +2529,13 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
     const auto  col = color;
 
     Mat3x3      matrix = m_RenderData.monitorProjection.projectBox(
-        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot);
+        newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
     Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
 
     blend(true);
 
     glUseProgram(m_shaders->m_shSHADOW.program);
-    const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->imageDescription == SImageDescription{};
+    const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->m_imageDescription == SImageDescription{};
     glUniform1i(m_shaders->m_shSHADOW.skipCM, skipCM);
     if (!skipCM)
         passCMUniforms(m_shaders->m_shSHADOW, SImageDescription{});
@@ -2588,8 +2591,8 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
 void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
 
     if (!m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated())
-        m_RenderData.pCurrentMonData->monitorMirrorFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y,
-                                                            m_RenderData.pMonitor->output->state->state().drmFormat);
+        m_RenderData.pCurrentMonData->monitorMirrorFB.alloc(m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y,
+                                                            m_RenderData.pMonitor->m_output->state->state().drmFormat);
 
     m_RenderData.pCurrentMonData->monitorMirrorFB.bind();
 
@@ -2605,16 +2608,16 @@ void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
 void CHyprOpenGLImpl::renderMirrored() {
 
     auto         monitor  = m_RenderData.pMonitor;
-    auto         mirrored = monitor->pMirrorOf;
+    auto         mirrored = monitor->m_mirrorOf;
 
-    const double scale  = std::min(monitor->vecTransformedSize.x / mirrored->vecTransformedSize.x, monitor->vecTransformedSize.y / mirrored->vecTransformedSize.y);
-    CBox         monbox = {0, 0, mirrored->vecTransformedSize.x * scale, mirrored->vecTransformedSize.y * scale};
+    const double scale  = std::min(monitor->m_transformedSize.x / mirrored->m_transformedSize.x, monitor->m_transformedSize.y / mirrored->m_transformedSize.y);
+    CBox         monbox = {0, 0, mirrored->m_transformedSize.x * scale, mirrored->m_transformedSize.y * scale};
 
     // transform box as it will be drawn on a transformed projection
-    monbox.transform(wlTransformToHyprutils(mirrored->transform), mirrored->vecTransformedSize.x * scale, mirrored->vecTransformedSize.y * scale);
+    monbox.transform(wlTransformToHyprutils(mirrored->m_transform), mirrored->m_transformedSize.x * scale, mirrored->m_transformedSize.y * scale);
 
-    monbox.x = (monitor->vecTransformedSize.x - monbox.w) / 2;
-    monbox.y = (monitor->vecTransformedSize.y - monbox.h) / 2;
+    monbox.x = (monitor->m_transformedSize.x - monbox.w) / 2;
+    monbox.y = (monitor->m_transformedSize.y - monbox.h) / 2;
 
     const auto PFB = &m_mMonitorRenderResources[mirrored].monitorMirrorFB;
     if (!PFB->isAllocated() || !PFB->getTexture())
@@ -2626,10 +2629,10 @@ void CHyprOpenGLImpl::renderMirrored() {
     data.tex               = PFB->getTexture();
     data.box               = monbox;
     data.replaceProjection = Mat3x3::identity()
-                                 .translate(monitor->vecPixelSize / 2.0)
-                                 .transform(wlTransformToHyprutils(monitor->transform))
-                                 .transform(wlTransformToHyprutils(invertTransform(mirrored->transform)))
-                                 .translate(-monitor->vecTransformedSize / 2.0);
+                                 .translate(monitor->m_pixelSize / 2.0)
+                                 .transform(wlTransformToHyprutils(monitor->m_transform))
+                                 .transform(wlTransformToHyprutils(invertTransform(mirrored->m_transform)))
+                                 .translate(-monitor->m_transformedSize / 2.0);
 
     g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }
@@ -2912,7 +2915,7 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
     const auto PFB = &m_mMonitorBGFBs[pMonitor];
     PFB->release();
 
-    PFB->alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat);
+    PFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
 
     if (!m_pBackgroundTexture) // ?!?!?!
         return;
@@ -2922,7 +2925,7 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
 
     tex->allocate();
 
-    const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+    const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
     const auto CAIRO        = cairo_create(CAIROSURFACE);
 
     cairo_set_antialias(CAIRO, CAIRO_ANTIALIAS_GOOD);
@@ -2933,11 +2936,11 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
     cairo_restore(CAIRO);
 
     if (!*PNOSPLASH)
-        renderSplash(CAIRO, CAIROSURFACE, 0.02 * pMonitor->vecPixelSize.y, pMonitor->vecPixelSize);
+        renderSplash(CAIRO, CAIROSURFACE, 0.02 * pMonitor->m_pixelSize.y, pMonitor->m_pixelSize);
 
     cairo_surface_flush(CAIROSURFACE);
 
-    tex->m_vSize = pMonitor->vecPixelSize;
+    tex->m_vSize = pMonitor->m_pixelSize;
 
     // copy the data to an OpenGL texture we have
     const GLint glFormat = GL_RGBA;
@@ -2965,31 +2968,31 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
 
     // first render the background
     if (m_pBackgroundTexture) {
-        const double MONRATIO = m_RenderData.pMonitor->vecTransformedSize.x / m_RenderData.pMonitor->vecTransformedSize.y;
+        const double MONRATIO = m_RenderData.pMonitor->m_transformedSize.x / m_RenderData.pMonitor->m_transformedSize.y;
         const double WPRATIO  = m_pBackgroundTexture->m_vSize.x / m_pBackgroundTexture->m_vSize.y;
         Vector2D     origin;
         double       scale = 1.0;
 
         if (MONRATIO > WPRATIO) {
-            scale    = m_RenderData.pMonitor->vecTransformedSize.x / m_pBackgroundTexture->m_vSize.x;
-            origin.y = (m_RenderData.pMonitor->vecTransformedSize.y - m_pBackgroundTexture->m_vSize.y * scale) / 2.0;
+            scale    = m_RenderData.pMonitor->m_transformedSize.x / m_pBackgroundTexture->m_vSize.x;
+            origin.y = (m_RenderData.pMonitor->m_transformedSize.y - m_pBackgroundTexture->m_vSize.y * scale) / 2.0;
         } else {
-            scale    = m_RenderData.pMonitor->vecTransformedSize.y / m_pBackgroundTexture->m_vSize.y;
-            origin.x = (m_RenderData.pMonitor->vecTransformedSize.x - m_pBackgroundTexture->m_vSize.x * scale) / 2.0;
+            scale    = m_RenderData.pMonitor->m_transformedSize.y / m_pBackgroundTexture->m_vSize.y;
+            origin.x = (m_RenderData.pMonitor->m_transformedSize.x - m_pBackgroundTexture->m_vSize.x * scale) / 2.0;
         }
 
         CBox texbox = CBox{origin, m_pBackgroundTexture->m_vSize * scale};
         renderTextureInternalWithDamage(m_pBackgroundTexture, texbox, 1.0, fakeDamage);
     }
 
-    CBox monbox = {{}, pMonitor->vecPixelSize};
+    CBox monbox = {{}, pMonitor->m_pixelSize};
     renderTextureInternalWithDamage(tex, monbox, 1.0, fakeDamage);
 
     // bind back
     if (m_RenderData.currentFB)
         m_RenderData.currentFB->bind();
 
-    Debug::log(LOG, "Background created for monitor {}", pMonitor->szName);
+    Debug::log(LOG, "Background created for monitor {}", pMonitor->m_name);
 }
 
 void CHyprOpenGLImpl::clearWithTex() {
@@ -3004,7 +3007,7 @@ void CHyprOpenGLImpl::clearWithTex() {
 
     if (TEXIT != m_mMonitorBGFBs.end()) {
         CTexPassElement::SRenderData data;
-        data.box          = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+        data.box          = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
         data.flipEndFrame = true;
         data.tex          = TEXIT->second.getTexture();
         g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
@@ -3036,7 +3039,7 @@ void CHyprOpenGLImpl::destroyMonitorResources(PHLMONITORREF pMonitor) {
     }
 
     if (pMonitor)
-        Debug::log(LOG, "Monitor {} -> destroyed all render data", pMonitor->szName);
+        Debug::log(LOG, "Monitor {} -> destroyed all render data", pMonitor->m_name);
 }
 
 void CHyprOpenGLImpl::saveMatrix() {
@@ -3053,8 +3056,8 @@ void CHyprOpenGLImpl::restoreMatrix() {
 
 void CHyprOpenGLImpl::bindOffMain() {
     if (!m_RenderData.pCurrentMonData->offMainFB.isAllocated()) {
-        m_RenderData.pCurrentMonData->offMainFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y,
-                                                      m_RenderData.pMonitor->output->state->state().drmFormat);
+        m_RenderData.pCurrentMonData->offMainFB.alloc(m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y,
+                                                      m_RenderData.pMonitor->m_output->state->state().drmFormat);
 
         m_RenderData.pCurrentMonData->offMainFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
     }
@@ -3065,7 +3068,7 @@ void CHyprOpenGLImpl::bindOffMain() {
 }
 
 void CHyprOpenGLImpl::renderOffToMain(CFramebuffer* off) {
-    CBox monbox = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    CBox monbox = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
     renderTexturePrimitive(off->getTexture(), monbox);
 }
 
@@ -3083,7 +3086,7 @@ void CHyprOpenGLImpl::setRenderModifEnabled(bool enabled) {
 }
 
 uint32_t CHyprOpenGLImpl::getPreferredReadFormat(PHLMONITOR pMonitor) {
-    return pMonitor->output->state->state().drmFormat;
+    return pMonitor->m_output->state->state().drmFormat;
 }
 
 std::vector<SDRMFormat> CHyprOpenGLImpl::getDRMFormats() {
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index 93d3620f..445c39cd 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -119,7 +119,7 @@ CHyprRenderer::CHyprRenderer() {
             if (!g_pHyprError->active())
                 return;
             for (auto& m : g_pCompositor->m_monitors) {
-                arrangeLayersForMonitor(m->ID);
+                arrangeLayersForMonitor(m->m_id);
             }
         });
     });
@@ -209,7 +209,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
     if (pWindow->m_workspace && pWindow->m_workspace->isVisible() && pWindow->m_isFloating /* tiled windows can't be multi-ws */)
         return !pWindow->isFullscreen(); // Do not draw fullscreen windows on other monitors
 
-    if (pMonitor->activeSpecialWorkspace == pWindow->m_workspace)
+    if (pMonitor->m_activeSpecialWorkspace == pWindow->m_workspace)
         return true;
 
     // if window is tiled and it's flying in, don't render on other mons (for slide)
@@ -226,7 +226,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
             windowBox.translate(PWINDOWWORKSPACE->m_renderOffset->value());
         windowBox.translate(pWindow->m_floatingOffset);
 
-        const CBox monitorBox = {pMonitor->vecPosition, pMonitor->vecSize};
+        const CBox monitorBox = {pMonitor->m_position, pMonitor->m_size};
         if (!windowBox.intersection(monitorBox).empty() && (pWindow->workspaceID() == pMonitor->activeWorkspaceID() || pWindow->m_monitorMovedFrom != -1))
             return true;
     }
@@ -254,7 +254,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow) {
         if (PWORKSPACE && PWORKSPACE->m_monitor == m && (PWORKSPACE->m_renderOffset->isBeingAnimated() || PWORKSPACE->m_alpha->isBeingAnimated()))
             return true;
 
-        if (m->activeSpecialWorkspace && pWindow->onSpecialWorkspace())
+        if (m->m_activeSpecialWorkspace && pWindow->onSpecialWorkspace())
             return true;
     }
 
@@ -479,8 +479,8 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
     renderdata.h     = textureBox.h;
 
     if (ignorePosition) {
-        renderdata.pos.x = pMonitor->vecPosition.x;
-        renderdata.pos.y = pMonitor->vecPosition.y;
+        renderdata.pos.x = pMonitor->m_position.x;
+        renderdata.pos.y = pMonitor->m_position.y;
     } else {
         const bool ANR = pWindow->isNotResponding();
         if (ANR && pWindow->m_notRespondingTint->goal() != 0.2F)
@@ -502,7 +502,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
         (USE_WORKSPACE_FADE_ALPHA ? pWindow->m_movingToWorkspaceAlpha->value() : 1.F) * pWindow->m_movingFromWorkspaceAlpha->value();
     renderdata.alpha         = pWindow->m_activeInactiveAlpha->value();
     renderdata.decorate      = decorate && !pWindow->m_X11DoesntWantBorders && !pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN);
-    renderdata.rounding      = standalone || renderdata.dontRound ? 0 : pWindow->rounding() * pMonitor->scale;
+    renderdata.rounding      = standalone || renderdata.dontRound ? 0 : pWindow->rounding() * pMonitor->m_scale;
     renderdata.roundingPower = standalone || renderdata.dontRound ? 2.0f : pWindow->roundingPower();
     renderdata.blur          = !standalone && *PBLUR && !DONT_BLUR;
     renderdata.pWindow       = pWindow;
@@ -521,7 +521,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
     EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOW);
 
     if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault() && !m_bRenderingSnapshot && mode != RENDER_PASS_POPUP) {
-        CBox                        monbox = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.y};
+        CBox                        monbox = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.y};
         CRectPassElement::SRectData data;
         data.color = CHyprColor(0, 0, 0, *PDIMAROUND * renderdata.alpha * renderdata.fadeAlpha);
         data.box   = monbox;
@@ -533,7 +533,8 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
 
     // if window is floating and we have a slide animation, clip it to its full bb
     if (!ignorePosition && pWindow->m_isFloating && !pWindow->isFullscreen() && PWORKSPACE->m_renderOffset->isBeingAnimated() && !pWindow->m_pinned) {
-        CRegion rg = pWindow->getFullWindowBoundingBox().translate(-pMonitor->vecPosition + PWORKSPACE->m_renderOffset->value() + pWindow->m_floatingOffset).scale(pMonitor->scale);
+        CRegion rg =
+            pWindow->getFullWindowBoundingBox().translate(-pMonitor->m_position + PWORKSPACE->m_renderOffset->value() + pWindow->m_floatingOffset).scale(pMonitor->m_scale);
         renderdata.clipBox = rg.getExtents();
     }
 
@@ -571,8 +572,8 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
             renderdata.useNearestNeighbor = true;
 
         if (!pWindow->m_windowData.noBlur.valueOrDefault() && pWindow->m_wlSurface->small() && !pWindow->m_wlSurface->m_fillIgnoreSmall && renderdata.blur && *PBLUR) {
-            CBox wb = {renderdata.pos.x - pMonitor->vecPosition.x, renderdata.pos.y - pMonitor->vecPosition.y, renderdata.w, renderdata.h};
-            wb.scale(pMonitor->scale).round();
+            CBox wb = {renderdata.pos.x - pMonitor->m_position.x, renderdata.pos.y - pMonitor->m_position.y, renderdata.w, renderdata.h};
+            wb.scale(pMonitor->m_scale).round();
             CRectPassElement::SRectData data;
             data.color = CHyprColor(0, 0, 0, 0);
             data.box   = wb;
@@ -699,7 +700,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
 
     if (*PDIMAROUND && pLayer->m_dimAround && !m_bRenderingSnapshot && !popups) {
         CRectPassElement::SRectData data;
-        data.box   = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.y};
+        data.box   = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.y};
         data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pLayer->m_alpha->value());
         m_sRenderPass.add(makeShared<CRectPassElement>(data));
     }
@@ -727,7 +728,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
     renderdata.pLS                              = pLayer;
     renderdata.blockBlurOptimization            = pLayer->m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM || pLayer->m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND;
 
-    renderdata.clipBox = CBox{0, 0, pMonitor->vecSize.x, pMonitor->vecSize.y}.scale(pMonitor->scale);
+    renderdata.clipBox = CBox{0, 0, pMonitor->m_size.x, pMonitor->m_size.y}.scale(pMonitor->m_scale);
 
     if (renderdata.blur && pLayer->m_ignoreAlpha) {
         renderdata.discardMode |= DISCARD_ALPHA;
@@ -804,13 +805,13 @@ void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, con
 }
 
 void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, PHLMONITOR pMonitor, const Time::steady_tp& time) {
-    CSurfacePassElement::SRenderData renderdata = {pMonitor, time, pMonitor->vecPosition, pMonitor->vecPosition};
+    CSurfacePassElement::SRenderData renderdata = {pMonitor, time, pMonitor->m_position, pMonitor->m_position};
 
     renderdata.blur     = false;
     renderdata.surface  = pSurface->surface->surface();
     renderdata.decorate = false;
-    renderdata.w        = pMonitor->vecSize.x;
-    renderdata.h        = pMonitor->vecSize.y;
+    renderdata.w        = pMonitor->m_size.x;
+    renderdata.h        = pMonitor->m_size.y;
 
     renderdata.surface->breadthfirst(
         [this, &renderdata, &pSurface](SP<CWLSurfaceResource> s, const Vector2D& offset, void* data) {
@@ -869,16 +870,16 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
         else
             g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
 
-        for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
+        for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
             renderLayer(ls.lock(), pMonitor, time);
         }
-        for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
+        for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
             renderLayer(ls.lock(), pMonitor, time);
         }
-        for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+        for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
             renderLayer(ls.lock(), pMonitor, time);
         }
-        for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
+        for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
             renderLayer(ls.lock(), pMonitor, time);
         }
 
@@ -891,10 +892,10 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
         else
             g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
 
-        for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
+        for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
             renderLayer(ls.lock(), pMonitor, time);
         }
-        for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
+        for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
             renderLayer(ls.lock(), pMonitor, time);
         }
     }
@@ -911,11 +912,11 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
     for (auto const& ws : g_pCompositor->m_workspaces) {
         if (ws->m_monitor == pMonitor && ws->m_alpha->value() > 0.f && ws->m_isSpecialWorkspace) {
             const auto SPECIALANIMPROGRS = ws->m_renderOffset->isBeingAnimated() ? ws->m_renderOffset->getCurveValue() : ws->m_alpha->getCurveValue();
-            const bool ANIMOUT           = !pMonitor->activeSpecialWorkspace;
+            const bool ANIMOUT           = !pMonitor->m_activeSpecialWorkspace;
 
             if (*PDIMSPECIAL != 0.f) {
                 CRectPassElement::SRectData data;
-                data.box   = {translate.x, translate.y, pMonitor->vecTransformedSize.x * scale, pMonitor->vecTransformedSize.y * scale};
+                data.box   = {translate.x, translate.y, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
                 data.color = CHyprColor(0, 0, 0, *PDIMSPECIAL * (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS));
 
                 g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(data));
@@ -923,7 +924,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
 
             if (*PBLURSPECIAL && *PBLUR) {
                 CRectPassElement::SRectData data;
-                data.box   = {translate.x, translate.y, pMonitor->vecTransformedSize.x * scale, pMonitor->vecTransformedSize.y * scale};
+                data.box   = {translate.x, translate.y, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
                 data.color = CHyprColor(0, 0, 0, 0);
                 data.blur  = true;
                 data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS);
@@ -963,7 +964,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
     EMIT_HOOK_EVENT("render", RENDER_POST_WINDOWS);
 
     // Render surfaces above windows for monitor
-    for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+    for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
         renderLayer(ls.lock(), pMonitor, time);
     }
 
@@ -972,11 +973,11 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
         renderIMEPopup(imep.get(), pMonitor, time);
     }
 
-    for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
+    for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
         renderLayer(ls.lock(), pMonitor, time);
     }
 
-    for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) {
+    for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
         for (auto const& ls : lsl) {
             renderLayer(ls.lock(), pMonitor, time, true);
         }
@@ -993,7 +994,7 @@ void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp&
     if (g_pSessionLockManager->isSessionLocked()) {
         Vector2D   translate = {geometry.x, geometry.y};
 
-        const auto PSLS = g_pSessionLockManager->getSessionLockSurfaceForMonitor(pMonitor->ID);
+        const auto PSLS = g_pSessionLockManager->getSessionLockSurfaceForMonitor(pMonitor->m_id);
         if (!PSLS) {
             if (g_pSessionLockManager->shallConsiderLockMissing())
                 renderSessionLockMissing(pMonitor);
@@ -1001,26 +1002,26 @@ void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp&
             renderSessionLockSurface(PSLS, pMonitor, now);
 
             // render layers and then their popups for abovelock rule
-            for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) {
+            for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
                 for (auto const& ls : lsl) {
                     renderLayer(ls.lock(), pMonitor, now, false, true);
                 }
             }
-            for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) {
+            for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
                 for (auto const& ls : lsl) {
                     renderLayer(ls.lock(), pMonitor, now, true, true);
                 }
             }
 
-            g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->ID);
+            g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->m_id);
         }
     }
 }
 
 void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
-    const auto ALPHA = g_pSessionLockManager->getRedScreenAlphaForMonitor(pMonitor->ID);
+    const auto ALPHA = g_pSessionLockManager->getRedScreenAlphaForMonitor(pMonitor->m_id);
 
-    CBox       monbox = {{}, pMonitor->vecPixelSize};
+    CBox       monbox = {{}, pMonitor->m_pixelSize};
 
     const bool ANY_PRESENT = g_pSessionLockManager->anySessionLockSurfacesPresent();
 
@@ -1041,7 +1042,7 @@ void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
     if (ALPHA < 1.f) /* animate */
         damageMonitor(pMonitor);
     else
-        g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->ID);
+        g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->m_id);
 }
 
 void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface, PHLMONITOR pMonitor, bool main, const Vector2D& projSize,
@@ -1081,10 +1082,10 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
         // to let the apps know to NOT add CSD. Also if source is there.
         // there is no way to fix this if that's the case
         if (*PEXPANDEDGES) {
-            const auto MONITOR_WL_SCALE = std::ceil(pMonitor->scale);
+            const auto MONITOR_WL_SCALE = std::ceil(pMonitor->m_scale);
             const bool SCALE_UNAWARE    = MONITOR_WL_SCALE != pSurface->current.scale && !pSurface->current.viewport.hasDestination;
             const auto EXPECTED_SIZE =
-                ((pSurface->current.viewport.hasDestination ? pSurface->current.viewport.destination : pSurface->current.bufferSize / pSurface->current.scale) * pMonitor->scale)
+                ((pSurface->current.viewport.hasDestination ? pSurface->current.viewport.destination : pSurface->current.bufferSize / pSurface->current.scale) * pMonitor->m_scale)
                     .round();
             if (!SCALE_UNAWARE && (EXPECTED_SIZE.x < projSize.x || EXPECTED_SIZE.y < projSize.y)) {
                 // this will not work with shm AFAIK, idk why.
@@ -1194,7 +1195,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
     if (!g_pCompositor->m_sessionActive)
         return;
 
-    if (pMonitor->ID == m_pMostHzMonitor->ID ||
+    if (pMonitor->m_id == m_pMostHzMonitor->m_id ||
         *PVFR == 1) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
         g_pCompositor->sanityCheckWorkspaces();
 
@@ -1204,18 +1205,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
             g_pConfigManager->performMonitorReload();
     }
 
-    if (pMonitor->scheduledRecalc) {
-        pMonitor->scheduledRecalc = false;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->ID);
+    if (pMonitor->m_scheduledRecalc) {
+        pMonitor->m_scheduledRecalc = false;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->m_id);
     }
 
-    if (!pMonitor->output->needsFrame && pMonitor->forceFullFrames == 0)
+    if (!pMonitor->m_output->needsFrame && pMonitor->m_forceFullFrames == 0)
         return;
 
     // tearing and DS first
     bool shouldTear = false;
-    if (pMonitor->tearingState.nextRenderTorn) {
-        pMonitor->tearingState.nextRenderTorn = false;
+    if (pMonitor->m_tearingState.nextRenderTorn) {
+        pMonitor->m_tearingState.nextRenderTorn = false;
 
         if (!*PTEARINGENABLED) {
             Debug::log(WARN, "Tearing commit requested but the master switch general:allow_tearing is off, ignoring");
@@ -1227,32 +1228,32 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
             return;
         }
 
-        if (!pMonitor->tearingState.canTear) {
+        if (!pMonitor->m_tearingState.canTear) {
             Debug::log(WARN, "Tearing commit requested but monitor doesn't support it, ignoring");
             return;
         }
 
-        if (!pMonitor->solitaryClient.expired())
+        if (!pMonitor->m_solitaryClient.expired())
             shouldTear = true;
     }
 
-    pMonitor->tearingState.activelyTearing = shouldTear;
+    pMonitor->m_tearingState.activelyTearing = shouldTear;
 
     if ((*PDIRECTSCANOUT == 1 ||
-         (*PDIRECTSCANOUT == 2 && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow &&
-          pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN && pMonitor->activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) &&
+         (*PDIRECTSCANOUT == 2 && pMonitor->m_activeWorkspace && pMonitor->m_activeWorkspace->m_hasFullscreenWindow &&
+          pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN && pMonitor->m_activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) &&
         !shouldTear) {
         if (pMonitor->attemptDirectScanout()) {
             return;
-        } else if (!pMonitor->lastScanout.expired()) {
+        } else if (!pMonitor->m_lastScanout.expired()) {
             Debug::log(LOG, "Left a direct scanout.");
-            pMonitor->lastScanout.reset();
+            pMonitor->m_lastScanout.reset();
 
             // reset DRM format, but only if needed since it might modeset
-            if (pMonitor->output->state->state().drmFormat != pMonitor->prevDrmFormat)
-                pMonitor->output->state->setFormat(pMonitor->prevDrmFormat);
+            if (pMonitor->m_output->state->state().drmFormat != pMonitor->m_prevDrmFormat)
+                pMonitor->m_output->state->setFormat(pMonitor->m_prevDrmFormat);
 
-            pMonitor->drmFormat = pMonitor->prevDrmFormat;
+            pMonitor->m_drmFormat = pMonitor->m_prevDrmFormat;
         }
     }
 
@@ -1261,9 +1262,9 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
     const auto NOW = Time::steadyNow();
 
     // check the damage
-    bool hasChanged = pMonitor->output->needsFrame || pMonitor->damage.hasChanged();
+    bool hasChanged = pMonitor->m_output->needsFrame || pMonitor->m_damage.hasChanged();
 
-    if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && pMonitor->forceFullFrames == 0 && damageBlinkCleanup == 0)
+    if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && pMonitor->m_forceFullFrames == 0 && damageBlinkCleanup == 0)
         return;
 
     if (*PDAMAGETRACKINGMODE == -1) {
@@ -1273,10 +1274,10 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
 
     EMIT_HOOK_EVENT("render", RENDER_PRE);
 
-    pMonitor->renderingActive = true;
+    pMonitor->m_renderingActive = true;
 
     // we need to cleanup fading out when rendering the appropriate context
-    g_pCompositor->cleanupFadingOut(pMonitor->ID);
+    g_pCompositor->cleanupFadingOut(pMonitor->m_id);
 
     // TODO: this is getting called with extents being 0,0,0,0 should it be?
     // potentially can save on resources.
@@ -1301,7 +1302,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
         g_pHyprOpenGL->m_RenderData.mouseZoomFactor    = zoomInFactorFirstLaunch;
         g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse  = false;
         g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false;
-        pMonitor->forceFullFrames                      = 10;
+        pMonitor->m_forceFullFrames                    = 10;
     }
 
     CRegion damage, finalDamage;
@@ -1311,18 +1312,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
     }
 
     // if we have no tracking or full tracking, invalidate the entire monitor
-    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || pMonitor->forceFullFrames > 0 || damageBlinkCleanup > 0)
-        damage = {0, 0, (int)pMonitor->vecTransformedSize.x * 10, (int)pMonitor->vecTransformedSize.y * 10};
+    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || pMonitor->m_forceFullFrames > 0 || damageBlinkCleanup > 0)
+        damage = {0, 0, (int)pMonitor->m_transformedSize.x * 10, (int)pMonitor->m_transformedSize.y * 10};
 
     finalDamage = damage;
 
     // update damage in renderdata as we modified it
     g_pHyprOpenGL->setDamage(damage, finalDamage);
 
-    if (pMonitor->forceFullFrames > 0) {
-        pMonitor->forceFullFrames -= 1;
-        if (pMonitor->forceFullFrames > 10)
-            pMonitor->forceFullFrames = 0;
+    if (pMonitor->m_forceFullFrames > 0) {
+        pMonitor->m_forceFullFrames -= 1;
+        if (pMonitor->m_forceFullFrames > 10)
+            pMonitor->m_forceFullFrames = 0;
     }
 
     EMIT_HOOK_EVENT("render", RENDER_BEGIN);
@@ -1330,7 +1331,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
     bool renderCursor = true;
 
     if (!finalDamage.empty()) {
-        if (pMonitor->solitaryClient.expired()) {
+        if (pMonitor->m_solitaryClient.expired()) {
             if (pMonitor->isMirror()) {
                 g_pHyprOpenGL->blend(false);
                 g_pHyprOpenGL->renderMirrored();
@@ -1338,8 +1339,8 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
                 EMIT_HOOK_EVENT("render", RENDER_POST_MIRROR);
                 renderCursor = false;
             } else {
-                CBox renderBox = {0, 0, (int)pMonitor->vecPixelSize.x, (int)pMonitor->vecPixelSize.y};
-                renderWorkspace(pMonitor, pMonitor->activeWorkspace, NOW, renderBox);
+                CBox renderBox = {0, 0, (int)pMonitor->m_pixelSize.x, (int)pMonitor->m_pixelSize.y};
+                renderWorkspace(pMonitor, pMonitor->m_activeWorkspace, NOW, renderBox);
 
                 renderLockscreen(pMonitor, NOW, renderBox);
 
@@ -1357,7 +1358,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
 
                 if (*PDAMAGEBLINK && damageBlinkCleanup == 0) {
                     CRectPassElement::SRectData data;
-                    data.box   = {0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y};
+                    data.box   = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y};
                     data.color = CHyprColor(1.0, 0.0, 1.0, 100.0 / 255.0);
                     m_sRenderPass.add(makeShared<CRectPassElement>(data));
                     damageBlinkCleanup = 1;
@@ -1368,18 +1369,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
                 }
             }
         } else
-            renderWindow(pMonitor->solitaryClient.lock(), pMonitor, NOW, false, RENDER_PASS_MAIN /* solitary = no popups */);
+            renderWindow(pMonitor->m_solitaryClient.lock(), pMonitor, NOW, false, RENDER_PASS_MAIN /* solitary = no popups */);
     } else if (!pMonitor->isMirror()) {
-        sendFrameEventsToWorkspace(pMonitor, pMonitor->activeWorkspace, NOW);
-        if (pMonitor->activeSpecialWorkspace)
-            sendFrameEventsToWorkspace(pMonitor, pMonitor->activeSpecialWorkspace, NOW);
+        sendFrameEventsToWorkspace(pMonitor, pMonitor->m_activeWorkspace, NOW);
+        if (pMonitor->m_activeSpecialWorkspace)
+            sendFrameEventsToWorkspace(pMonitor, pMonitor->m_activeSpecialWorkspace, NOW);
     }
 
     renderCursor = renderCursor && shouldRenderCursor();
 
     if (renderCursor) {
         TRACY_GPU_ZONE("RenderCursor");
-        g_pPointerManager->renderSoftwareCursorsFor(pMonitor->self.lock(), NOW, g_pHyprOpenGL->m_RenderData.damage);
+        g_pPointerManager->renderSoftwareCursorsFor(pMonitor->m_self.lock(), NOW, g_pHyprOpenGL->m_RenderData.damage);
     }
 
     EMIT_HOOK_EVENT("render", RENDER_LAST_MOMENT);
@@ -1390,35 +1391,35 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
 
     CRegion    frameDamage{g_pHyprOpenGL->m_RenderData.damage};
 
-    const auto TRANSFORM = invertTransform(pMonitor->transform);
-    frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y);
+    const auto TRANSFORM = invertTransform(pMonitor->m_transform);
+    frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y);
 
     if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR)
-        frameDamage.add(0, 0, (int)pMonitor->vecTransformedSize.x, (int)pMonitor->vecTransformedSize.y);
+        frameDamage.add(0, 0, (int)pMonitor->m_transformedSize.x, (int)pMonitor->m_transformedSize.y);
 
     if (*PDAMAGEBLINK)
         frameDamage.add(damage);
 
-    if (!pMonitor->mirrors.empty())
+    if (!pMonitor->m_mirrors.empty())
         damageMirrorsWith(pMonitor, frameDamage);
 
-    pMonitor->renderingActive = false;
+    pMonitor->m_renderingActive = false;
 
     EMIT_HOOK_EVENT("render", RENDER_POST);
 
-    pMonitor->output->state->addDamage(frameDamage);
-    pMonitor->output->state->setPresentationMode(shouldTear ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
-                                                              Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
+    pMonitor->m_output->state->addDamage(frameDamage);
+    pMonitor->m_output->state->setPresentationMode(shouldTear ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
+                                                                Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
 
     commitPendingAndDoExplicitSync(pMonitor);
 
     if (shouldTear)
-        pMonitor->tearingState.busy = true;
+        pMonitor->m_tearingState.busy = true;
 
-    if (*PDAMAGEBLINK || *PVFR == 0 || pMonitor->pendingFrame)
+    if (*PDAMAGEBLINK || *PVFR == 0 || pMonitor->m_pendingFrame)
         g_pCompositor->scheduleFrameForMonitor(pMonitor, Aquamarine::IOutput::AQ_SCHEDULE_RENDER_MONITOR);
 
-    pMonitor->pendingFrame = false;
+    pMonitor->m_pendingFrame = false;
 
     const float durationUs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - renderStart).count() / 1000.f;
     g_pDebugOverlay->renderData(pMonitor, durationUs);
@@ -1478,12 +1479,12 @@ static hdr_output_metadata       createHDRMetadata(SImageDescription settings, A
 bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
     static auto PCT   = CConfigValue<Hyprlang::INT>("render:send_content_type");
     static auto PPASS = CConfigValue<Hyprlang::INT>("render:cm_fs_passthrough");
-    const bool  PHDR  = pMonitor->imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ;
+    const bool  PHDR  = pMonitor->m_imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ;
 
-    const bool  SUPPORTSPQ = pMonitor->output->parsedEDID.hdrMetadata.has_value() ? pMonitor->output->parsedEDID.hdrMetadata->supportsPQ : false;
-    Debug::log(TRACE, "ColorManagement supportsBT2020 {}, supportsPQ {}", pMonitor->output->parsedEDID.supportsBT2020, SUPPORTSPQ);
+    const bool  SUPPORTSPQ = pMonitor->m_output->parsedEDID.hdrMetadata.has_value() ? pMonitor->m_output->parsedEDID.hdrMetadata->supportsPQ : false;
+    Debug::log(TRACE, "ColorManagement supportsBT2020 {}, supportsPQ {}", pMonitor->m_output->parsedEDID.supportsBT2020, SUPPORTSPQ);
 
-    if (pMonitor->output->parsedEDID.supportsBT2020 && SUPPORTSPQ) {
+    if (pMonitor->m_output->parsedEDID.supportsBT2020 && SUPPORTSPQ) {
         // HDR metadata determined by
         // PPASS = 0 monitor settings
         // PPASS = 1
@@ -1496,8 +1497,8 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
 
         bool wantHDR      = PHDR;
         bool hdrIsHandled = false;
-        if (*PPASS && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
-            const auto WINDOW    = pMonitor->activeWorkspace->getFullscreenWindow();
+        if (*PPASS && pMonitor->m_activeWorkspace && pMonitor->m_activeWorkspace->m_hasFullscreenWindow && pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
+            const auto WINDOW    = pMonitor->m_activeWorkspace->getFullscreenWindow();
             const auto ROOT_SURF = WINDOW->m_wlSurface->resource();
             const auto SURF =
                 ROOT_SURF->findFirstPreorder([ROOT_SURF](SP<CWLSurfaceResource> surf) { return surf->colorManagement.valid() && surf->extends() == ROOT_SURF->extends(); });
@@ -1509,28 +1510,28 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
                 (!wantHDR || SURF->colorManagement->imageDescription().transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) {
                 bool needsHdrMetadataUpdate = SURF->colorManagement->needsHdrMetadataUpdate() || pMonitor->m_previousFSWindow != WINDOW;
                 if (SURF->colorManagement->needsHdrMetadataUpdate())
-                    SURF->colorManagement->setHDRMetadata(createHDRMetadata(SURF->colorManagement->imageDescription(), pMonitor->output->parsedEDID));
+                    SURF->colorManagement->setHDRMetadata(createHDRMetadata(SURF->colorManagement->imageDescription(), pMonitor->m_output->parsedEDID));
                 if (needsHdrMetadataUpdate)
-                    pMonitor->output->state->setHDRMetadata(SURF->colorManagement->hdrMetadata());
+                    pMonitor->m_output->state->setHDRMetadata(SURF->colorManagement->hdrMetadata());
                 hdrIsHandled = true;
             }
 
             pMonitor->m_previousFSWindow = WINDOW;
         }
         if (!hdrIsHandled) {
-            if ((pMonitor->output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2) != wantHDR)
-                pMonitor->output->state->setHDRMetadata(wantHDR ? createHDRMetadata(pMonitor->imageDescription, pMonitor->output->parsedEDID) : NO_HDR_METADATA);
+            if ((pMonitor->m_output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2) != wantHDR)
+                pMonitor->m_output->state->setHDRMetadata(wantHDR ? createHDRMetadata(pMonitor->m_imageDescription, pMonitor->m_output->parsedEDID) : NO_HDR_METADATA);
             pMonitor->m_previousFSWindow.reset();
         }
     }
 
-    const bool needsWCG = pMonitor->output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2 || pMonitor->imageDescription.primariesNamed == CM_PRIMARIES_BT2020;
-    if (pMonitor->output->state->state().wideColorGamut != needsWCG) {
+    const bool needsWCG = pMonitor->m_output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2 || pMonitor->m_imageDescription.primariesNamed == CM_PRIMARIES_BT2020;
+    if (pMonitor->m_output->state->state().wideColorGamut != needsWCG) {
         Debug::log(TRACE, "Setting wide color gamut {}", needsWCG ? "on" : "off");
-        pMonitor->output->state->setWideColorGamut(needsWCG);
+        pMonitor->m_output->state->setWideColorGamut(needsWCG);
 
         // FIXME do not trust enabled10bit, auto switch to 10bit and back if needed
-        if (needsWCG && !pMonitor->enabled10bit) {
+        if (needsWCG && !pMonitor->m_enabled10bit) {
             Debug::log(WARN, "Wide color gamut is enabled but the display is not in 10bit mode");
             static bool shown = false;
             if (!shown) {
@@ -1541,32 +1542,32 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
     }
 
     if (*PCT) {
-        if (pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
-            const auto WINDOW = pMonitor->activeWorkspace->getFullscreenWindow();
-            pMonitor->output->state->setContentType(NContentType::toDRM(WINDOW->getContentType()));
+        if (pMonitor->m_activeWorkspace && pMonitor->m_activeWorkspace->m_hasFullscreenWindow && pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
+            const auto WINDOW = pMonitor->m_activeWorkspace->getFullscreenWindow();
+            pMonitor->m_output->state->setContentType(NContentType::toDRM(WINDOW->getContentType()));
         } else
-            pMonitor->output->state->setContentType(NContentType::toDRM(CONTENT_TYPE_NONE));
+            pMonitor->m_output->state->setContentType(NContentType::toDRM(CONTENT_TYPE_NONE));
     }
 
-    if (pMonitor->ctmUpdated) {
-        pMonitor->ctmUpdated = false;
-        pMonitor->output->state->setCTM(pMonitor->ctm);
+    if (pMonitor->m_ctmUpdated) {
+        pMonitor->m_ctmUpdated = false;
+        pMonitor->m_output->state->setCTM(pMonitor->m_ctm);
     }
 
-    bool ok = pMonitor->state.commit();
+    bool ok = pMonitor->m_state.commit();
     if (!ok) {
-        if (pMonitor->inFence.isValid()) {
+        if (pMonitor->m_inFence.isValid()) {
             Debug::log(TRACE, "Monitor state commit failed, retrying without a fence");
-            pMonitor->output->state->resetExplicitFences();
-            ok = pMonitor->state.commit();
+            pMonitor->m_output->state->resetExplicitFences();
+            ok = pMonitor->m_state.commit();
         }
 
         if (!ok) {
             Debug::log(TRACE, "Monitor state commit failed");
             // rollback the buffer to avoid writing to the front buffer that is being
             // displayed
-            pMonitor->output->swapchain->rollback();
-            pMonitor->damage.damageEntire();
+            pMonitor->m_output->swapchain->rollback();
+            pMonitor->m_damage.damageEntire();
         }
     }
 
@@ -1575,11 +1576,11 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
 
 void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now, const CBox& geometry) {
     Vector2D translate = {geometry.x, geometry.y};
-    float    scale     = (float)geometry.width / pMonitor->vecPixelSize.x;
+    float    scale     = (float)geometry.width / pMonitor->m_pixelSize.x;
 
     TRACY_GPU_ZONE("RenderWorkspace");
 
-    if (!DELTALESSTHAN((double)geometry.width / (double)geometry.height, pMonitor->vecPixelSize.x / pMonitor->vecPixelSize.y, 0.01)) {
+    if (!DELTALESSTHAN((double)geometry.width / (double)geometry.height, pMonitor->m_pixelSize.x / pMonitor->m_pixelSize.y, 0.01)) {
         Debug::log(ERR, "Ignoring geometry in renderWorkspace: aspect ratio mismatch");
         scale     = 1.f;
         translate = Vector2D{};
@@ -1599,7 +1600,7 @@ void CHyprRenderer::sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE
         w->m_wlSurface->resource()->breadthfirst([now](SP<CWLSurfaceResource> r, const Vector2D& offset, void* d) { r->frame(now); }, nullptr);
     }
 
-    for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) {
+    for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
         for (auto const& ls : lsl) {
             if (ls->m_fadingOut || !ls->m_surface->resource())
                 continue;
@@ -1677,7 +1678,7 @@ static void applyExclusive(CBox& usableArea, uint32_t anchor, int32_t exclusive,
 }
 
 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};
+    CBox full_area = {pMonitor->m_position.x, pMonitor->m_position.y, pMonitor->m_size.x, pMonitor->m_size.y};
 
     for (auto const& ls : layerSurfaces) {
         if (!ls || ls->m_fadingOut || ls->m_readyToDelete || !ls->m_layerSurface || ls->m_noProcess)
@@ -1772,44 +1773,44 @@ void CHyprRenderer::arrangeLayersForMonitor(const MONITORID& monitor) {
         return;
 
     // Reset the reserved
-    PMONITOR->vecReservedBottomRight = Vector2D();
-    PMONITOR->vecReservedTopLeft     = Vector2D();
+    PMONITOR->m_reservedBottomRight = Vector2D();
+    PMONITOR->m_reservedTopLeft     = Vector2D();
 
-    CBox usableArea = {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    CBox usableArea = {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
 
-    if (g_pHyprError->active() && g_pCompositor->m_lastMonitor == PMONITOR->self) {
+    if (g_pHyprError->active() && g_pCompositor->m_lastMonitor == PMONITOR->m_self) {
         const auto HEIGHT = g_pHyprError->height();
         if (*BAR_POSITION == 0) {
-            PMONITOR->vecReservedTopLeft.y = HEIGHT;
+            PMONITOR->m_reservedTopLeft.y = HEIGHT;
             usableArea.y += HEIGHT;
             usableArea.h -= HEIGHT;
         } else {
-            PMONITOR->vecReservedBottomRight.y = HEIGHT;
+            PMONITOR->m_reservedBottomRight.y = HEIGHT;
             usableArea.h -= HEIGHT;
         }
     }
 
-    for (auto& la : PMONITOR->m_aLayerSurfaceLayers) {
+    for (auto& la : PMONITOR->m_layerSurfaceLayers) {
         std::stable_sort(la.begin(), la.end(), [](const PHLLSREF& a, const PHLLSREF& b) { return a->m_order > b->m_order; });
     }
 
-    for (auto const& la : PMONITOR->m_aLayerSurfaceLayers)
+    for (auto const& la : PMONITOR->m_layerSurfaceLayers)
         arrangeLayerArray(PMONITOR, la, true, &usableArea);
 
-    for (auto const& la : PMONITOR->m_aLayerSurfaceLayers)
+    for (auto const& la : PMONITOR->m_layerSurfaceLayers)
         arrangeLayerArray(PMONITOR, la, false, &usableArea);
 
-    PMONITOR->vecReservedTopLeft     = Vector2D(usableArea.x, usableArea.y) - PMONITOR->vecPosition;
-    PMONITOR->vecReservedBottomRight = PMONITOR->vecSize - Vector2D(usableArea.width, usableArea.height) - PMONITOR->vecReservedTopLeft;
+    PMONITOR->m_reservedTopLeft     = Vector2D(usableArea.x, usableArea.y) - PMONITOR->m_position;
+    PMONITOR->m_reservedBottomRight = PMONITOR->m_size - Vector2D(usableArea.width, usableArea.height) - PMONITOR->m_reservedTopLeft;
 
-    auto ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(PMONITOR->szName);
+    auto ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(PMONITOR->m_name);
     if (ADDITIONALRESERVED == g_pConfigManager->m_mAdditionalReservedAreas.end()) {
         ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(""); // glob wildcard
     }
 
     if (ADDITIONALRESERVED != g_pConfigManager->m_mAdditionalReservedAreas.end()) {
-        PMONITOR->vecReservedTopLeft     = PMONITOR->vecReservedTopLeft + Vector2D(ADDITIONALRESERVED->second.left, ADDITIONALRESERVED->second.top);
-        PMONITOR->vecReservedBottomRight = PMONITOR->vecReservedBottomRight + Vector2D(ADDITIONALRESERVED->second.right, ADDITIONALRESERVED->second.bottom);
+        PMONITOR->m_reservedTopLeft     = PMONITOR->m_reservedTopLeft + Vector2D(ADDITIONALRESERVED->second.left, ADDITIONALRESERVED->second.top);
+        PMONITOR->m_reservedBottomRight = PMONITOR->m_reservedBottomRight + Vector2D(ADDITIONALRESERVED->second.right, ADDITIONALRESERVED->second.bottom);
     }
 
     // damage the monitor if can
@@ -1846,11 +1847,11 @@ void CHyprRenderer::damageSurface(SP<CWLSurfaceResource> pSurface, double x, dou
     CRegion damageBoxForEach;
 
     for (auto const& m : g_pCompositor->m_monitors) {
-        if (!m->output)
+        if (!m->m_output)
             continue;
 
         damageBoxForEach.set(damageBox);
-        damageBoxForEach.translate({-m->vecPosition.x, -m->vecPosition.y}).scale(m->scale);
+        damageBoxForEach.translate({-m->m_position.x, -m->m_position.y}).scale(m->m_scale);
 
         m->addDamage(damageBoxForEach);
     }
@@ -1874,8 +1875,8 @@ void CHyprRenderer::damageWindow(PHLWINDOW pWindow, bool forceFull) {
 
     for (auto const& m : g_pCompositor->m_monitors) {
         if (forceFull || 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);
+            CBox fixedDamageBox = {windowBox.x - m->m_position.x, windowBox.y - m->m_position.y, windowBox.width, windowBox.height};
+            fixedDamageBox.scale(m->m_scale);
             m->addDamage(fixedDamageBox);
         }
     }
@@ -1899,7 +1900,7 @@ void CHyprRenderer::damageMonitor(PHLMONITOR pMonitor) {
     static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
 
     if (*PLOGDAMAGE)
-        Debug::log(LOG, "Damage: Monitor {}", pMonitor->szName);
+        Debug::log(LOG, "Damage: Monitor {}", pMonitor->m_name);
 }
 
 void CHyprRenderer::damageBox(const CBox& box, bool skipFrameSchedule) {
@@ -1911,7 +1912,7 @@ void CHyprRenderer::damageBox(const CBox& box, bool skipFrameSchedule) {
             continue; // don't damage mirrors traditionally
 
         if (!skipFrameSchedule) {
-            CBox damageBox = box.copy().translate(-m->vecPosition).scale(m->scale);
+            CBox damageBox = box.copy().translate(-m->m_position).scale(m->m_scale);
             m->addDamage(damageBox);
         }
     }
@@ -1934,7 +1935,7 @@ void CHyprRenderer::damageRegion(const CRegion& rg) {
 }
 
 void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegion) {
-    for (auto const& mirror : pMonitor->mirrors) {
+    for (auto const& mirror : pMonitor->m_mirrors) {
 
         // transform the damage here, so it won't get clipped by the monitor damage ring
         auto    monitor = mirror;
@@ -1942,13 +1943,13 @@ void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegio
         CRegion transformed{pRegion};
 
         // we want to transform to the same box as in CHyprOpenGLImpl::renderMirrored
-        double scale  = std::min(monitor->vecTransformedSize.x / pMonitor->vecTransformedSize.x, monitor->vecTransformedSize.y / pMonitor->vecTransformedSize.y);
-        CBox   monbox = {0, 0, pMonitor->vecTransformedSize.x * scale, pMonitor->vecTransformedSize.y * scale};
-        monbox.x      = (monitor->vecTransformedSize.x - monbox.w) / 2;
-        monbox.y      = (monitor->vecTransformedSize.y - monbox.h) / 2;
+        double scale  = std::min(monitor->m_transformedSize.x / pMonitor->m_transformedSize.x, monitor->m_transformedSize.y / pMonitor->m_transformedSize.y);
+        CBox   monbox = {0, 0, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
+        monbox.x      = (monitor->m_transformedSize.x - monbox.w) / 2;
+        monbox.y      = (monitor->m_transformedSize.y - monbox.h) / 2;
 
         transformed.scale(scale);
-        transformed.transform(wlTransformToHyprutils(pMonitor->transform), pMonitor->vecPixelSize.x * scale, pMonitor->vecPixelSize.y * scale);
+        transformed.transform(wlTransformToHyprutils(pMonitor->m_transform), pMonitor->m_pixelSize.x * scale, pMonitor->m_pixelSize.y * scale);
         transformed.translate(Vector2D(monbox.x, monbox.y));
 
         mirror->addDamage(transformed);
@@ -2110,14 +2111,14 @@ void CHyprRenderer::initiateManualCrash() {
 }
 
 void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
-    pMonitor->solitaryClient.reset(); // reset it, if we find one it will be set.
+    pMonitor->m_solitaryClient.reset(); // reset it, if we find one it will be set.
 
     if (g_pHyprNotificationOverlay->hasAny() || g_pSessionLockManager->isSessionLocked())
         return;
 
-    const auto PWORKSPACE = pMonitor->activeWorkspace;
+    const auto PWORKSPACE = pMonitor->m_activeWorkspace;
 
-    if (!PWORKSPACE || !PWORKSPACE->m_hasFullscreenWindow || PROTO::data->dndActive() || pMonitor->activeSpecialWorkspace || PWORKSPACE->m_alpha->value() != 1.f ||
+    if (!PWORKSPACE || !PWORKSPACE->m_hasFullscreenWindow || PROTO::data->dndActive() || pMonitor->m_activeSpecialWorkspace || PWORKSPACE->m_alpha->value() != 1.f ||
         PWORKSPACE->m_renderOffset->value() != Vector2D{})
         return;
 
@@ -2129,14 +2130,14 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
     if (!PCANDIDATE->opaque())
         return;
 
-    if (PCANDIDATE->m_realSize->value() != pMonitor->vecSize || PCANDIDATE->m_realPosition->value() != pMonitor->vecPosition || PCANDIDATE->m_realPosition->isBeingAnimated() ||
+    if (PCANDIDATE->m_realSize->value() != pMonitor->m_size || PCANDIDATE->m_realPosition->value() != pMonitor->m_position || PCANDIDATE->m_realPosition->isBeingAnimated() ||
         PCANDIDATE->m_realSize->isBeingAnimated())
         return;
 
-    if (!pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY].empty())
+    if (!pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY].empty())
         return;
 
-    for (auto const& topls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+    for (auto const& topls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
         if (topls->m_alpha->value() != 0.f)
             return;
     }
@@ -2149,7 +2150,7 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
             return;
     }
 
-    if (pMonitor->activeSpecialWorkspace)
+    if (pMonitor->m_activeSpecialWorkspace)
         return;
 
     // check if it did not open any subsurfaces or shit
@@ -2163,7 +2164,7 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
         return;
 
     // found one!
-    pMonitor->solitaryClient = PCANDIDATE;
+    pMonitor->m_solitaryClient = PCANDIDATE;
 }
 
 SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) {
@@ -2221,29 +2222,29 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
     static constexpr const int HL_BUFFER_AGE = 2;
 
     if (!buffer) {
-        m_pCurrentBuffer = pMonitor->output->swapchain->next(nullptr);
+        m_pCurrentBuffer = pMonitor->m_output->swapchain->next(nullptr);
         if (!m_pCurrentBuffer) {
-            Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->szName);
+            Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->m_name);
             return false;
         }
     } else
         m_pCurrentBuffer = buffer;
 
     try {
-        m_pCurrentRenderbuffer = getOrCreateRenderbuffer(m_pCurrentBuffer, pMonitor->output->state->state().drmFormat);
+        m_pCurrentRenderbuffer = getOrCreateRenderbuffer(m_pCurrentBuffer, pMonitor->m_output->state->state().drmFormat);
     } catch (std::exception& e) {
-        Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->szName);
+        Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->m_name);
         return false;
     }
 
     if (!m_pCurrentRenderbuffer) {
-        Debug::log(ERR, "failed to start a render pass for output {}, no RBO could be obtained", pMonitor->szName);
+        Debug::log(ERR, "failed to start a render pass for output {}, no RBO could be obtained", pMonitor->m_name);
         return false;
     }
 
     if (mode == RENDER_MODE_NORMAL) {
-        damage = pMonitor->damage.getBufferDamage(HL_BUFFER_AGE);
-        pMonitor->damage.rotate();
+        damage = pMonitor->m_damage.getBufferDamage(HL_BUFFER_AGE);
+        pMonitor->m_damage.rotate();
     }
 
     m_pCurrentRenderbuffer->bind();
@@ -2283,7 +2284,7 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
         return;
 
     if (m_eRenderMode == RENDER_MODE_NORMAL)
-        PMONITOR->output->state->setBuffer(m_pCurrentBuffer);
+        PMONITOR->m_output->state->setBuffer(m_pCurrentBuffer);
 
     UP<CEGLSync> eglSync = CEGLSync::create();
     if (eglSync && eglSync->isValid()) {
@@ -2305,8 +2306,8 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
         usedAsyncBuffers.clear();
 
         if (m_eRenderMode == RENDER_MODE_NORMAL) {
-            PMONITOR->inFence = eglSync->takeFd();
-            PMONITOR->output->state->setExplicitInFence(PMONITOR->inFence.get());
+            PMONITOR->m_inFence = eglSync->takeFd();
+            PMONITOR->m_output->state->setExplicitInFence(PMONITOR->m_inFence.get());
         }
     } else {
         Debug::log(ERR, "renderer: couldn't use EGLSync for explicit gpu synchronization");
@@ -2376,17 +2377,17 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
     // we trust the window is valid.
     const auto PMONITOR = pWindow->m_monitor.lock();
 
-    if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0)
+    if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
         return;
 
     // we need to "damage" the entire monitor
     // so that we render the entire window
     // this is temporary, doesnt mess with the actual damage
-    CRegion fakeDamage{0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y};
+    CRegion fakeDamage{0, 0, (int)PMONITOR->m_transformedSize.x, (int)PMONITOR->m_transformedSize.y};
 
     makeEGLCurrent();
 
-    pFramebuffer->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat);
+    pFramebuffer->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
     pFramebuffer->addStencil(g_pHyprOpenGL->m_RenderData.pCurrentMonData->stencilTex);
 
     beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, pFramebuffer);
@@ -2403,7 +2404,7 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
     **PBLUR                    = 0;
 
     // TODO: how can we make this the size of the window? setting it to window's size makes the entire screen render with the wrong res forever more. odd.
-    glViewport(0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+    glViewport(0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
 
     g_pHyprOpenGL->m_RenderData.currentFB = pFramebuffer;
 
@@ -2420,7 +2421,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
     // we trust the window is valid.
     const auto PMONITOR = pWindow->m_monitor.lock();
 
-    if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0)
+    if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
         return;
 
     if (!shouldRenderWindow(pWindow))
@@ -2429,7 +2430,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
     // we need to "damage" the entire monitor
     // so that we render the entire window
     // this is temporary, doesnt mess with the actual damage
-    CRegion      fakeDamage{0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y};
+    CRegion      fakeDamage{0, 0, (int)PMONITOR->m_transformedSize.x, (int)PMONITOR->m_transformedSize.y};
 
     PHLWINDOWREF ref{pWindow};
 
@@ -2437,7 +2438,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
 
     const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mWindowFramebuffers[ref];
 
-    PFRAMEBUFFER->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat);
+    PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
 
     beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, PFRAMEBUFFER);
 
@@ -2469,19 +2470,19 @@ void CHyprRenderer::makeLayerSnapshot(PHLLS pLayer) {
     // we trust the window is valid.
     const auto PMONITOR = pLayer->m_monitor.lock();
 
-    if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0)
+    if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
         return;
 
     // we need to "damage" the entire monitor
     // so that we render the entire window
     // this is temporary, doesnt mess with the actual damage
-    CRegion fakeDamage{0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y};
+    CRegion fakeDamage{0, 0, (int)PMONITOR->m_transformedSize.x, (int)PMONITOR->m_transformedSize.y};
 
     makeEGLCurrent();
 
     const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mLayerFramebuffers[pLayer];
 
-    PFRAMEBUFFER->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat);
+    PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
 
     beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, PFRAMEBUFFER);
 
@@ -2520,21 +2521,21 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
     CBox       windowBox;
     // some mafs to figure out the correct box
     // the originalClosedPos is relative to the monitor's pos
-    Vector2D scaleXY = Vector2D((PMONITOR->scale * pWindow->m_realSize->value().x / (pWindow->m_originalClosedSize.x * PMONITOR->scale)),
-                                (PMONITOR->scale * pWindow->m_realSize->value().y / (pWindow->m_originalClosedSize.y * PMONITOR->scale)));
+    Vector2D scaleXY = Vector2D((PMONITOR->m_scale * pWindow->m_realSize->value().x / (pWindow->m_originalClosedSize.x * PMONITOR->m_scale)),
+                                (PMONITOR->m_scale * pWindow->m_realSize->value().y / (pWindow->m_originalClosedSize.y * PMONITOR->m_scale)));
 
-    windowBox.width  = PMONITOR->vecTransformedSize.x * scaleXY.x;
-    windowBox.height = PMONITOR->vecTransformedSize.y * scaleXY.y;
-    windowBox.x      = ((pWindow->m_realPosition->value().x - PMONITOR->vecPosition.x) * PMONITOR->scale) - ((pWindow->m_originalClosedPos.x * PMONITOR->scale) * scaleXY.x);
-    windowBox.y      = ((pWindow->m_realPosition->value().y - PMONITOR->vecPosition.y) * PMONITOR->scale) - ((pWindow->m_originalClosedPos.y * PMONITOR->scale) * scaleXY.y);
+    windowBox.width  = PMONITOR->m_transformedSize.x * scaleXY.x;
+    windowBox.height = PMONITOR->m_transformedSize.y * scaleXY.y;
+    windowBox.x      = ((pWindow->m_realPosition->value().x - PMONITOR->m_position.x) * PMONITOR->m_scale) - ((pWindow->m_originalClosedPos.x * PMONITOR->m_scale) * scaleXY.x);
+    windowBox.y      = ((pWindow->m_realPosition->value().y - PMONITOR->m_position.y) * PMONITOR->m_scale) - ((pWindow->m_originalClosedPos.y * PMONITOR->m_scale) * scaleXY.y);
 
-    CRegion fakeDamage{0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y};
+    CRegion fakeDamage{0, 0, PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y};
 
     if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault()) {
 
         CRectPassElement::SRectData data;
 
-        data.box   = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.y};
+        data.box   = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.y};
         data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value());
 
         m_sRenderPass.add(makeShared<CRectPassElement>(data));
@@ -2565,17 +2566,17 @@ void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
     CBox       layerBox;
     // some mafs to figure out the correct box
     // the originalClosedPos is relative to the monitor's pos
-    Vector2D scaleXY = Vector2D((PMONITOR->scale * pLayer->m_realSize->value().x / (pLayer->m_geometry.w * PMONITOR->scale)),
-                                (PMONITOR->scale * pLayer->m_realSize->value().y / (pLayer->m_geometry.h * PMONITOR->scale)));
+    Vector2D scaleXY = Vector2D((PMONITOR->m_scale * pLayer->m_realSize->value().x / (pLayer->m_geometry.w * PMONITOR->m_scale)),
+                                (PMONITOR->m_scale * pLayer->m_realSize->value().y / (pLayer->m_geometry.h * PMONITOR->m_scale)));
 
-    layerBox.width  = PMONITOR->vecTransformedSize.x * scaleXY.x;
-    layerBox.height = PMONITOR->vecTransformedSize.y * scaleXY.y;
+    layerBox.width  = PMONITOR->m_transformedSize.x * scaleXY.x;
+    layerBox.height = PMONITOR->m_transformedSize.y * scaleXY.y;
     layerBox.x =
-        ((pLayer->m_realPosition->value().x - PMONITOR->vecPosition.x) * PMONITOR->scale) - (((pLayer->m_geometry.x - PMONITOR->vecPosition.x) * PMONITOR->scale) * scaleXY.x);
+        ((pLayer->m_realPosition->value().x - PMONITOR->m_position.x) * PMONITOR->m_scale) - (((pLayer->m_geometry.x - PMONITOR->m_position.x) * PMONITOR->m_scale) * scaleXY.x);
     layerBox.y =
-        ((pLayer->m_realPosition->value().y - PMONITOR->vecPosition.y) * PMONITOR->scale) - (((pLayer->m_geometry.y - PMONITOR->vecPosition.y) * PMONITOR->scale) * scaleXY.y);
+        ((pLayer->m_realPosition->value().y - PMONITOR->m_position.y) * PMONITOR->m_scale) - (((pLayer->m_geometry.y - PMONITOR->m_position.y) * PMONITOR->m_scale) * scaleXY.y);
 
-    CRegion                      fakeDamage{0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y};
+    CRegion                      fakeDamage{0, 0, PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y};
 
     CTexPassElement::SRenderData data;
     data.flipEndFrame = true;
diff --git a/src/render/decorations/CHyprBorderDecoration.cpp b/src/render/decorations/CHyprBorderDecoration.cpp
index d1d8e9c0..75990896 100644
--- a/src/render/decorations/CHyprBorderDecoration.cpp
+++ b/src/render/decorations/CHyprBorderDecoration.cpp
@@ -52,7 +52,7 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
     if (m_bAssignedGeometry.width < m_seExtents.topLeft.x + 1 || m_bAssignedGeometry.height < m_seExtents.topLeft.y + 1)
         return;
 
-    CBox windowBox = assignedBoxGlobal().translate(-pMonitor->vecPosition + m_pWindow->m_floatingOffset).expand(-m_pWindow->getRealBorderSize()).scale(pMonitor->scale).round();
+    CBox windowBox = assignedBoxGlobal().translate(-pMonitor->m_position + m_pWindow->m_floatingOffset).expand(-m_pWindow->getRealBorderSize()).scale(pMonitor->m_scale).round();
 
     if (windowBox.width < 1 || windowBox.height < 1)
         return;
@@ -71,7 +71,7 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
     }
 
     int                             borderSize    = m_pWindow->getRealBorderSize();
-    const auto                      ROUNDING      = m_pWindow->rounding() * pMonitor->scale;
+    const auto                      ROUNDING      = m_pWindow->rounding() * pMonitor->m_scale;
     const auto                      ROUNDINGPOWER = m_pWindow->roundingPower();
 
     CBorderPassElement::SBorderData data;
@@ -134,7 +134,7 @@ void CHyprBorderDecoration::damageEntire() {
 
     for (auto const& m : g_pCompositor->m_monitors) {
         if (!g_pHyprRenderer->shouldRenderWindow(m_pWindow.lock(), m)) {
-            const CRegion monitorRegion({m->vecPosition, m->vecSize});
+            const CRegion monitorRegion({m->m_position, m->m_size});
             borderRegion.subtract(monitorRegion);
         }
     }
diff --git a/src/render/decorations/CHyprDropShadowDecoration.cpp b/src/render/decorations/CHyprDropShadowDecoration.cpp
index ff9a195e..198a9c96 100644
--- a/src/render/decorations/CHyprDropShadowDecoration.cpp
+++ b/src/render/decorations/CHyprDropShadowDecoration.cpp
@@ -68,7 +68,7 @@ void CHyprDropShadowDecoration::damageEntire() {
 
     for (auto const& m : g_pCompositor->m_monitors) {
         if (!g_pHyprRenderer->shouldRenderWindow(PWINDOW, m)) {
-            const CRegion monitorRegion({m->vecPosition, m->vecSize});
+            const CRegion monitorRegion({m->m_position, m->m_size});
             shadowRegion.subtract(monitorRegion);
         }
     }
@@ -125,7 +125,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
 
     // draw the shadow
     CBox fullBox = m_bLastWindowBoxWithDecos;
-    fullBox.translate(-pMonitor->vecPosition + WORKSPACEOFFSET);
+    fullBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
     fullBox.x -= *PSHADOWSIZE;
     fullBox.y -= *PSHADOWSIZE;
     fullBox.w += 2 * *PSHADOWSIZE;
@@ -138,9 +138,9 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
 
     updateWindow(PWINDOW);
     m_vLastWindowPos += WORKSPACEOFFSET;
-    m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->vecPosition.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->vecPosition.y + 2},
-                   {fullBox.x + fullBox.width + pMonitor->vecPosition.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2,
-                    fullBox.y + fullBox.height + pMonitor->vecPosition.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}};
+    m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->m_position.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->m_position.y + 2},
+                   {fullBox.x + fullBox.width + pMonitor->m_position.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2,
+                    fullBox.y + fullBox.height + pMonitor->m_position.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}};
 
     fullBox.translate(PWINDOW->m_floatingOffset);
 
@@ -155,25 +155,25 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
     CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorSwapFB;
     auto*         LASTFB      = g_pHyprOpenGL->m_RenderData.currentFB;
 
-    fullBox.scale(pMonitor->scale).round();
+    fullBox.scale(pMonitor->m_scale).round();
 
     if (*PSHADOWIGNOREWINDOW) {
         CBox windowBox = m_bLastWindowBox;
         CBox withDecos = m_bLastWindowBoxWithDecos;
 
         // get window box
-        windowBox.translate(-pMonitor->vecPosition + WORKSPACEOFFSET);
-        withDecos.translate(-pMonitor->vecPosition + WORKSPACEOFFSET);
+        windowBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
+        withDecos.translate(-pMonitor->m_position + WORKSPACEOFFSET);
 
         windowBox.translate(PWINDOW->m_floatingOffset);
         withDecos.translate(PWINDOW->m_floatingOffset);
 
         auto scaledExtentss = withDecos.extentsFrom(windowBox);
-        scaledExtentss      = scaledExtentss * pMonitor->scale;
+        scaledExtentss      = scaledExtentss * pMonitor->m_scale;
         scaledExtentss      = scaledExtentss.round();
 
         // add extents
-        windowBox.scale(pMonitor->scale).round().addExtents(scaledExtentss);
+        windowBox.scale(pMonitor->m_scale).round().addExtents(scaledExtentss);
 
         if (windowBox.width < 1 || windowBox.height < 1)
             return; // prevent assert failed
@@ -181,7 +181,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
         CRegion saveDamage = g_pHyprOpenGL->m_RenderData.damage;
 
         g_pHyprOpenGL->m_RenderData.damage = fullBox;
-        g_pHyprOpenGL->m_RenderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->scale)).intersect(saveDamage);
+        g_pHyprOpenGL->m_RenderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->m_scale)).intersect(saveDamage);
         g_pHyprOpenGL->m_RenderData.renderModif.applyToRegion(g_pHyprOpenGL->m_RenderData.damage);
 
         alphaFB.bind();
@@ -192,10 +192,10 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
         g_pHyprOpenGL->renderRect(fullBox, CHyprColor(0, 0, 0, 1), 0);
 
         // render white shadow with the alpha of the shadow color (otherwise we clear with alpha later and shit it to 2 bit)
-        drawShadowInternal(fullBox, ROUNDING * pMonitor->scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->scale, CHyprColor(1, 1, 1, PWINDOW->m_realShadowColor->value().a), a);
+        drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, CHyprColor(1, 1, 1, PWINDOW->m_realShadowColor->value().a), a);
 
         // render black window box ("clip")
-        g_pHyprOpenGL->renderRect(windowBox, CHyprColor(0, 0, 0, 1.0), (ROUNDING + 1 /* This fixes small pixel gaps. */) * pMonitor->scale, ROUNDINGPOWER);
+        g_pHyprOpenGL->renderRect(windowBox, CHyprColor(0, 0, 0, 1.0), (ROUNDING + 1 /* This fixes small pixel gaps. */) * pMonitor->m_scale, ROUNDINGPOWER);
 
         alphaSwapFB.bind();
 
@@ -204,7 +204,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
 
         LASTFB->bind();
 
-        CBox monbox = {0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y};
+        CBox monbox = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y};
 
         g_pHyprOpenGL->setMonitorTransformEnabled(true);
         g_pHyprOpenGL->setRenderModifEnabled(false);
@@ -214,7 +214,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
 
         g_pHyprOpenGL->m_RenderData.damage = saveDamage;
     } else
-        drawShadowInternal(fullBox, ROUNDING * pMonitor->scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->scale, PWINDOW->m_realShadowColor->value(), a);
+        drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, PWINDOW->m_realShadowColor->value(), a);
 
     if (m_seExtents != m_seReportedExtents)
         g_pDecorationPositioner->repositionDeco(this);
diff --git a/src/render/decorations/CHyprGroupBarDecoration.cpp b/src/render/decorations/CHyprGroupBarDecoration.cpp
index 57861d26..aa070e67 100644
--- a/src/render/decorations/CHyprGroupBarDecoration.cpp
+++ b/src/render/decorations/CHyprGroupBarDecoration.cpp
@@ -143,11 +143,11 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
     for (int i = 0; i < barsToDraw; ++i) {
         const auto WINDOWINDEX = *PSTACKED ? m_dwGroupMembers.size() - i - 1 : i;
 
-        CBox       rect = {ASSIGNEDBOX.x + xoff - pMonitor->vecPosition.x + m_pWindow->m_floatingOffset.x,
-                           ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->vecPosition.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
+        CBox       rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_pWindow->m_floatingOffset.x,
+                           ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
                            *PINDICATORHEIGHT};
 
-        rect.scale(pMonitor->scale).round();
+        rect.scale(pMonitor->m_scale).round();
 
         const bool        GROUPLOCKED  = m_pWindow->getGroupHead()->m_groupData.locked || g_pKeybindManager->m_bGroupsLocked;
         const auto* const PCOLACTIVE   = GROUPLOCKED ? GROUPCOLACTIVELOCKED : GROUPCOLACTIVE;
@@ -187,10 +187,10 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
             g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(rectdata));
         }
 
-        rect = {ASSIGNEDBOX.x + xoff - pMonitor->vecPosition.x + m_pWindow->m_floatingOffset.x,
-                ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->vecPosition.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
+        rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_pWindow->m_floatingOffset.x,
+                ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
                 (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0)};
-        rect.scale(pMonitor->scale);
+        rect.scale(pMonitor->m_scale);
 
         if (!rect.empty()) {
             if (*PGRADIENTS) {
@@ -232,17 +232,17 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
                 CTitleTex* pTitleTex = textureFromTitle(m_dwGroupMembers[WINDOWINDEX]->m_title);
 
                 if (!pTitleTex)
-                    pTitleTex =
-                        m_sTitleTexs.titleTexs
-                            .emplace_back(makeUnique<CTitleTex>(m_dwGroupMembers[WINDOWINDEX].lock(),
-                                                                Vector2D{m_fBarWidth * pMonitor->scale, (*PTITLEFONTSIZE + 2L * BAR_TEXT_PAD) * pMonitor->scale}, pMonitor->scale))
-                            .get();
+                    pTitleTex = m_sTitleTexs.titleTexs
+                                    .emplace_back(makeUnique<CTitleTex>(m_dwGroupMembers[WINDOWINDEX].lock(),
+                                                                        Vector2D{m_fBarWidth * pMonitor->m_scale, (*PTITLEFONTSIZE + 2L * BAR_TEXT_PAD) * pMonitor->m_scale},
+                                                                        pMonitor->m_scale))
+                                    .get();
 
                 const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->texActive : pTitleTex->texInactive;
-                rect.y += std::ceil(((rect.height - titleTex->m_vSize.y) / 2.0) - (*PTEXTOFFSET * pMonitor->scale));
+                rect.y += std::ceil(((rect.height - titleTex->m_vSize.y) / 2.0) - (*PTEXTOFFSET * pMonitor->m_scale));
                 rect.height = titleTex->m_vSize.y;
                 rect.width  = titleTex->m_vSize.x;
-                rect.x += std::round(((m_fBarWidth * pMonitor->scale) / 2.0) - (titleTex->m_vSize.x / 2.0));
+                rect.x += std::round(((m_fBarWidth * pMonitor->m_scale) / 2.0) - (titleTex->m_vSize.x / 2.0));
                 rect.round();
 
                 CTexPassElement::SRenderData data;
@@ -300,7 +300,7 @@ static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) {
     if (!g_pCompositor->m_lastMonitor)
         return;
 
-    const Vector2D& bufferSize = g_pCompositor->m_lastMonitor->vecPixelSize;
+    const Vector2D& bufferSize = g_pCompositor->m_lastMonitor->m_pixelSize;
 
     const auto      CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, bufferSize.x, bufferSize.y);
     const auto      CAIRO        = cairo_create(CAIROSURFACE);
diff --git a/src/render/pass/Pass.cpp b/src/render/pass/Pass.cpp
index 6a56eea8..65d0ee65 100644
--- a/src/render/pass/Pass.cpp
+++ b/src/render/pass/Pass.cpp
@@ -30,7 +30,7 @@ void CRenderPass::simplify() {
     // if there is live blur, we need to NOT occlude any area where it will be influenced
     const auto WILLBLUR = std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->needsLiveBlur(); });
 
-    CRegion    newDamage = damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize});
+    CRegion    newDamage = damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize});
     for (auto& el : m_vPassElements | std::views::reverse) {
 
         if (newDamage.empty() && !el->element->undiscardable()) {
@@ -43,7 +43,7 @@ void CRenderPass::simplify() {
         if (!bb1 || newDamage.empty())
             continue;
 
-        auto bb = bb1->scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale);
+        auto bb = bb1->scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
 
         // drop if empty
         if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) {
@@ -54,7 +54,7 @@ void CRenderPass::simplify() {
         auto opaque = el->element->opaqueRegion();
 
         if (!opaque.empty()) {
-            opaque.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale);
+            opaque.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
 
             // if this intersects the liveBlur region, allow live blur to operate correctly.
             // do not occlude a border near it.
@@ -76,7 +76,7 @@ void CRenderPass::simplify() {
                 }
 
                 // expand the region: this area needs to be proper to blur it right.
-                liveBlurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale).expand(oneBlurRadius() * 2.F);
+                liveBlurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).expand(oneBlurRadius() * 2.F);
 
                 if (auto infringement = opaque.copy().intersect(liveBlurRegion); !infringement.empty()) {
                     // eh, this is not the correct solution, but it will do...
@@ -98,7 +98,7 @@ void CRenderPass::simplify() {
             const auto BB = el2->element->boundingBox();
             RASSERT(BB, "No bounding box for an element with live blur is illegal");
 
-            totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale));
+            totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale));
         }
     }
 }
@@ -146,7 +146,7 @@ CRegion CRenderPass::render(const CRegion& damage_) {
             blurRegion.add(*BB);
         }
 
-        blurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale);
+        blurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
 
         blurRegion.intersect(damage).expand(oneBlurRadius());
 
@@ -197,7 +197,7 @@ CRegion CRenderPass::render(const CRegion& damage_) {
 }
 
 void CRenderPass::renderDebugData() {
-    CBox box = {{}, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize};
+    CBox box = {{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize};
     for (const auto& rg : occludedRegions) {
         g_pHyprOpenGL->renderRectWithDamage(box, Colors::RED.modifyA(0.1F), rg);
     }
@@ -219,9 +219,9 @@ void CRenderPass::renderDebugData() {
         if (!bb.has_value())
             return;
 
-        CBox box = bb->copy().translate(-g_pHyprOpenGL->m_RenderData.pMonitor->vecPosition).scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale);
+        CBox box = bb->copy().translate(-g_pHyprOpenGL->m_RenderData.pMonitor->m_position).scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
 
-        if (box.intersection(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->vecSize}).empty())
+        if (box.intersection(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_size}).empty())
             return;
 
         g_pHyprOpenGL->renderRectWithDamage(box, color, CRegion{0, 0, INT32_MAX, INT32_MAX});
@@ -251,8 +251,8 @@ void CRenderPass::renderDebugData() {
                 auto BOX = hlSurface->getSurfaceBoxGlobal();
                 if (BOX) {
                     auto region = g_pSeatManager->state.pointerFocus->current.input.copy()
-                                      .scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale)
-                                      .translate(BOX->pos() - g_pHyprOpenGL->m_RenderData.pMonitor->vecPosition);
+                                      .scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale)
+                                      .translate(BOX->pos() - g_pHyprOpenGL->m_RenderData.pMonitor->m_position);
                     g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.8F, 0.8F, 0.2F, 0.4F}, region);
                 }
             }
@@ -261,11 +261,11 @@ void CRenderPass::renderDebugData() {
 
     const auto DISCARDED_ELEMENTS = std::count_if(m_vPassElements.begin(), m_vPassElements.end(), [](const auto& e) { return e->discard; });
     auto tex = g_pHyprOpenGL->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", occludedRegions.size(), m_vPassElements.size(),
-                                                     DISCARDED_ELEMENTS, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize),
+                                                     DISCARDED_ELEMENTS, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize),
                                          Colors::WHITE, 12);
 
     if (tex) {
-        box = CBox{{0.F, g_pHyprOpenGL->m_RenderData.pMonitor->vecSize.y - tex->m_vSize.y}, tex->m_vSize}.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale);
+        box = CBox{{0.F, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_vSize.y}, tex->m_vSize}.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
         g_pHyprOpenGL->renderTexture(tex, box, 1.F);
     }
 
@@ -282,8 +282,8 @@ void CRenderPass::renderDebugData() {
 
     tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12);
     if (tex) {
-        box = CBox{{g_pHyprOpenGL->m_RenderData.pMonitor->vecSize.x - tex->m_vSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecSize.y - tex->m_vSize.y}, tex->m_vSize}.scale(
-            g_pHyprOpenGL->m_RenderData.pMonitor->scale);
+        box = CBox{{g_pHyprOpenGL->m_RenderData.pMonitor->m_size.x - tex->m_vSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_vSize.y}, tex->m_vSize}.scale(
+            g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
         g_pHyprOpenGL->renderTexture(tex, box, 1.F);
     }
 }
diff --git a/src/render/pass/RectPassElement.cpp b/src/render/pass/RectPassElement.cpp
index cd354844..1dab6a71 100644
--- a/src/render/pass/RectPassElement.cpp
+++ b/src/render/pass/RectPassElement.cpp
@@ -29,7 +29,7 @@ bool CRectPassElement::needsPrecomputeBlur() {
 }
 
 std::optional<CBox> CRectPassElement::boundingBox() {
-    return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->scale).round();
+    return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).round();
 }
 
 CRegion CRectPassElement::opaqueRegion() {
diff --git a/src/render/pass/SurfacePassElement.cpp b/src/render/pass/SurfacePassElement.cpp
index 22e61a23..ed0e3000 100644
--- a/src/render/pass/SurfacePassElement.cpp
+++ b/src/render/pass/SurfacePassElement.cpp
@@ -64,7 +64,7 @@ void CSurfacePassElement::draw(const CRegion& damage) {
 
     const auto  PROJSIZEUNSCALED = windowBox.size();
 
-    windowBox.scale(data.pMonitor->scale);
+    windowBox.scale(data.pMonitor->m_scale);
     windowBox.round();
 
     if (windowBox.width <= 1 || windowBox.height <= 1) {
@@ -72,14 +72,14 @@ void CSurfacePassElement::draw(const CRegion& damage) {
         return;
     }
 
-    const bool MISALIGNEDFSV1 = std::floor(data.pMonitor->scale) != data.pMonitor->scale /* Fractional */ && data.surface->current.scale == 1 /* fs protocol */ &&
+    const bool MISALIGNEDFSV1 = std::floor(data.pMonitor->m_scale) != data.pMonitor->m_scale /* Fractional */ && data.surface->current.scale == 1 /* fs protocol */ &&
         windowBox.size() != data.surface->current.bufferSize /* misaligned */ && DELTALESSTHAN(windowBox.width, data.surface->current.bufferSize.x, 3) &&
         DELTALESSTHAN(windowBox.height, data.surface->current.bufferSize.y, 3) /* off by one-or-two */ &&
         (!data.pWindow || (!data.pWindow->m_realSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */;
 
     if (data.surface->colorManagement.valid())
         Debug::log(TRACE, "FIXME: rendering surface with color management enabled, should apply necessary transformations");
-    g_pHyprRenderer->calculateUVForSurface(data.pWindow, data.surface, data.pMonitor->self.lock(), data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
+    g_pHyprRenderer->calculateUVForSurface(data.pWindow, data.surface, data.pMonitor->m_self.lock(), data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
 
     auto cancelRender                      = false;
     g_pHyprOpenGL->m_RenderData.clipRegion = visibleRegion(cancelRender);
@@ -127,7 +127,7 @@ void CSurfacePassElement::draw(const CRegion& damage) {
     }
 
     if (!g_pHyprRenderer->m_bBlockSurfaceFeedback)
-        data.surface->presentFeedback(data.when, data.pMonitor->self.lock());
+        data.surface->presentFeedback(data.when, data.pMonitor->m_self.lock());
 
     // add async (dmabuf) buffers to usedBuffers so we can handle release later
     // sync (shm) buffers will be released in commitState, so no need to track them here
@@ -138,7 +138,7 @@ void CSurfacePassElement::draw(const CRegion& damage) {
 }
 
 CBox CSurfacePassElement::getTexBox() {
-    const double outputX = -data.pMonitor->vecPosition.x, outputY = -data.pMonitor->vecPosition.y;
+    const double outputX = -data.pMonitor->m_position.x, outputY = -data.pMonitor->m_position.y;
 
     const auto   INTERACTIVERESIZEINPROGRESS = data.pWindow && g_pInputManager->currentlyDraggedWindow && g_pInputManager->dragMode == MBIND_RESIZE;
     auto         PSURFACE                    = CWLSurface::fromResource(data.surface);
@@ -230,7 +230,7 @@ CRegion CSurfacePassElement::opaqueRegion() {
         CRegion    opaqueSurf = data.surface->current.opaque.copy().intersect(CBox{{}, {data.w, data.h}});
         const auto texBox     = getTexBox();
         opaqueSurf.scale(texBox.size() / Vector2D{data.w, data.h});
-        return opaqueSurf.translate(data.pos + data.localPos - data.pMonitor->vecPosition).expand(-data.rounding);
+        return opaqueSurf.translate(data.pos + data.localPos - data.pMonitor->m_position).expand(-data.rounding);
     }
 
     return data.texture && data.texture->m_bOpaque ? boundingBox()->expand(-data.rounding) : CRegion{};
@@ -269,11 +269,11 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
     visibleRegion.translate(-uvTL * bufferSize);
 
     auto texBox = getTexBox();
-    texBox.scale(data.pMonitor->scale);
+    texBox.scale(data.pMonitor->m_scale);
     texBox.round();
 
     visibleRegion.scale((Vector2D(1, 1) / (uvBR - uvTL)) * (texBox.size() / bufferSize));
-    visibleRegion.translate((data.pos + data.localPos) * data.pMonitor->scale - data.pMonitor->vecPosition);
+    visibleRegion.translate((data.pos + data.localPos) * data.pMonitor->m_scale - data.pMonitor->m_position);
 
     return visibleRegion;
 }
@@ -281,6 +281,6 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
 void CSurfacePassElement::discard() {
     if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) {
         Debug::log(TRACE, "discard for invisible surface");
-        data.surface->presentFeedback(data.when, data.pMonitor->self.lock(), true);
+        data.surface->presentFeedback(data.when, data.pMonitor->m_self.lock(), true);
     }
 }
diff --git a/src/render/pass/TexPassElement.cpp b/src/render/pass/TexPassElement.cpp
index 01302907..3ccad6cb 100644
--- a/src/render/pass/TexPassElement.cpp
+++ b/src/render/pass/TexPassElement.cpp
@@ -24,7 +24,7 @@ void CTexPassElement::draw(const CRegion& damage) {
         g_pHyprOpenGL->m_RenderData.monitorProjection = *data.replaceProjection;
     g_pHyprOpenGL->renderTextureInternalWithDamage(data.tex, data.box, data.a, data.damage.empty() ? damage : data.damage, data.round, data.roundingPower);
     if (data.replaceProjection)
-        g_pHyprOpenGL->m_RenderData.monitorProjection = g_pHyprOpenGL->m_RenderData.pMonitor->projMatrix;
+        g_pHyprOpenGL->m_RenderData.monitorProjection = g_pHyprOpenGL->m_RenderData.pMonitor->m_projMatrix;
 }
 
 bool CTexPassElement::needsLiveBlur() {
@@ -36,7 +36,7 @@ bool CTexPassElement::needsPrecomputeBlur() {
 }
 
 std::optional<CBox> CTexPassElement::boundingBox() {
-    return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->scale).round();
+    return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).round();
 }
 
 CRegion CTexPassElement::opaqueRegion() {