version: bump to 0.49.0

* layout: allow interacting with pinned windows when fullscreened

* IHyprLayout: format code

* e

.github/ISSUE_TEMPLATE/bug.yml

@@ -1,117 +1,15 @@
-name: Bug Report
-description: Something is not working right
-labels: ["bug"]
+name: Do not open issues, go to discussions please!
+description: Do not open an issue
 body:
   - type: checkboxes
     attributes:
-      label: Already reported ? *
-      description: Before opening a new bug report, please take a moment to search through the current open issues. If the same bug is already reported, don't open new issue - instead go upvote/comment on an existing one.
+      label: Please close this issue.
+      description: Users cannot open issues. I want my issue to be closed.
       options:
-        - label: I have searched the existing open and closed issues.
+        - label: Yes, I want this issue to be closed.
           required: true
 
-  - type: dropdown
-    id: type
-    attributes:
-      label: Regression?
-      description: |
-        Regression means that something used to work but no longer does.
-        **BEFORE CONTINUING**, please check if this bug is a regression or not, and if it is, we need you to bisect with the help of the wiki: https://wiki.hyprland.org/Crashes-and-Bugs/#bisecting-an-issue
-      multiple: true
-      options:
-        - "Definitely a regression - something broke after update (requires bisect)"
-        - "Probably not a regression / I don't remember it happening before"
-        - "Not a regression - it's bug regarding new feature"
-        - "Not a regression - it's an old bug"
-        - "I don't know, I started using Hyprland only recently"
-    validations:
-      required: true
-
   - type: textarea
-    id: ver
+    id: body
     attributes:
-      label: System Info and Hyprland Version
-      description: |
-        Paste the output of `hyprctl systeminfo` here. If you can't
-        launch Hyprland, paste the output of `Hyprland --systeminfo`.
-      value: "<details>
-        <summary>System/Version info</summary>
-
-
-        ```
-
-        <Paste the output of the command here, without removing any formatting around this>
-
-        ```
-
-
-        </details>"
-    validations:
-      required: true
-
-  - type: textarea
-    id: desc
-    attributes:
-      label: Description
-      description: "What went wrong?"
-    validations:
-      required: true
-
-  - type: textarea
-    id: repro
-    attributes:
-      label: How to reproduce
-      description: "How can someone else reproduce the issue?"
-      placeholder: |
-        1. ...
-        2. ...
-        3. ...
-
-    validations:
-      required: true
-
-  - type: markdown
-    attributes:
-      value: |
-        ## Additional info section
-
-        In the section below you will be asked to upload some files.
-
-        When including text files (such as logs or config), please **always ATTACH** them, and not paste them directly.
-
-        This is important to avoid clutter, spam, and make the issues more readable.
-        Thanks for your understanding.
-
-  # The main reason to disallow pasting directly or in a dropdown, is to not clutter
-  # the issue with unnecessary keywords, making the github issue search useless.
-  - type: checkboxes
-    attributes:
-      label: Attach not paste
-      options:
-        - label: I understand that all text files must be *attached*, and not pasted directly. If not respected, this issue will likely get closed as spam
-          required: true
-
-  - type: markdown
-    attributes:
-      value: >-
-        Please be sure to upload the following files below if they are relevant to the issue:
-
-          - Logs can be found in $XDG_RUNTIME_DIR/hypr (sort by date to grab the latest)
-          - Crash reports are stored in ~/.cache/hyprland or $XDG_CACHE_HOME/hyprland
-          - Hyprland config files - `hyprctl systeminfo -c > /tmp/hyprland_config_dump.txt` use this command to dump full configuration to a single file.
-
-  - type: checkboxes
-    attributes:
-      label: Checklist of files to include below
-      options:
-        - label: Hyprland config - `hyprctl systeminfo -c` (always include)
-        - label: Crash report (always include in case of crash)
-        - label: Video (always include in case of a visual bug)
-        - label: Logs (might contain useful info such as errors)
-
-  - type: textarea
-    id: logs
-    attributes:
-      label: Additional info & File uploads
-      description: |
-        Tip: You can attach files by clicking this area to highlight it and then dragging files in.
+      label: Issue body

.github/ISSUE_TEMPLATE/feature.yml

@@ -1,19 +0,0 @@
-name: Feature Request
-description: I'd like to request additional functionality
-labels: ["enhancement"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Before opening a new issue, take a moment to search through the current open ones.
-
-        ---
-
-  - type: textarea
-    id: desc
-    attributes:
-      label: Description
-      description: "Describe your idea"
-    validations:
-      required: true
-

.github/actions/setup_base/action.yml

@@ -20,6 +20,7 @@ runs:
           clang \
           cmake \
           git \
+          glaze \
           glm \
           glslang \
           go \
@@ -64,15 +65,6 @@ runs:
           librsvg \
           re2
 
-    - name: Get glaze
-      shell: bash
-      run: |
-        git clone https://github.com/stephenberry/glaze.git
-        cd glaze
-        cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build
-        cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
-        cmake --install build
-
     - name: Get hyprwayland-scanner-git
       shell: bash
       run: |

.github/workflows/close-issues.yml

@@ -0,0 +1,101 @@
+name: Close Unauthorized Issues
+
+on:
+  workflow_dispatch:
+  issues:
+    types: [opened]
+
+jobs:
+  close-unauthorized-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      # XXX: This *could* be done in Bash by abusing GitHub's own tool to interact with its API
+      # but that's too much of a hack, and we'll be adding a layer of abstraction. github-script
+      # is a workflow that eases interaction with GitHub API in the workflow run context.
+      - name: "Close 'unauthorized' issues"
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const ALLOWED_USERS = ['vaxerski', 'fufexan', 'NotAShelf'];
+            const CLOSING_COMMENT = 'Users are no longer allowed to open issues themselves, please open a discussion instead.\n\nPlease see the [wiki](https://wiki.hyprland.org/Contributing-and-Debugging/Issue-Guidelines/) on why this is the case.\n\nWe are volunteers, and we need your cooperation to make the best software we can. Thank you for understanding! ❤️\n\n[Open a discussion here](https://github.com/hyprwm/Hyprland/discussions)';
+
+            async function closeUnauthorizedIssue(issueNumber, userName) {
+              if (ALLOWED_USERS.includes(userName)) {
+                console.log(`Issue #${issueNumber} - Created by authorized user ${userName}`);
+                return;
+              }
+
+              console.log(`Issue #${issueNumber} - Unauthorized, closing`);
+
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                state: 'closed',
+                state_reason: 'not_planned'
+              });
+
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                body: CLOSING_COMMENT
+              });
+            }
+
+            if (context.eventName === 'issues' && context.payload.action === 'opened') {
+              // Direct access to the issue that triggered the workflow
+              const issue = context.payload.issue;
+
+              // Skip if this is a PR
+              if (issue.pull_request) {
+                console.log(`Issue #${issue.number} - Skipping, this is a pull request`);
+                return;
+              }
+
+              // Process the single issue that triggered the workflow
+              await closeUnauthorizedIssue(issue.number, issue.user.login);
+            } else {
+              // For manual runs, we need to handle pagination
+              async function* fetchAllOpenIssues() {
+                let page = 1;
+                let hasNextPage = true;
+
+                while (hasNextPage) {
+                  const response = await github.rest.issues.listForRepo({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    state: 'open',
+                    per_page: 100,
+                    page: page
+                  });
+
+                  if (response.data.length === 0) {
+                    hasNextPage = false;
+                  } else {
+                    for (const issue of response.data) {
+                      yield issue;
+                    }
+                    page++;
+                  }
+                }
+              }
+
+              // Process issues one by one
+              for await (const issue of fetchAllOpenIssues()) {
+                try {
+                  // Skip pull requests
+                  if (issue.pull_request) {
+                    console.log(`Issue #${issue.number} - Skipping, this is a pull request`);
+                    continue;
+                  }
+
+                  await closeUnauthorizedIssue(issue.number, issue.user.login);
+                } catch (error) {
+                  console.error(`Error processing issue #${issue.number}: ${error.message}`);
+                }
+              }
+            }

.github/workflows/stale.yml

@@ -1,28 +0,0 @@
-# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
-#
-# You can adjust the behavior by modifying this file.
-# For more information, see:
-# https://github.com/actions/stale
-name: Mark stale issues and pull requests
-
-on:
-  schedule:
-    - cron: "7 */4 * * *"
-  workflow_dispatch:
-
-jobs:
-  stale:
-    if: github.repository == 'hyprwm/Hyprland'
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-
-    steps:
-      - uses: actions/stale@v9
-        with:
-          repo-token: ${{ secrets.STALEBOT_PAT }}
-          stale-issue-label: "stale"
-          stale-pr-label: "stale"
-          operations-per-run: 40
-          days-before-close: -1

.gitignore

@@ -28,6 +28,8 @@ protocols/*.c*
 protocols/*.h*
 .ccls-cache
 *.so
+src/render/shaders/*.inc
+src/render/shaders/Shaders.hpp
 
 hyprctl/hyprctl
 

CMakeLists.txt

@@ -25,6 +25,9 @@ message(STATUS "Gathering git info")
 # Get git info hash and branch
 execute_process(COMMAND ./scripts/generateVersion.sh
                 WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+# Make shader files includable
+execute_process(COMMAND ./scripts/generateShaderIncludes.sh
+                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 
 find_package(PkgConfig REQUIRED)
 
@@ -86,6 +89,7 @@ add_compile_options(
   -Wno-missing-field-initializers
   -Wno-narrowing
   -Wno-pointer-arith
+  -Wno-clobbered
   -fmacro-prefix-map=${CMAKE_SOURCE_DIR}/=)
 
 set(CMAKE_EXECUTABLE_ENABLE_EXPORTS TRUE)
@@ -105,7 +109,7 @@ find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.8.0)
 pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2)
 pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7)
-pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.5.1)
+pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.7.0)
 pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
 
 string(REPLACE "." ";" AQ_VERSION_LIST ${aquamarine_dep_VERSION})
@@ -129,7 +133,7 @@ pkg_check_modules(
   xkbcommon
   uuid
   wayland-server>=1.22.90
-  wayland-protocols>=1.41
+  wayland-protocols>=1.43
   cairo
   pango
   pangocairo
@@ -313,7 +317,7 @@ endfunction()
 
 target_link_libraries(Hyprland OpenGL::EGL OpenGL::GL Threads::Threads)
 
-pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.2)
+pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.4)
 if(hyprland_protocols_dep_FOUND)
   pkg_get_variable(HYPRLAND_PROTOCOLS hyprland-protocols pkgdatadir)
   message(STATUS "hyprland-protocols dependency set to ${HYPRLAND_PROTOCOLS}")
@@ -345,6 +349,7 @@ protocolnew("protocols" "wayland-drm" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-ctm-control-v1" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-surface-v1" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-lock-notify-v1" true)
+protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-toplevel-mapping-v1" true)
 
 protocolnew("staging/tearing-control" "tearing-control-v1" false)
 protocolnew("staging/fractional-scale" "fractional-scale-v1" false)
@@ -379,6 +384,8 @@ protocolnew("staging/single-pixel-buffer" "single-pixel-buffer-v1" false)
 protocolnew("staging/security-context" "security-context-v1" false)
 protocolnew("staging/content-type" "content-type-v1" false)
 protocolnew("staging/color-management" "color-management-v1" false)
+protocolnew("staging/xdg-toplevel-tag" "xdg-toplevel-tag-v1" false)
+protocolnew("staging/xdg-system-bell" "xdg-system-bell-v1" false)
 
 protocolwayland()
 
@@ -444,5 +451,7 @@ install(
   DIRECTORY ${HEADERS_SRC}
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hyprland
   FILES_MATCHING
-  PATTERN "*.h*"
-  PATTERN "*.frag")
+  PATTERN "*.h"
+  PATTERN "*.hpp"
+  PATTERN "*.inc"
+  )

Makefile

@@ -52,7 +52,7 @@ installheaders:
 
 	cmake --build ./build --config Release --target generate-protocol-headers
 
-	find src -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
+	find src -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.inc' \) -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
 	cp ./protocols/*.h* ${PREFIX}/include/hyprland/protocols
 	cp ./build/hyprland.pc ${PREFIX}/share/pkgconfig
 	if [ -d /usr/share/pkgconfig ]; then cp ./build/hyprland.pc /usr/share/pkgconfig 2>/dev/null || true; fi

SECURITY.md

@@ -0,0 +1,32 @@
+# Hyprland Development Security Policy
+
+If you have a bug that affects the security of your system, you may
+want to privately disclose it instead of making it immediately public.
+
+## Supported versions
+
+_Only_ the most recent release on Github is supported. There are no LTS releases.
+
+## What is not a security issue
+
+Some examples of issues that should not be reported as security issues:
+
+- An app can execute a command when ran outside of a sandbox
+- An app can write / read hyprland sockets when ran outside of a sandbox
+- Crashes
+- Things that are protected via permissions when the permission system is disabled
+
+## What is a security issue
+
+Some examples of issues that should be reported as security issues:
+
+- Sandboxed application executing arbitrary code via Hyprland
+- Application being able to modify Hyprland's code on the fly
+- Application being able to keylog / track user's activity beyond what the wayland protocols allow
+
+## How to report security issues
+
+Please report your security issues via either of these channels:
+- Mail: `vaxry [at] vaxry [dot] net`
+- Matrix: `@vaxry:matrix.vaxry.net`
+- Discord: `@vaxry`

VERSION

@@ -1 +1 @@
-0.48.0
+0.49.0

example/hyprland.conf

@@ -52,6 +52,23 @@ env = XCURSOR_SIZE,24
 env = HYPRCURSOR_SIZE,24
 
 
+###################
+### PERMISSIONS ###
+###################
+
+# See https://wiki.hyprland.org/Configuring/Permissions/
+# Please note permission changes here require a Hyprland restart and are not applied on-the-fly
+# for security reasons
+
+# ecosystem {
+#   enforce_permissions = 1
+# }
+
+# permission = /usr/(bin|local/bin)/grim, screencopy, allow
+# permission = /usr/(lib|libexec|lib64)/xdg-desktop-portal-hyprland, screencopy, allow
+# permission = /usr/(bin|local/bin)/hyprpm, plugin, allow
+
+
 #####################
 ### LOOK AND FEEL ###
 #####################
@@ -260,8 +277,8 @@ bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume -l 1 @DEFAULT_AUDIO_SINK@
 bindel = ,XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-
 bindel = ,XF86AudioMute, exec, wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle
 bindel = ,XF86AudioMicMute, exec, wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle
-bindel = ,XF86MonBrightnessUp, exec, brightnessctl s 10%+
-bindel = ,XF86MonBrightnessDown, exec, brightnessctl s 10%-
+bindel = ,XF86MonBrightnessUp, exec, brightnessctl -e4 -n2 set 5%+
+bindel = ,XF86MonBrightnessDown, exec, brightnessctl -e4 -n2 set 5%-
 
 # Requires playerctl
 bindl = , XF86AudioNext, exec, playerctl next

flake.lock

@@ -16,11 +16,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742213273,
-        "narHash": "sha256-0l0vDb4anfsBu1rOs94bC73Hub+xEivgBAo6QXl2MmU=",
+        "lastModified": 1745357003,
+        "narHash": "sha256-jYwzQkv1r7HN/4qrAuKp+NR4YYNp2xDrOX5O9YVqkWo=",
         "owner": "hyprwm",
         "repo": "aquamarine",
-        "rev": "484b732195cc53f4536ce4bd59a5c6402b1e7ccf",
+        "rev": "a19cf76ee1a15c1c12083fa372747ce46387289f",
         "type": "github"
       },
       "original": {
@@ -79,11 +79,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742215578,
-        "narHash": "sha256-zfs71PXVVPEe56WEyNi2TJQPs0wabU4WAlq0XV7GcdE=",
+        "lastModified": 1745948457,
+        "narHash": "sha256-lzTV10FJTCGNtMdgW5YAhCAqezeAzKOd/97HbQK8GTU=",
         "owner": "hyprwm",
         "repo": "hyprcursor",
-        "rev": "2fd36421c21aa87e2fe3bee11067540ae612f719",
+        "rev": "ac903e80b33ba6a88df83d02232483d99f327573",
         "type": "github"
       },
       "original": {
@@ -105,11 +105,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1739049071,
-        "narHash": "sha256-3+7TpXMrbsUXSwgr5VAKAnmkzMb6JO+Rvc9XRb5NMg4=",
+        "lastModified": 1745015490,
+        "narHash": "sha256-apEJ9zoSzmslhJ2vOKFcXTMZLUFYzh1ghfB6Rbw3Low=",
         "owner": "hyprwm",
         "repo": "hyprgraphics",
-        "rev": "175c6b29b6ff82100539e7c4363a35a02c74dd73",
+        "rev": "60754910946b4e2dc1377b967b7156cb989c5873",
         "type": "github"
       },
       "original": {
@@ -128,11 +128,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1738422629,
-        "narHash": "sha256-5v+bv75wJWvahyM2xcMTSNNxmV8a7hb01Eey5zYnBJw=",
+        "lastModified": 1743714874,
+        "narHash": "sha256-yt8F7NhMFCFHUHy/lNjH/pjZyIDFNk52Q4tivQ31WFo=",
         "owner": "hyprwm",
         "repo": "hyprland-protocols",
-        "rev": "755aef8dab49d0fc4663c715fa4ad221b2aedaed",
+        "rev": "3a5c2bda1c1a4e55cc1330c782547695a93f05b2",
         "type": "github"
       },
       "original": {
@@ -189,11 +189,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1739048983,
-        "narHash": "sha256-REhTcXq4qs3B3cCDtLlYDz0GZvmsBSh947Ub6pQWGTQ=",
+        "lastModified": 1745951494,
+        "narHash": "sha256-2dModE32doiyQMmd6EDAQeZnz+5LOs6KXyE0qX76WIg=",
         "owner": "hyprwm",
         "repo": "hyprland-qtutils",
-        "rev": "3504a293c8f8db4127cb0f7cfc1a318ffb4316f8",
+        "rev": "4be1d324faf8d6e82c2be9f8510d299984dfdd2e",
         "type": "github"
       },
       "original": {
@@ -215,11 +215,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1741191527,
-        "narHash": "sha256-kM+11Nch47Xwfgtw2EpRitJuORy4miwoMuRi5tyMBDY=",
+        "lastModified": 1746655412,
+        "narHash": "sha256-kVQ0bHVtX6baYxRWWIh4u3LNJZb9Zcm2xBeDPOGz5BY=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "72df3861f1197e41b078faa3e38eedd60e00018d",
+        "rev": "557241780c179cf7ef224df392f8e67dab6cef83",
         "type": "github"
       },
       "original": {
@@ -238,11 +238,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1741534688,
-        "narHash": "sha256-EV3945SnjOCuRVbGRghsWx/9D89FyshnSO1Q6/TuQ14=",
+        "lastModified": 1746635225,
+        "narHash": "sha256-W9G9bb0zRYDBRseHbVez0J8qVpD5QbizX67H/vsudhM=",
         "owner": "hyprwm",
         "repo": "hyprutils",
-        "rev": "dd1f720cbc2dbb3c71167c9598045dd3261d27b3",
+        "rev": "674ea57373f08b7609ce93baff131117a0dfe70d",
         "type": "github"
       },
       "original": {
@@ -276,11 +276,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1742069588,
-        "narHash": "sha256-C7jVfohcGzdZRF6DO+ybyG/sqpo1h6bZi9T56sxLy+k=",
+        "lastModified": 1746461020,
+        "narHash": "sha256-7+pG1I9jvxNlmln4YgnlW4o+w0TZX24k688mibiFDUE=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "c80f6a7e10b39afcc1894e02ef785b1ad0b0d7e5",
+        "rev": "3730d8a308f94996a9ba7c7138ede69c1b9ac4ae",
         "type": "github"
       },
       "original": {
@@ -299,11 +299,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742058297,
-        "narHash": "sha256-b4SZc6TkKw8WQQssbN5O2DaCEzmFfvSTPYHlx/SFW9Y=",
+        "lastModified": 1746537231,
+        "narHash": "sha256-Wb2xeSyOsCoTCTj7LOoD6cdKLEROyFAArnYoS+noCWo=",
         "owner": "cachix",
         "repo": "git-hooks.nix",
-        "rev": "59f17850021620cd348ad2e9c0c64f4e6325ce2a",
+        "rev": "fa466640195d38ec97cf0493d6d6882bc4d14969",
         "type": "github"
       },
       "original": {
@@ -365,11 +365,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1741934139,
-        "narHash": "sha256-ZhTcTH9FoeAtbPfWGrhkH7RjLJZ7GeF18nygLAMR+WE=",
+        "lastModified": 1745871725,
+        "narHash": "sha256-M24SNc2flblWGXFkGQfqSlEOzAGZnMc9QG3GH4K/KbE=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "150b0b6f52bb422a1b232a53698606fe0320dde0",
+        "rev": "76bbf1a6b1378e4ab5230bad00ad04bc287c969e",
         "type": "github"
       },
       "original": {

hyprctl/hyprctl.bash

@@ -23,7 +23,7 @@ _hyprctl () {
     local words cword
     _get_comp_words_by_ref -n "$COMP_WORDBREAKS" words cword
 
-    declare -a literals=(resizeactive 2 changegroupactive -r moveintogroup forceallowsinput 4 ::= systeminfo all layouts setprop animationstyle switchxkblayout create denywindowfromgroup headless activebordercolor exec setcursor wayland focusurgentorlast workspacerules movecurrentworkspacetomonitor movetoworkspacesilent hyprpaper alpha inactivebordercolor movegroupwindow movecursortocorner movewindowpixel prev movewindow globalshortcuts clients dimaround setignoregrouplock splash execr monitors 0 forcenoborder -q animations 1 nomaxsize splitratio moveactive pass swapnext devices layers rounding lockactivegroup 5 moveworkspacetomonitor -f -i --quiet forcenodim pin 0 1 forceopaque forcenoshadow setfloating minsize alphaoverride sendshortcut workspaces cyclenext alterzorder togglegroup lockgroups bordersize dpms focuscurrentorlast -1 --batch notify remove instances 1 3 moveoutofgroup killactive 2 movetoworkspace movecursor configerrors closewindow swapwindow tagwindow forcerendererreload centerwindow auto focuswindow seterror nofocus alphafullscreen binds version -h togglespecialworkspace fullscreen windowdancecompat 0 keyword toggleopaque 3 --instance togglefloating renameworkspace alphafullscreenoverride activeworkspace x11 kill forceopaqueoverriden output global dispatch reload forcenoblur -j event --help disable -1 activewindow keepaspectratio dismissnotify focusmonitor movefocus plugin exit workspace fullscreenstate getoption alphainactiveoverride alphainactive decorations settiled config-only descriptions resizewindowpixel fakefullscreen rollinglog swapactiveworkspaces submap next movewindoworgroup cursorpos forcenoanims focusworkspaceoncurrentmonitor maxsize)
+    declare -a literals=(resizeactive 2 changegroupactive -r moveintogroup forceallowsinput 4 ::= systeminfo all layouts setprop animationstyle switchxkblayout create denywindowfromgroup headless activebordercolor exec setcursor wayland focusurgentorlast workspacerules movecurrentworkspacetomonitor movetoworkspacesilent hyprpaper alpha inactivebordercolor movegroupwindow movecursortocorner movewindowpixel prev movewindow globalshortcuts clients dimaround setignoregrouplock splash execr monitors 0 forcenoborder -q animations 1 nomaxsize splitratio moveactive pass swapnext devices layers rounding lockactivegroup 5 moveworkspacetomonitor -f -i --quiet forcenodim pin 0 1 forceopaque forcenoshadow setfloating minsize alphaoverride sendshortcut workspaces cyclenext alterzorder togglegroup lockgroups bordersize dpms focuscurrentorlast -1 --batch notify remove instances 1 3 moveoutofgroup killactive 2 movetoworkspace movecursor configerrors closewindow swapwindow tagwindow forcerendererreload centerwindow auto focuswindow seterror nofocus alphafullscreen binds version -h togglespecialworkspace fullscreen windowdancecompat 0 keyword toggleopaque 3 --instance togglefloating renameworkspace alphafullscreenoverride activeworkspace x11 kill forceopaqueoverriden output global dispatch reload forcenoblur -j event --help disable -1 activewindow keepaspectratio dismissnotify focusmonitor movefocus plugin exit workspace fullscreenstate getoption alphainactiveoverride alphainactive decorations settiled config-only descriptions resizewindowpixel fakefullscreen rollinglog swapactiveworkspaces submap next movewindoworgroup cursorpos forcenoanims focusworkspaceoncurrentmonitor maxsize sendkeystate)
     declare -A literal_transitions
     literal_transitions[0]="([120]=14 [43]=2 [125]=21 [81]=2 [3]=21 [51]=2 [50]=2 [128]=2 [89]=2 [58]=21 [8]=2 [10]=2 [11]=3 [130]=4 [13]=5 [97]=6 [101]=2 [102]=21 [133]=7 [100]=2 [137]=2 [22]=2 [19]=2 [140]=8 [25]=2 [143]=2 [107]=9 [146]=10 [69]=2 [33]=2 [34]=2 [78]=21 [114]=2 [37]=2 [151]=2 [116]=2 [121]=13 [123]=21 [39]=11 [42]=21 [79]=15 [118]=12)"
     literal_transitions[1]="([81]=2 [51]=2 [50]=2 [128]=2 [8]=2 [89]=2 [10]=2 [11]=3 [130]=4 [13]=5 [97]=6 [101]=2 [133]=7 [100]=2 [22]=2 [19]=2 [137]=2 [140]=8 [25]=2 [143]=2 [107]=9 [146]=10 [69]=2 [33]=2 [34]=2 [114]=2 [37]=2 [151]=2 [116]=2 [39]=11 [118]=12 [121]=13 [120]=14 [79]=15 [43]=2)"

hyprctl/hyprctl.fish

@@ -29,7 +29,7 @@ function _hyprctl
         set COMP_CWORD (count $COMP_WORDS)
     end
 
-    set literals "resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize"
+    set literals "resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize" "sendkeystate"
 
     set descriptions
     set descriptions[1] "Resize the active window"

hyprctl/hyprctl.usage

@@ -106,6 +106,7 @@ hyprctl [<OPTIONS>]... <ARGUMENTS>
                 |  (execr)           	                              "Execute a raw shell command"
                 |  (pass)            	                              "Pass the key to a specified window"
                 |  (sendshortcut)            	                      "On shortcut X sends shortcut Y to a specified window"
+                |  (sendkeystate)            	                      "Send a key with specific state (down/repeat/up) to a specified window (window must keep focus for events to continue)"
                 |  (killactive)          	                          "Close the active window"
                 |  (closewindow)         	                          "Close a specified window"
                 |  (workspace)           	                          "Change the workspace"

hyprctl/hyprctl.zsh

@@ -17,7 +17,7 @@ _hyprctl_cmd_0 () {
 }
 
 _hyprctl () {
-    local -a literals=("resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize")
+    local -a literals=("resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize" "sendkeystate")
 
     local -A descriptions
     descriptions[1]="Resize the active window"

hyprpm/CMakeLists.txt

@@ -9,11 +9,11 @@ file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 
 set(CMAKE_CXX_STANDARD 23)
 
-pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.2.4)
+pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.7.0)
 
 find_package(glaze QUIET)
 if (NOT glaze_FOUND)
-    set(GLAZE_VERSION v4.2.3)
+    set(GLAZE_VERSION v5.1.1)
     message(STATUS "glaze dependency not found, retrieving ${GLAZE_VERSION} with FetchContent")
     include(FetchContent)
     FetchContent_Declare(

hyprpm/src/core/DataState.cpp

@@ -1,22 +1,41 @@
 #include "DataState.hpp"
+#include <sys/stat.h>
 #include <toml++/toml.hpp>
 #include <print>
+#include <sstream>
 #include <fstream>
 #include "PluginManager.hpp"
+#include "../helpers/Die.hpp"
+#include "../helpers/Sys.hpp"
+#include "../helpers/StringUtils.hpp"
 
-std::filesystem::path DataState::getDataStatePath() {
-    const auto HOME = getenv("HOME");
-    if (!HOME) {
-        std::println(stderr, "DataState: no $HOME");
-        throw std::runtime_error("no $HOME");
-        return "";
+static std::string getTempRoot() {
+    static auto ENV = getenv("XDG_RUNTIME_DIR");
+    if (!ENV) {
+        std::cerr << "\nERROR: XDG_RUNTIME_DIR not set!\n";
+        exit(1);
     }
 
-    const auto XDG_DATA_HOME = getenv("XDG_DATA_HOME");
+    const auto STR = ENV + std::string{"/hyprpm/"};
 
-    if (XDG_DATA_HOME)
-        return std::filesystem::path{XDG_DATA_HOME} / "hyprpm";
-    return std::filesystem::path{HOME} / ".local/share/hyprpm";
+    return STR;
+}
+
+// write the state to a file
+static bool writeState(const std::string& str, const std::string& to) {
+    // create temp file in a safe temp root
+    std::ofstream of(getTempRoot() + ".temp-state", std::ios::trunc);
+    if (!of.good())
+        return false;
+
+    of << str;
+    of.close();
+
+    return NSys::root::install(getTempRoot() + ".temp-state", to, "644");
+}
+
+std::filesystem::path DataState::getDataStatePath() {
+    return std::filesystem::path("/var/cache/hyprpm/" + g_pPluginManager->m_szUsername);
 }
 
 std::string DataState::getHeadersPath() {
@@ -41,21 +60,32 @@ std::vector<std::filesystem::path> DataState::getPluginStates() {
 }
 
 void DataState::ensureStateStoreExists() {
-    const auto PATH = getDataStatePath();
-
-    if (!std::filesystem::exists(PATH))
-        std::filesystem::create_directories(PATH);
-
-    if (!std::filesystem::exists(getHeadersPath()))
-        std::filesystem::create_directories(getHeadersPath());
+    std::error_code ec;
+    if (!std::filesystem::exists(getHeadersPath(), ec) || ec) {
+        std::println("{}", infoString("The hyprpm state store doesn't exist. Creating now..."));
+        if (!std::filesystem::exists("/var/cache/hyprpm/", ec) || ec) {
+            if (!NSys::root::createDirectory("/var/cache/hyprpm", "755"))
+                Debug::die("ensureStateStoreExists: Failed to run a superuser cmd");
+        }
+        if (!std::filesystem::exists(getDataStatePath(), ec) || ec) {
+            if (!NSys::root::createDirectory(getDataStatePath().string(), "755"))
+                Debug::die("ensureStateStoreExists: Failed to run a superuser cmd");
+        }
+        if (!NSys::root::createDirectory(getHeadersPath(), "755"))
+            Debug::die("ensureStateStoreExists: Failed to run a superuser cmd");
+    }
 }
 
 void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath() / repo.name;
+    const auto      PATH = getDataStatePath() / repo.name;
 
-    std::filesystem::create_directories(PATH);
+    std::error_code ec;
+    if (!std::filesystem::exists(PATH, ec) || ec) {
+        if (!NSys::root::createDirectory(PATH.string(), "755"))
+            Debug::die("addNewPluginRepo: failed to create cache dir");
+    }
     // clang-format off
     auto DATA = toml::table{
         {"repository", toml::table{
@@ -68,9 +98,11 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     for (auto const& p : repo.plugins) {
         const auto filename = p.name + ".so";
 
-        // copy .so to the good place
-        if (std::filesystem::exists(p.filename))
-            std::filesystem::copy_file(p.filename, PATH / filename);
+        // copy .so to the good place and chmod 755
+        if (std::filesystem::exists(p.filename)) {
+            if (!NSys::root::install(p.filename, (PATH / filename).string(), "0755"))
+                Debug::die("addNewPluginRepo: failed to install so file");
+        }
 
         DATA.emplace(p.name, toml::table{
             {"filename", filename},
@@ -80,16 +112,16 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     }
     // clang-format on
 
-    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
-    ofs << DATA;
-    ofs.close();
+    std::stringstream ss;
+    ss << DATA;
+
+    if (!writeState(ss.str(), (PATH / "state.toml").string()))
+        Debug::die("{}", failureString("Failed to write plugin state"));
 }
 
 bool DataState::pluginRepoExists(const std::string& urlOrName) {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath();
-
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE = toml::parse_file(stateFile.c_str());
         const auto NAME  = STATE["repository"]["name"].value_or("");
@@ -105,8 +137,6 @@ bool DataState::pluginRepoExists(const std::string& urlOrName) {
 void DataState::removePluginRepo(const std::string& urlOrName) {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath();
-
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE = toml::parse_file(stateFile.c_str());
         const auto NAME  = STATE["repository"]["name"].value_or("");
@@ -122,7 +152,14 @@ void DataState::removePluginRepo(const std::string& urlOrName) {
                 g_pPluginManager->loadUnloadPlugin(std::filesystem::absolute(file.path()), false);
             }
 
-            std::filesystem::remove_all(stateFile.parent_path());
+            const auto PATH = stateFile.parent_path().string();
+
+            if (!PATH.starts_with("/var/cache/hyprpm") || PATH.contains('\''))
+                return; // WTF?
+
+            // scary!
+            if (!NSys::root::removeRecursive(PATH))
+                Debug::die("removePluginRepo: failed to remove dir");
             return;
         }
     }
@@ -131,9 +168,13 @@ void DataState::removePluginRepo(const std::string& urlOrName) {
 void DataState::updateGlobalState(const SGlobalState& state) {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath();
+    const auto      PATH = getDataStatePath();
 
-    std::filesystem::create_directories(PATH);
+    std::error_code ec;
+    if (!std::filesystem::exists(PATH, ec) || ec) {
+        if (!NSys::root::createDirectory(PATH.string(), "755"))
+            Debug::die("updateGlobalState: failed to create dir");
+    }
     // clang-format off
     auto DATA = toml::table{
         {"state", toml::table{
@@ -143,17 +184,20 @@ void DataState::updateGlobalState(const SGlobalState& state) {
     };
     // clang-format on
 
-    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
-    ofs << DATA;
-    ofs.close();
+    std::stringstream ss;
+    ss << DATA;
+
+    if (!writeState(ss.str(), (PATH / "state.toml").string()))
+        Debug::die("{}", failureString("Failed to write plugin state"));
 }
 
 SGlobalState DataState::getGlobalState() {
     ensureStateStoreExists();
 
-    const auto stateFile = getDataStatePath() / "state.toml";
+    const auto      stateFile = getDataStatePath() / "state.toml";
 
-    if (!std::filesystem::exists(stateFile))
+    std::error_code ec;
+    if (!std::filesystem::exists(stateFile, ec) || ec)
         return SGlobalState{};
 
     auto         DATA = toml::parse_file(stateFile.c_str());
@@ -168,8 +212,6 @@ SGlobalState DataState::getGlobalState() {
 std::vector<SPluginRepository> DataState::getAllRepositories() {
     ensureStateStoreExists();
 
-    const auto                     PATH = getDataStatePath();
-
     std::vector<SPluginRepository> repos;
     for (const auto& stateFile : getPluginStates()) {
         const auto        STATE = toml::parse_file(stateFile.c_str());
@@ -205,8 +247,6 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
 bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath();
-
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE = toml::parse_file(stateFile.c_str());
         for (const auto& [key, val] : STATE) {
@@ -224,9 +264,11 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
             auto modifiedState = STATE;
             (*modifiedState[key].as_table()).insert_or_assign("enabled", enabled);
 
-            std::ofstream state(stateFile, std::ios::trunc);
-            state << modifiedState;
-            state.close();
+            std::stringstream ss;
+            ss << modifiedState;
+
+            if (!writeState(ss.str(), stateFile.string()))
+                Debug::die("{}", failureString("Failed to write plugin state"));
 
             return true;
         }
@@ -234,3 +276,18 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
 
     return false;
 }
+
+void DataState::purgeAllCache() {
+    std::error_code ec;
+    if (!std::filesystem::exists(getDataStatePath()) && !ec) {
+        std::println("{}", infoString("Nothing to do"));
+        return;
+    }
+
+    const auto PATH = getDataStatePath().string();
+    if (PATH.contains('\''))
+        return;
+    // scary!
+    if (!NSys::root::removeRecursive(PATH))
+        Debug::die("Failed to run a superuser cmd");
+}

hyprpm/src/core/DataState.hpp

@@ -18,6 +18,7 @@ namespace DataState {
     void                               removePluginRepo(const std::string& urlOrName);
     bool                               pluginRepoExists(const std::string& urlOrName);
     void                               updateGlobalState(const SGlobalState& state);
+    void                               purgeAllCache();
     SGlobalState                       getGlobalState();
     bool                               setPluginEnabled(const std::string& name, bool enabled);
     std::vector<SPluginRepository>     getAllRepositories();

hyprpm/src/core/HyprlandSocket.cpp

@@ -0,0 +1,85 @@
+#include "HyprlandSocket.hpp"
+#include <pwd.h>
+#include <sys/socket.h>
+#include "../helpers/StringUtils.hpp"
+#include <print>
+#include <sys/un.h>
+#include <unistd.h>
+
+static int getUID() {
+    const auto UID   = getuid();
+    const auto PWUID = getpwuid(UID);
+    return PWUID ? PWUID->pw_uid : UID;
+}
+
+static std::string getRuntimeDir() {
+    const auto XDG = getenv("XDG_RUNTIME_DIR");
+
+    if (!XDG) {
+        const std::string USERID = std::to_string(getUID());
+        return "/run/user/" + USERID + "/hypr";
+    }
+
+    return std::string{XDG} + "/hypr";
+}
+
+std::string NHyprlandSocket::send(const std::string& cmd) {
+    const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
+
+    if (SERVERSOCKET < 0) {
+        std::println("{}", failureString("Couldn't open a socket (1)"));
+        return "";
+    }
+
+    const auto HIS = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+    if (!HIS) {
+        std::println("{}", failureString("HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?) (3)"));
+        return "";
+    }
+
+    sockaddr_un serverAddress = {0};
+    serverAddress.sun_family  = AF_UNIX;
+
+    std::string socketPath = getRuntimeDir() + "/" + HIS + "/.socket.sock";
+
+    strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
+
+    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
+        std::println("{}", failureString("Couldn't connect to " + socketPath + ". (4)"));
+        return "";
+    }
+
+    auto sizeWritten = write(SERVERSOCKET, cmd.c_str(), cmd.length());
+
+    if (sizeWritten < 0) {
+        std::println("{}", failureString("Couldn't write (5)"));
+        return "";
+    }
+
+    std::string      reply               = "";
+    constexpr size_t BUFFER_SIZE         = 8192;
+    char             buffer[BUFFER_SIZE] = {0};
+
+    sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+
+    if (sizeWritten < 0) {
+        std::println("{}", failureString("Couldn't read (6)"));
+        return "";
+    }
+
+    reply += std::string(buffer, sizeWritten);
+
+    while (sizeWritten == BUFFER_SIZE) {
+        sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+        if (sizeWritten < 0) {
+            std::println("{}", failureString("Couldn't read (7)"));
+            return "";
+        }
+        reply += std::string(buffer, sizeWritten);
+    }
+
+    close(SERVERSOCKET);
+
+    return reply;
+}

hyprpm/src/core/HyprlandSocket.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <string>
+
+namespace NHyprlandSocket {
+    std::string send(const std::string& cmd);
+};

hyprpm/src/core/Manifest.cpp

@@ -1,6 +1,12 @@
 #include "Manifest.hpp"
 #include <toml++/toml.hpp>
-#include <iostream>
+#include <algorithm>
+
+// Alphanumerics and -_ allowed for plugin names. No magic names.
+// [A-Za-z0-9\-_]*
+static bool validManifestName(const std::string_view& n) {
+    return std::ranges::all_of(n, [](const char& c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '-' || c == '_' || c == '=' || (c >= '0' && c <= '9'); });
+}
 
 CManifest::CManifest(const eManifestType type, const std::string& path) {
     auto manifest = toml::parse_file(path);
@@ -11,11 +17,17 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
                 continue;
 
             CManifest::SManifestPlugin plugin;
+
+            if (!validManifestName(key.str())) {
+                m_good = false;
+                return;
+            }
+
             plugin.name = key;
-            m_vPlugins.push_back(plugin);
+            m_plugins.push_back(plugin);
         }
 
-        for (auto& plugin : m_vPlugins) {
+        for (auto& plugin : m_plugins) {
             plugin.description = manifest[plugin.name]["description"].value_or("?");
             plugin.version     = manifest[plugin.name]["version"].value_or("?");
             plugin.output      = manifest[plugin.name]["build"]["output"].value_or("?");
@@ -37,21 +49,21 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
             }
 
             if (plugin.output.empty() || plugin.buildSteps.empty()) {
-                m_bGood = false;
+                m_good = false;
                 return;
             }
         }
     } else if (type == MANIFEST_HYPRPM) {
-        m_sRepository.name = manifest["repository"]["name"].value_or("");
-        auto authors       = manifest["repository"]["authors"].as_array();
+        m_repository.name = manifest["repository"]["name"].value_or("");
+        auto authors      = manifest["repository"]["authors"].as_array();
         if (authors) {
             for (auto&& a : *authors) {
-                m_sRepository.authors.push_back(a.as_string()->value_or("?"));
+                m_repository.authors.push_back(a.as_string()->value_or("?"));
             }
         } else {
             auto author = manifest["repository"]["author"].value_or("");
             if (!std::string{author}.empty())
-                m_sRepository.authors.push_back(author);
+                m_repository.authors.push_back(author);
         }
 
         auto pins = manifest["repository"]["commit_pins"].as_array();
@@ -59,7 +71,7 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
             for (auto&& pin : *pins) {
                 auto pinArr = pin.as_array();
                 if (pinArr && pinArr->get(1))
-                    m_sRepository.commitPins.push_back(std::make_pair<>(pinArr->get(0)->as_string()->get(), pinArr->get(1)->as_string()->get()));
+                    m_repository.commitPins.push_back(std::make_pair<>(pinArr->get(0)->as_string()->get(), pinArr->get(1)->as_string()->get()));
             }
         }
 
@@ -68,11 +80,17 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
                 continue;
 
             CManifest::SManifestPlugin plugin;
+
+            if (!validManifestName(key.str())) {
+                m_good = false;
+                return;
+            }
+
             plugin.name = key;
-            m_vPlugins.push_back(plugin);
+            m_plugins.push_back(plugin);
         }
 
-        for (auto& plugin : m_vPlugins) {
+        for (auto& plugin : m_plugins) {
             plugin.description = manifest[plugin.name]["description"].value_or("?");
             plugin.output      = manifest[plugin.name]["output"].value_or("?");
             plugin.since       = manifest[plugin.name]["since_hyprland"].value_or(0);
@@ -94,12 +112,12 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
             }
 
             if (plugin.output.empty() || plugin.buildSteps.empty()) {
-                m_bGood = false;
+                m_good = false;
                 return;
             }
         }
     } else {
         // ???
-        m_bGood = false;
+        m_good = false;
     }
 }

hyprpm/src/core/Manifest.hpp

@@ -27,8 +27,8 @@ class CManifest {
         std::string                                      name;
         std::vector<std::string>                         authors;
         std::vector<std::pair<std::string, std::string>> commitPins;
-    } m_sRepository;
+    } m_repository;
 
-    std::vector<SManifestPlugin> m_vPlugins;
-    bool                         m_bGood = true;
+    std::vector<SManifestPlugin> m_plugins;
+    bool                         m_good = true;
 };

hyprpm/src/core/PluginManager.cpp

@@ -4,6 +4,9 @@
 #include "../progress/CProgressBar.hpp"
 #include "Manifest.hpp"
 #include "DataState.hpp"
+#include "HyprlandSocket.hpp"
+#include "../helpers/Sys.hpp"
+#include "../helpers/Die.hpp"
 
 #include <cstdio>
 #include <iostream>
@@ -49,6 +52,13 @@ static std::string getTempRoot() {
     return STR;
 }
 
+CPluginManager::CPluginManager() {
+    if (NSys::isSuperuser())
+        Debug::die("Don't run hyprpm as a superuser.");
+
+    m_szUsername = getpwuid(NSys::getUID())->pw_name;
+}
+
 SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
     static bool             onceRunning   = false;
     static bool             onceInstalled = false;
@@ -66,7 +76,7 @@ SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
     else
         onceInstalled = true;
 
-    const auto HLVERCALL = running ? execAndGet("hyprctl version") : execAndGet("Hyprland --version");
+    const auto HLVERCALL = running ? NHyprlandSocket::send("/version") : execAndGet("Hyprland --version");
     if (m_bVerbose)
         std::println("{}", verboseString("{} version returned: {}", running ? "running" : "installed", HLVERCALL));
 
@@ -129,7 +139,8 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     const auto HLVER = getHyprlandVersion();
 
     if (!hasDeps()) {
-        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
+        std::println(stderr, "\n{}",
+                     failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config, git, g++, gcc"));
         return false;
     }
 
@@ -225,14 +236,14 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         return false;
     }
 
-    if (!pManifest->m_bGood) {
+    if (!pManifest->m_good) {
         std::println(stderr, "\n{}", failureString("The provided plugin repository has a corrupted manifest"));
         return false;
     }
 
     progress.m_iSteps = 2;
-    progress.printMessageAbove(successString("parsed manifest, found " + std::to_string(pManifest->m_vPlugins.size()) + " plugins:"));
-    for (auto const& pl : pManifest->m_vPlugins) {
+    progress.printMessageAbove(successString("parsed manifest, found " + std::to_string(pManifest->m_plugins.size()) + " plugins:"));
+    for (auto const& pl : pManifest->m_plugins) {
         std::string message = "→ " + pl.name + " by ";
         for (auto const& a : pl.authors) {
             message += a + ", ";
@@ -245,12 +256,12 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         progress.printMessageAbove(message);
     }
 
-    if (!pManifest->m_sRepository.commitPins.empty()) {
+    if (!pManifest->m_repository.commitPins.empty()) {
         // check commit pins
 
-        progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_sRepository.commitPins.size()));
+        progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_repository.commitPins.size()));
 
-        for (auto const& [hl, plugin] : pManifest->m_sRepository.commitPins) {
+        for (auto const& [hl, plugin] : pManifest->m_repository.commitPins) {
             if (hl != HLVER.hash)
                 continue;
 
@@ -273,6 +284,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
     if (HEADERSSTATUS != HEADERS_OK) {
         std::println("\n{}", headerError(HEADERSSTATUS));
+        std::println("\n{}", infoString("if the problem persists, try running hyprpm purge-cache."));
         return false;
     }
 
@@ -281,7 +293,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     progress.m_szCurrentMessage = "Building plugin(s)";
     progress.print();
 
-    for (auto& p : pManifest->m_vPlugins) {
+    for (auto& p : pManifest->m_plugins) {
         std::string out;
 
         if (p.since > HLVER.commits && HLVER.commits >= 1 /* for --depth 1 clones, we can't check this. */) {
@@ -324,11 +336,11 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     std::string       repohash = execAndGet("cd " + m_szWorkingPluginDirectory + " && git rev-parse HEAD");
     if (repohash.length() > 0)
         repohash.pop_back();
-    repo.name = pManifest->m_sRepository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_sRepository.name;
+    repo.name = pManifest->m_repository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_repository.name;
     repo.url  = url;
     repo.rev  = rev;
     repo.hash = repohash;
-    for (auto const& p : pManifest->m_vPlugins) {
+    for (auto const& p : pManifest->m_plugins) {
         repo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, false, p.failed});
     }
     DataState::addNewPluginRepo(repo);
@@ -435,7 +447,7 @@ bool CPluginManager::updateHeaders(bool force) {
     const auto HLVER = getHyprlandVersion(false);
 
     if (!hasDeps()) {
-        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
+        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config, git, g++, gcc"));
         return false;
     }
 
@@ -548,13 +560,21 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.m_szCurrentMessage = "Installing sources";
     progress.print();
 
-    const std::string& cmd =
-        std::format("sed -i -e \"s#PREFIX = /usr/local#PREFIX = {}#\" {}/Makefile && cd {} && make installheaders", DataState::getHeadersPath(), WORKINGDIR, WORKINGDIR);
+    std::string cmd = std::format("sed -i -e \"s#PREFIX = /usr/local#PREFIX = {}#\" {}/Makefile", DataState::getHeadersPath(), WORKINGDIR);
     if (m_bVerbose)
-        progress.printMessageAbove(verboseString("installation will run: {}", cmd));
+        progress.printMessageAbove(verboseString("prepare install will run: {}", cmd));
 
     ret = execAndGet(cmd);
 
+    cmd = std::format("make -C '{}' installheaders && chmod -R 644 '{}' && find '{}' -type d -exec chmod o+x {{}} \\;", WORKINGDIR, DataState::getHeadersPath(),
+                      DataState::getHeadersPath());
+
+    if (m_bVerbose)
+        progress.printMessageAbove(verboseString("install will run as sudo: {}", cmd));
+
+    // WORKINGDIR and headersPath should not contain anything unsafe. Usernames can't contain cmd exec parts.
+    ret = NSys::root::runAsSuperuserUnsafe(cmd);
+
     if (m_bVerbose)
         std::println("{}", verboseString("installer returned: {}", ret));
 
@@ -568,9 +588,14 @@ bool CPluginManager::updateHeaders(bool force) {
         progress.m_szCurrentMessage = "Done!";
         progress.print();
 
+        auto GLOBALSTATE                = DataState::getGlobalState();
+        GLOBALSTATE.headersHashCompiled = HLVER.hash;
+        DataState::updateGlobalState(GLOBALSTATE);
+
         std::print("\n");
     } else {
         progress.printMessageAbove(failureString("failed to install headers with error code {} ({})", (int)HEADERSVALID, headerErrorShort(HEADERSVALID)));
+        progress.printMessageAbove(infoString("if the problem persists, try running hyprpm purge-cache."));
         progress.m_iSteps           = 5;
         progress.m_szCurrentMessage = "Failed";
         progress.print();
@@ -677,17 +702,17 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             continue;
         }
 
-        if (!pManifest->m_bGood) {
-            std::println(stderr, "\n{}", failureString("The provided plugin repository has a corrupted manifest"));
+        if (!pManifest->m_good) {
+            std::println(stderr, "\n{}", failureString("The provided plugin repository has a bad manifest"));
             continue;
         }
 
-        if (repo.rev.empty() && !pManifest->m_sRepository.commitPins.empty()) {
+        if (repo.rev.empty() && !pManifest->m_repository.commitPins.empty()) {
             // check commit pins unless a revision is specified
 
-            progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_sRepository.commitPins.size()));
+            progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_repository.commitPins.size()));
 
-            for (auto const& [hl, plugin] : pManifest->m_sRepository.commitPins) {
+            for (auto const& [hl, plugin] : pManifest->m_repository.commitPins) {
                 if (hl != HLVER.hash)
                     continue;
 
@@ -697,7 +722,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             }
         }
 
-        for (auto& p : pManifest->m_vPlugins) {
+        for (auto& p : pManifest->m_plugins) {
             std::string out;
 
             if (p.since > HLVER.commits && HLVER.commits >= 1000 /* for shallow clones, we can't check this. 1000 is an arbitrary number I chose. */) {
@@ -739,7 +764,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
         if (repohash.length() > 0)
             repohash.pop_back();
         newrepo.hash = repohash;
-        for (auto const& p : pManifest->m_vPlugins) {
+        for (auto const& p : pManifest->m_plugins) {
             const auto OLDPLUGINIT = std::find_if(repo.plugins.begin(), repo.plugins.end(), [&](const auto& other) { return other.name == p.name; });
             newrepo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, OLDPLUGINIT != repo.plugins.end() ? OLDPLUGINIT->enabled : false});
         }
@@ -796,9 +821,9 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload)
     }
     const auto HYPRPMPATH = DataState::getDataStatePath();
 
-    const auto json = glz::read_json<glz::json_t::array_t>(execAndGet("hyprctl plugins list -j"));
+    const auto json = glz::read_json<glz::json_t::array_t>(NHyprlandSocket::send("j/plugins list"));
     if (!json) {
-        std::println(stderr, "PluginManager: couldn't parse hyprctl output");
+        std::println(stderr, "PluginManager: couldn't parse plugin list output");
         return LOADSTATE_FAIL;
     }
 
@@ -882,14 +907,15 @@ bool CPluginManager::loadUnloadPlugin(const std::string& path, bool load) {
     auto HLVER = getHyprlandVersion(true);
 
     if (state.headersHashCompiled != HLVER.hash) {
-        std::println("{}", infoString("Running Hyprland version differs from plugin state, please restart Hyprland."));
+        if (load)
+            std::println("{}", infoString("Running Hyprland version ({}) differs from plugin state ({}), please restart Hyprland.", HLVER.hash, state.headersHashCompiled));
         return false;
     }
 
     if (load)
-        execAndGet("hyprctl plugin load " + path);
+        NHyprlandSocket::send("/plugin load " + path);
     else
-        execAndGet("hyprctl plugin unload " + path);
+        NHyprlandSocket::send("/plugin unload " + path);
 
     return true;
 }
@@ -914,7 +940,7 @@ void CPluginManager::listAllPlugins() {
 }
 
 void CPluginManager::notify(const eNotifyIcons icon, uint32_t color, int durationMs, const std::string& message) {
-    execAndGet("hyprctl notify " + std::to_string((int)icon) + " " + std::to_string(durationMs) + " " + std::to_string(color) + " " + message);
+    NHyprlandSocket::send("/notify " + std::to_string((int)icon) + " " + std::to_string(durationMs) + " " + std::to_string(color) + " " + message);
 }
 
 std::string CPluginManager::headerError(const eHeadersErrors err) {
@@ -947,7 +973,7 @@ std::string CPluginManager::headerErrorShort(const eHeadersErrors err) {
 }
 
 bool CPluginManager::hasDeps() {
-    std::vector<std::string> deps = {"meson", "cpio", "cmake", "pkg-config"};
+    std::vector<std::string> deps = {"meson", "cpio", "cmake", "pkg-config", "g++", "gcc", "git"};
     for (auto const& d : deps) {
         if (!execAndGet("command -v " + d).contains("/"))
             return false;

hyprpm/src/core/PluginManager.hpp

@@ -40,6 +40,8 @@ struct SHyprlandVersion {
 
 class CPluginManager {
   public:
+    CPluginManager();
+
     bool                   addNewPluginRepo(const std::string& url, const std::string& rev);
     bool                   removePluginRepo(const std::string& urlOrName);
 
@@ -62,7 +64,7 @@ class CPluginManager {
 
     bool                   m_bVerbose   = false;
     bool                   m_bNoShallow = false;
-    std::string            m_szCustomHlUrl;
+    std::string            m_szCustomHlUrl, m_szUsername;
 
     // will delete recursively if exists!!
     bool createSafeDirectory(const std::string& path);

hyprpm/src/helpers/Die.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <format>
+#include <iostream>
+
+// NOLINTNEXTLINE
+namespace Debug {
+    template <typename... Args>
+    void die(std::format_string<Args...> fmt, Args&&... args) {
+        const std::string logMsg = std::vformat(fmt.get(), std::make_format_args(args...));
+
+        std::cout << "\n[ERR] " << logMsg << "\n";
+        exit(1);
+    }
+};

hyprpm/src/helpers/Sys.cpp

@@ -0,0 +1,167 @@
+#include "Sys.hpp"
+#include "Die.hpp"
+#include "StringUtils.hpp"
+
+#include <pwd.h>
+#include <unistd.h>
+#include <print>
+#include <filesystem>
+#include <algorithm>
+
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/string/VarList.hpp>
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::String;
+
+inline constexpr std::array<std::string_view, 3> SUPERUSER_BINARIES = {
+    "sudo",
+    "doas",
+    "run0",
+};
+
+static std::string validSubinsAsStr() {
+    std::ostringstream oss;
+    auto               it = SUPERUSER_BINARIES.begin();
+    if (it != SUPERUSER_BINARIES.end()) {
+        oss << *it++;
+        for (; it != SUPERUSER_BINARIES.end(); ++it)
+            oss << ", " << *it;
+    }
+
+    return oss.str();
+}
+
+static bool executableExistsInPath(const std::string& exe) {
+    const char* PATHENV = std::getenv("PATH");
+    if (!PATHENV)
+        return false;
+
+    CVarList        paths(PATHENV, 0, ':', true);
+    std::error_code ec;
+
+    for (const auto& PATH : paths) {
+        std::filesystem::path candidate = std::filesystem::path(PATH) / exe;
+        if (!std::filesystem::exists(candidate, ec) || ec)
+            continue;
+        if (!std::filesystem::is_regular_file(candidate, ec) || ec)
+            continue;
+        auto perms = std::filesystem::status(candidate, ec).permissions();
+        if (ec)
+            continue;
+        if ((perms & std::filesystem::perms::others_exec) != std::filesystem::perms::none)
+            return true;
+    }
+
+    return false;
+}
+
+static std::string subin() {
+    static std::string bin;
+    static bool        once = true;
+    if (!once)
+        return bin;
+
+    for (const auto& BIN : SUPERUSER_BINARIES) {
+        if (!executableExistsInPath(std::string{BIN}))
+            continue;
+
+        bin = BIN;
+        break;
+    }
+
+    once = false;
+
+    if (bin.empty())
+        Debug::die("{}", failureString("No valid superuser binary present. Supported: {}", validSubinsAsStr()));
+
+    return bin;
+}
+
+static bool verifyStringValid(const std::string& s) {
+    return std::ranges::none_of(s, [](const char& c) { return c == '`' || c == '$' || c == '(' || c == ')' || c == '\'' || c == '"'; });
+}
+
+int NSys::getUID() {
+    const auto UID   = getuid();
+    const auto PWUID = getpwuid(UID);
+    return PWUID ? PWUID->pw_uid : UID;
+}
+
+int NSys::getEUID() {
+    const auto UID   = geteuid();
+    const auto PWUID = getpwuid(UID);
+    return PWUID ? PWUID->pw_uid : UID;
+}
+
+bool NSys::isSuperuser() {
+    return getuid() != geteuid() || geteuid() == 0;
+}
+
+void NSys::root::cacheSudo() {
+    // "caches" the sudo so that the prompt later doesn't pop up in a weird spot
+    // sudo will not ask us again for a moment
+    CProcess proc(subin(), {"echo", "hyprland"});
+    proc.runSync();
+}
+
+void NSys::root::dropSudo() {
+    if (subin() != "sudo") {
+        std::println("{}", infoString("Don't know how to drop timestamp for '{}', ignoring.", subin()));
+        return;
+    }
+
+    CProcess proc(subin(), {"-k"});
+    proc.runSync();
+}
+
+bool NSys::root::createDirectory(const std::string& path, const std::string& mode) {
+    if (!verifyStringValid(path))
+        return false;
+
+    if (!std::ranges::all_of(mode, [](const char& c) { return c >= '0' && c <= '9'; }))
+        return false;
+
+    CProcess proc(subin(), {"mkdir", "-p", "-m", mode, path});
+
+    return proc.runSync() && proc.exitCode() == 0;
+}
+
+bool NSys::root::removeRecursive(const std::string& path) {
+    if (!verifyStringValid(path))
+        return false;
+
+    std::error_code   ec;
+    const std::string PATH_ABSOLUTE = std::filesystem::canonical(path, ec);
+
+    if (ec)
+        return false;
+
+    if (!PATH_ABSOLUTE.starts_with("/var/cache/hyprpm"))
+        return false;
+
+    CProcess proc(subin(), {"rm", "-fr", PATH_ABSOLUTE});
+
+    return proc.runSync() && proc.exitCode() == 0;
+}
+
+bool NSys::root::install(const std::string& what, const std::string& where, const std::string& mode) {
+    if (!verifyStringValid(what) || !verifyStringValid(where))
+        return false;
+
+    if (!std::ranges::all_of(mode, [](const char& c) { return c >= '0' && c <= '9'; }))
+        return false;
+
+    CProcess proc(subin(), {"install", "-m" + mode, "-o", "root", "-g", "root", what, where});
+
+    return proc.runSync() && proc.exitCode() == 0;
+}
+
+std::string NSys::root::runAsSuperuserUnsafe(const std::string& cmd) {
+    CProcess proc(subin(), {"/bin/sh", "-c", cmd});
+
+    if (!proc.runSync())
+        return "";
+
+    return proc.stdOut();
+}

hyprpm/src/helpers/Sys.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+
+namespace NSys {
+    bool isSuperuser();
+    int  getUID();
+    int  getEUID();
+
+    // NOLINTNEXTLINE
+    namespace root {
+        void cacheSudo();
+        void dropSudo();
+
+        //
+        [[nodiscard("Discarding could lead to vulnerabilities and bugs")]] bool createDirectory(const std::string& path, const std::string& mode);
+        [[nodiscard("Discarding could lead to vulnerabilities and bugs")]] bool removeRecursive(const std::string& path);
+        [[nodiscard("Discarding could lead to vulnerabilities and bugs")]] bool install(const std::string& what, const std::string& where, const std::string& mode);
+
+        // Do not use this unless absolutely necessary!
+        std::string runAsSuperuserUnsafe(const std::string& cmd);
+    };
+};

hyprpm/src/main.cpp

@@ -2,34 +2,36 @@
 #include "helpers/StringUtils.hpp"
 #include "core/PluginManager.hpp"
 #include "core/DataState.hpp"
+#include "helpers/Sys.hpp"
 
-#include <cstdio>
 #include <vector>
 #include <string>
 #include <print>
-#include <chrono>
-#include <thread>
+
+#include <hyprutils/utils/ScopeGuard.hpp>
+using namespace Hyprutils::Utils;
 
 constexpr std::string_view HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
-┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision
+┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision.
 ┃                          is optional, when set, commit locks are ignored.
-┣ remove [url/name]      → Remove an installed plugin repository
-┣ enable [name]          → Enable a plugin
-┣ disable [name]         → Disable a plugin
-┣ update                 → Check and update all plugins if needed
+┣ remove [url/name]      → Remove an installed plugin repository.
+┣ enable [name]          → Enable a plugin.
+┣ disable [name]         → Disable a plugin.
+┣ update                 → Check and update all plugins if needed.
 ┣ reload                 → Reload hyprpm state. Ensure all enabled plugins are loaded.
-┣ list                   → List all installed plugins
+┣ list                   → List all installed plugins.
+┣ purge-cache            → Remove the entire hyprpm cache, built plugins, hyprpm settings and headers.
 ┃
 ┣ Flags:
 ┃
-┣ --notify       | -n    → Send a hyprland notification for important events (including both successes and fail events)
-┣ --notify-fail  | -nn   → Send a hyprland notification for fail events only
-┣ --help         | -h    → Show this menu
-┣ --verbose      | -v    → Enable too much logging
-┣ --force        | -f    → Force an operation ignoring checks (e.g. update -f)
-┣ --no-shallow   | -s    → Disable shallow cloning of Hyprland sources
-┣ --hl-url       |       → Pass a custom hyprland source url
+┣ --notify       | -n    → Send a hyprland notification for important events (including both successes and fail events).
+┣ --notify-fail  | -nn   → Send a hyprland notification for fail events only.
+┣ --help         | -h    → Show this menu.
+┣ --verbose      | -v    → Enable too much logging.
+┣ --force        | -f    → Force an operation ignoring checks (e.g. update -f).
+┣ --no-shallow   | -s    → Disable shallow cloning of Hyprland sources.
+┣ --hl-url       |       → Pass a custom hyprland source url.
 ┗
 )#";
 
@@ -96,9 +98,11 @@ int                        main(int argc, char** argv, char** envp) {
         }
 
         std::string rev = "";
-        if (command.size() >= 3) {
+        if (command.size() >= 3)
             rev = command[2];
-        }
+
+        NSys::root::cacheSudo();
+        CScopeGuard x([] { NSys::root::dropSudo(); });
 
         return g_pPluginManager->addNewPluginRepo(command[1], rev) ? 0 : 1;
     } else if (command[0] == "remove") {
@@ -107,10 +111,17 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
+        NSys::root::cacheSudo();
+        CScopeGuard x([] { NSys::root::dropSudo(); });
+
         return g_pPluginManager->removePluginRepo(command[1]) ? 0 : 1;
     } else if (command[0] == "update") {
-        bool headersValid = g_pPluginManager->headersValid() == HEADERS_OK;
-        bool headers      = g_pPluginManager->updateHeaders(force);
+        NSys::root::cacheSudo();
+        CScopeGuard x([] { NSys::root::dropSudo(); });
+
+        bool        headersValid = g_pPluginManager->headersValid() == HEADERS_OK;
+        bool        headers      = g_pPluginManager->updateHeaders(force);
+
         if (headers) {
             const auto HLVER            = g_pPluginManager->getHyprlandVersion(false);
             auto       GLOBALSTATE      = DataState::getGlobalState();
@@ -141,7 +152,10 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        auto ret = g_pPluginManager->ensurePluginsLoadState();
+        NSys::root::cacheSudo();
+        CScopeGuard x([] { NSys::root::dropSudo(); });
+
+        auto        ret = g_pPluginManager->ensurePluginsLoadState();
 
         if (ret == LOADSTATE_HYPRLAND_UPDATED)
             g_pPluginManager->notify(ICON_INFO, 0, 10000, "[hyprpm] Enabled plugin, but Hyprland was updated. Please restart Hyprland.");
@@ -159,7 +173,11 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        auto ret = g_pPluginManager->ensurePluginsLoadState();
+        NSys::root::cacheSudo();
+        CScopeGuard x([] { NSys::root::dropSudo(); });
+
+        auto        ret = g_pPluginManager->ensurePluginsLoadState();
+
         if (ret != LOADSTATE_OK)
             return 1;
     } else if (command[0] == "reload") {
@@ -181,6 +199,10 @@ int                        main(int argc, char** argv, char** envp) {
         } else if (notify && !notifyFail) {
             g_pPluginManager->notify(ICON_OK, 0, 4000, "[hyprpm] Loaded plugins");
         }
+    } else if (command[0] == "purge-cache") {
+        NSys::root::cacheSudo();
+        CScopeGuard x([] { NSys::root::dropSudo(); });
+        DataState::purgeAllCache();
     } else if (command[0] == "list") {
         g_pPluginManager->listAllPlugins();
     } else {

hyprpm/src/progress/CProgressBar.cpp

@@ -1,82 +1,78 @@
 #include "CProgressBar.hpp"
 
 #include <sys/ioctl.h>
-#include <algorithm>
+#include <unistd.h>
 #include <cmath>
 #include <format>
-
 #include <print>
-#include <stdio.h>
-#include <unistd.h>
+#include <cstdio>
+
+#include <algorithm>
+#include <sstream>
 
 #include "../helpers/Colors.hpp"
 
-void CProgressBar::printMessageAbove(const std::string& msg) {
-    struct winsize w;
+static winsize getTerminalSize() {
+    winsize w{};
     ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
+    return w;
+}
 
-    std::string spaces;
-    spaces.reserve(w.ws_col);
-    for (size_t i = 0; i < w.ws_col; ++i) {
-        spaces += ' ';
-    }
+static void clearCurrentLine() {
+    std::print("\r\33[2K"); // ansi escape sequence to clear entire line
+}
 
-    std::println("\r{}\r{}", spaces, msg);
-    print();
+void CProgressBar::printMessageAbove(const std::string& msg) {
+    clearCurrentLine();
+    std::print("\r{}\n", msg);
+
+    print(); // reprint bar underneath
 }
 
 void CProgressBar::print() {
-    struct winsize w;
-    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
+    const auto w = getTerminalSize();
 
-    if (m_bFirstPrint)
+    if (m_bFirstPrint) {
         std::print("\n");
-    m_bFirstPrint = false;
-
-    std::string spaces;
-    spaces.reserve(w.ws_col);
-    for (size_t i = 0; i < w.ws_col; ++i) {
-        spaces += ' ';
+        m_bFirstPrint = false;
     }
 
-    std::print("\r{}\r", spaces);
+    clearCurrentLine();
 
-    std::string message = "";
-
-    float       percentDone = 0;
-    if (m_fPercentage >= 0)
+    float percentDone = 0.0f;
+    if (m_fPercentage >= 0.0f)
         percentDone = m_fPercentage;
-    else
-        percentDone = (float)m_iSteps / (float)m_iMaxSteps;
-
-    const auto BARWIDTH = std::clamp(w.ws_col - static_cast<unsigned long>(m_szCurrentMessage.length()) - 2, 0UL, 50UL);
-
-    // draw bar
-    message += std::string{" "} + Colors::GREEN;
-    size_t i = 0;
-    for (; i < std::floor(percentDone * BARWIDTH); ++i) {
-        message += "━";
+    else {
+        // check for divide-by-zero
+        percentDone = m_iMaxSteps > 0 ? static_cast<float>(m_iSteps) / m_iMaxSteps : 0.0f;
     }
+    // clamp to ensure no overflows (sanity check)
+    percentDone = std::clamp(percentDone, 0.0f, 1.0f);
+
+    const size_t       BARWIDTH = std::clamp<size_t>(w.ws_col - m_szCurrentMessage.length() - 2, 0, 50);
+
+    std::ostringstream oss;
+    oss << ' ' << Colors::GREEN;
+
+    size_t filled = static_cast<size_t>(std::floor(percentDone * BARWIDTH));
+    size_t i      = 0;
+
+    for (; i < filled; ++i)
+        oss << "━";
 
     if (i < BARWIDTH) {
-        i++;
-
-        message += std::string{"╍"} + Colors::RESET;
-
-        for (; i < BARWIDTH; ++i) {
-            message += "━";
-        }
+        oss << "╍" << Colors::RESET;
+        ++i;
+        for (; i < BARWIDTH; ++i)
+            oss << "━";
     } else
-        message += Colors::RESET;
+        oss << Colors::RESET;
 
-    // draw progress
-    if (m_fPercentage >= 0)
-        message += "  " + std::format("{}%", static_cast<int>(percentDone * 100.0)) + " ";
+    if (m_fPercentage >= 0.0f)
+        oss << "  " << std::format("{}%", static_cast<int>(percentDone * 100.0)) << ' ';
     else
-        message += "  " + std::format("{} / {}", m_iSteps, m_iMaxSteps) + " ";
-
-    // draw message
-    std::print("{} {}", message, m_szCurrentMessage);
+        oss << "  " << std::format("{} / {}", m_iSteps, m_iMaxSteps) << ' ';
 
+    std::print("{} {}", oss.str(), m_szCurrentMessage);
     std::fflush(stdout);
 }

meson.build

@@ -35,7 +35,7 @@ aquamarine = dependency('aquamarine', version: '>=0.8.0')
 hyprcursor = dependency('hyprcursor', version: '>=0.1.7')
 hyprgraphics = dependency('hyprgraphics', version: '>= 0.1.1')
 hyprlang = dependency('hyprlang', version: '>= 0.3.2')
-hyprutils = dependency('hyprutils', version: '>= 0.2.3')
+hyprutils = dependency('hyprutils', version: '>= 0.7.0')
 aquamarine_version_list = aquamarine.version().split('.')
 add_project_arguments(['-DAQUAMARINE_VERSION="@0@"'.format(aquamarine.version())], language: 'cpp')
 add_project_arguments(['-DAQUAMARINE_VERSION_MAJOR=@0@'.format(aquamarine_version_list.get(0))], language: 'cpp')
@@ -87,9 +87,11 @@ endif
 
 # Generate hyprland version and populate version.h
 run_command('sh', '-c', 'scripts/generateVersion.sh', check: true)
+# Make shader files includable
+run_command('sh', '-c', 'scripts/generateShaderIncludes.sh', check: true)
 
 # Install headers
-globber = run_command('find', 'src', '-name', '*.h*', '-o', '-name', '*.frag', check: true)
+globber = run_command('find', 'src', '-name', '*.h*', '-o', '-name', '*.inc', check: true)
 headers = globber.stdout().strip().split('\n')
 foreach file : headers
   install_headers(file, subdir: 'hyprland', preserve_path: true)

nix/default.nix

@@ -11,6 +11,7 @@
   aquamarine,
   binutils,
   cairo,
+  epoll-shim,
   git,
   glaze,
   hyprcursor,
@@ -141,6 +142,7 @@ in
           wayland-scanner
           xorg.libXcursor
         ]
+        (optionals customStdenv.hostPlatform.isBSD [ epoll-shim ])
         (optionals customStdenv.hostPlatform.isMusl [libexecinfo])
         (optionals enableXWayland [
           xorg.libxcb
@@ -153,6 +155,8 @@ in
         (optional withSystemd systemd)
       ];
 
+      strictDeps = true;
+
       mesonBuildType =
         if debug
         then "debug"
@@ -162,6 +166,7 @@ in
         (mapAttrsToList mesonEnable {
           "xwayland" = enableXWayland;
           "legacy_renderer" = legacyRenderer;
+          "systemd" = withSystemd;
           "uwsm" = false;
           "hyprpm" = false;
         })

nix/module.nix

@@ -126,13 +126,14 @@ in {
             bottomCommandsPrefixes = cfg.bottomPrefixes;
           }
           {
-            plugin = let
+            "exec-once" = let
               mkEntry = entry:
                 if lib.types.package.check entry
                 then "${entry}/lib/lib${entry.pname}.so"
                 else entry;
+              hyprctl = lib.getExe' config.programs.hyprland.package "hyprctl";
             in
-              map mkEntry cfg.plugins;
+              map (p: "${hyprctl} plugin load ${mkEntry p}") cfg.plugins;
           };
       in
         lib.mkIf shouldGenerate {

nix/overlays.nix

@@ -29,6 +29,7 @@ in {
     inputs.hyprutils.overlays.default
     inputs.hyprwayland-scanner.overlays.default
     self.overlays.udis86
+    self.overlays.wayland-protocols
 
     # Hyprland packages themselves
     (final: _prev: let
@@ -89,4 +90,16 @@ in {
       patches = [];
     });
   };
+
+  # TODO: remove when https://github.com/NixOS/nixpkgs/pull/397497 lands in master
+  wayland-protocols = final: prev: {
+    wayland-protocols = prev.wayland-protocols.overrideAttrs (self: super: {
+      version = "1.43";
+
+      src = final.fetchurl {
+        url = "https://gitlab.freedesktop.org/wayland/${self.pname}/-/releases/${self.version}/downloads/${self.pname}-${self.version}.tar.xz";
+        hash = "sha256-ujw0Jd0nxXtSkek9upe+EkeWAeALyrJNJkcZSMtkNlM=";
+      };
+    });
+  };
 }

protocols/meson.build

@@ -1,13 +1,13 @@
 wayland_protos = dependency(
 	'wayland-protocols',
-	version: '>=1.41',
+	version: '>=1.43',
 	fallback: 'wayland-protocols',
 	default_options: ['tests=false'],
 )
 
 hyprland_protos = dependency(
 	'hyprland-protocols',
-	version: '>=0.6.2',
+	version: '>=0.6.4',
 	fallback: 'hyprland-protocols',
 )
 
@@ -37,6 +37,7 @@ protocols = [
 	'frog-color-management-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-global-shortcuts-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-toplevel-export-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-toplevel-mapping-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-focus-grab-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-ctm-control-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-surface-v1.xml',
@@ -72,6 +73,8 @@ protocols = [
 	wayland_protocol_dir / 'staging/security-context/security-context-v1.xml',
 	wayland_protocol_dir / 'staging/content-type/content-type-v1.xml',
 	wayland_protocol_dir / 'staging/color-management/color-management-v1.xml',
+	wayland_protocol_dir / 'staging/xdg-toplevel-tag/xdg-toplevel-tag-v1.xml',
+	wayland_protocol_dir / 'staging/xdg-system-bell/xdg-system-bell-v1.xml',
 ]
 
 wl_protocols = []
@@ -87,7 +90,7 @@ foreach protocol : protocols
 endforeach
 
 # wayland.xml generation
-wayland_scanner = dependency('wayland-scanner')
+wayland_scanner = dependency('wayland-scanner', native: true)
 wayland_scanner_datadir = wayland_scanner.get_variable('pkgdatadir')
 
 wayland_xml = wayland_scanner_datadir / 'wayland.xml'

scripts/generateShaderIncludes.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+SHADERS_SRC="./src/render/shaders/glsl"
+
+echo "-- Generating shader includes"
+
+if [ ! -d ./src/render/shaders ]; then
+	mkdir ./src/render/shaders
+fi
+
+echo '#pragma once' > ./src/render/shaders/Shaders.hpp
+echo '#include <map>' >> ./src/render/shaders/Shaders.hpp
+echo 'static const std::map<std::string, std::string> SHADERS = {' >> ./src/render/shaders/Shaders.hpp
+
+for filename in `ls ${SHADERS_SRC}`; do
+	echo "--	${filename}"
+	
+	{ echo 'R"#('; cat ${SHADERS_SRC}/${filename}; echo ')#"'; } > ./src/render/shaders/${filename}.inc
+	echo "{\"${filename}\"," >> ./src/render/shaders/Shaders.hpp
+	echo "#include \"./${filename}.inc\"" >> ./src/render/shaders/Shaders.hpp
+	echo "}," >> ./src/render/shaders/Shaders.hpp
+done
+
+echo '};' >> ./src/render/shaders/Shaders.hpp

src/Compositor.hpp

@@ -25,53 +25,53 @@ class CCompositor {
     CCompositor(bool onlyConfig = false);
     ~CCompositor();
 
-    wl_display*                                m_sWLDisplay   = nullptr;
-    wl_event_loop*                             m_sWLEventLoop = nullptr;
-    int                                        m_iDRMFD       = -1;
-    bool                                       m_bInitialized = false;
-    SP<Aquamarine::CBackend>                   m_pAqBackend;
+    wl_display*                                  m_wlDisplay   = nullptr;
+    wl_event_loop*                               m_wlEventLoop = nullptr;
+    int                                          m_drmFD       = -1;
+    bool                                         m_initialized = false;
+    SP<Aquamarine::CBackend>                     m_aqBackend;
 
-    std::string                                m_szHyprTempDataRoot = "";
+    std::string                                  m_hyprTempDataRoot = "";
 
-    std::string                                m_szWLDisplaySocket   = "";
-    std::string                                m_szInstanceSignature = "";
-    std::string                                m_szInstancePath      = "";
-    std::string                                m_szCurrentSplash     = "error";
+    std::string                                  m_wlDisplaySocket   = "";
+    std::string                                  m_instanceSignature = "";
+    std::string                                  m_instancePath      = "";
+    std::string                                  m_currentSplash     = "error";
 
-    std::vector<PHLMONITOR>                    m_vMonitors;
-    std::vector<PHLMONITOR>                    m_vRealMonitors; // for all monitors, even those turned off
-    std::vector<PHLWINDOW>                     m_vWindows;
-    std::vector<PHLLS>                         m_vLayers;
-    std::vector<PHLWORKSPACE>                  m_vWorkspaces;
-    std::vector<PHLWINDOWREF>                  m_vWindowsFadingOut;
-    std::vector<PHLLSREF>                      m_vSurfacesFadingOut;
+    std::vector<PHLMONITOR>                      m_monitors;
+    std::vector<PHLMONITOR>                      m_realMonitors; // for all monitors, even those turned off
+    std::vector<PHLWINDOW>                       m_windows;
+    std::vector<PHLLS>                           m_layers;
+    std::vector<PHLWORKSPACE>                    m_workspaces;
+    std::vector<PHLWINDOWREF>                    m_windowsFadingOut;
+    std::vector<PHLLSREF>                        m_surfacesFadingOut;
 
-    std::unordered_map<std::string, MONITORID> m_mMonitorIDMap;
+    std::unordered_map<std::string, MONITORID>   m_monitorIDMap;
+    std::unordered_map<std::string, WORKSPACEID> m_seenMonitorWorkspaceMap; // map of seen monitor names to workspace IDs
 
-    void                                       initServer(std::string socketName, int socketFd);
-    void                                       startCompositor();
-    void                                       stopCompositor();
-    void                                       cleanup();
-    void                                       bumpNofile();
-    void                                       restoreNofile();
+    void                                         initServer(std::string socketName, int socketFd);
+    void                                         startCompositor();
+    void                                         stopCompositor();
+    void                                         cleanup();
+    void                                         bumpNofile();
+    void                                         restoreNofile();
 
-    WP<CWLSurfaceResource>                     m_pLastFocus;
-    PHLWINDOWREF                               m_pLastWindow;
-    PHLMONITORREF                              m_pLastMonitor;
+    WP<CWLSurfaceResource>                       m_lastFocus;
+    PHLWINDOWREF                                 m_lastWindow;
+    PHLMONITORREF                                m_lastMonitor;
 
-    std::vector<PHLWINDOWREF>                  m_vWindowFocusHistory; // first element is the most recently focused.
+    std::vector<PHLWINDOWREF>                    m_windowFocusHistory; // first element is the most recently focused
 
-    bool                                       m_bReadyToProcess = false;
-    bool                                       m_bSessionActive  = true;
-    bool                                       m_bDPMSStateON    = true;
-    bool                                       m_bUnsafeState    = false; // unsafe state is when there is no monitors.
-    bool                                       m_bNextIsUnsafe   = false;
-    PHLMONITORREF                              m_pUnsafeOutput; // fallback output for the unsafe state
-    bool                                       m_bIsShuttingDown         = false;
-    bool                                       m_bFinalRequests          = false;
-    bool                                       m_bDesktopEnvSet          = false;
-    bool                                       m_bWantsXwayland          = true;
-    bool                                       m_bOnlyConfigVerification = false;
+    bool                                         m_readyToProcess = false;
+    bool                                         m_sessionActive  = true;
+    bool                                         m_dpmsStateOn    = true;
+    bool                                         m_unsafeState    = false; // unsafe state is when there is no monitors
+    PHLMONITORREF                                m_unsafeOutput;           // fallback output for the unsafe state
+    bool                                         m_isShuttingDown         = false;
+    bool                                         m_finalRequests          = false;
+    bool                                         m_desktopEnvSet          = false;
+    bool                                         m_wantsXwayland          = true;
+    bool                                         m_onlyConfigVerification = false;
 
     // ------------------------------------------------- //
 
@@ -85,7 +85,7 @@ class CCompositor {
     void                   focusSurface(SP<CWLSurfaceResource>, PHLWINDOW pWindowOwner = nullptr);
     bool                   monitorExists(PHLMONITOR);
     PHLWINDOW              vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
-    SP<CWLSurfaceResource> vectorToLayerSurface(const Vector2D&, std::vector<PHLLSREF>*, Vector2D*, PHLLS*);
+    SP<CWLSurfaceResource> vectorToLayerSurface(const Vector2D&, std::vector<PHLLSREF>*, Vector2D*, PHLLS*, bool aboveLockscreen = false);
     SP<CWLSurfaceResource> vectorToLayerPopupSurface(const Vector2D&, PHLMONITOR monitor, Vector2D*, PHLLS*);
     SP<CWLSurfaceResource> vectorWindowToSurface(const Vector2D&, PHLWINDOW, Vector2D& sl);
     Vector2D               vectorToSurfaceLocal(const Vector2D&, PHLWINDOW, SP<CWLSurfaceResource>);
@@ -152,7 +152,7 @@ class CCompositor {
     NColorManagement::SImageDescription getPreferredImageDescription();
     bool                                shouldChangePreferredImageDescription();
 
-    std::string                         explicitConfigPath;
+    std::string                         m_explicitConfigPath;
 
   private:
     void             initAllSignals();
@@ -165,9 +165,9 @@ class CCompositor {
     void             removeLockFile();
     void             setMallocThreshold();
 
-    uint64_t         m_iHyprlandPID    = 0;
-    wl_event_source* m_critSigSource   = nullptr;
-    rlimit           m_sOriginalNofile = {};
+    uint64_t         m_hyprlandPID    = 0;
+    wl_event_source* m_critSigSource  = nullptr;
+    rlimit           m_originalNofile = {};
 };
 
 inline UP<CCompositor> g_pCompositor;

src/config/ConfigDataValues.hpp

@@ -2,11 +2,13 @@
 #include "../defines.hpp"
 #include "../helpers/varlist/VarList.hpp"
 #include <vector>
+#include <map>
 
 enum eConfigValueDataTypes : int8_t {
-    CVD_TYPE_INVALID   = -1,
-    CVD_TYPE_GRADIENT  = 0,
-    CVD_TYPE_CSS_VALUE = 1
+    CVD_TYPE_INVALID     = -1,
+    CVD_TYPE_GRADIENT    = 0,
+    CVD_TYPE_CSS_VALUE   = 1,
+    CVD_TYPE_FONT_WEIGHT = 2,
 };
 
 class ICustomConfigValueData {
@@ -22,7 +24,7 @@ class CGradientValueData : public ICustomConfigValueData {
   public:
     CGradientValueData() = default;
     CGradientValueData(CHyprColor col) {
-        m_vColors.push_back(col);
+        m_colors.push_back(col);
         updateColorsOk();
     };
     virtual ~CGradientValueData() = default;
@@ -32,39 +34,39 @@ class CGradientValueData : public ICustomConfigValueData {
     }
 
     void reset(CHyprColor col) {
-        m_vColors.clear();
-        m_vColors.emplace_back(col);
-        m_fAngle = 0;
+        m_colors.clear();
+        m_colors.emplace_back(col);
+        m_angle = 0;
         updateColorsOk();
     }
 
     void updateColorsOk() {
-        m_vColorsOkLabA.clear();
-        for (auto& c : m_vColors) {
+        m_colorsOkLabA.clear();
+        for (auto& c : m_colors) {
             const auto OKLAB = c.asOkLab();
-            m_vColorsOkLabA.emplace_back(OKLAB.l);
-            m_vColorsOkLabA.emplace_back(OKLAB.a);
-            m_vColorsOkLabA.emplace_back(OKLAB.b);
-            m_vColorsOkLabA.emplace_back(c.a);
+            m_colorsOkLabA.emplace_back(OKLAB.l);
+            m_colorsOkLabA.emplace_back(OKLAB.a);
+            m_colorsOkLabA.emplace_back(OKLAB.b);
+            m_colorsOkLabA.emplace_back(c.a);
         }
     }
 
     /* Vector containing the colors */
-    std::vector<CHyprColor> m_vColors;
+    std::vector<CHyprColor> m_colors;
 
     /* Vector containing pure colors for shoving into opengl */
-    std::vector<float> m_vColorsOkLabA;
+    std::vector<float> m_colorsOkLabA;
 
     /* Float corresponding to the angle (rad) */
-    float m_fAngle = 0;
+    float m_angle = 0;
 
     //
     bool operator==(const CGradientValueData& other) const {
-        if (other.m_vColors.size() != m_vColors.size() || m_fAngle != other.m_fAngle)
+        if (other.m_colors.size() != m_colors.size() || m_angle != other.m_angle)
             return false;
 
-        for (size_t i = 0; i < m_vColors.size(); ++i)
-            if (m_vColors[i] != other.m_vColors[i])
+        for (size_t i = 0; i < m_colors.size(); ++i)
+            if (m_colors[i] != other.m_colors[i])
                 return false;
 
         return true;
@@ -72,28 +74,28 @@ class CGradientValueData : public ICustomConfigValueData {
 
     virtual std::string toString() {
         std::string result;
-        for (auto& c : m_vColors) {
+        for (auto& c : m_colors) {
             result += std::format("{:x} ", c.getAsHex());
         }
 
-        result += std::format("{}deg", (int)(m_fAngle * 180.0 / M_PI));
+        result += std::format("{}deg", (int)(m_angle * 180.0 / M_PI));
         return result;
     }
 };
 
 class CCssGapData : public ICustomConfigValueData {
   public:
-    CCssGapData() : top(0), right(0), bottom(0), left(0) {};
-    CCssGapData(int64_t global) : top(global), right(global), bottom(global), left(global) {};
-    CCssGapData(int64_t vertical, int64_t horizontal) : top(vertical), right(horizontal), bottom(vertical), left(horizontal) {};
-    CCssGapData(int64_t top, int64_t horizontal, int64_t bottom) : top(top), right(horizontal), bottom(bottom), left(horizontal) {};
-    CCssGapData(int64_t top, int64_t right, int64_t bottom, int64_t left) : top(top), right(right), bottom(bottom), left(left) {};
+    CCssGapData() : m_top(0), m_right(0), m_bottom(0), m_left(0) {};
+    CCssGapData(int64_t global) : m_top(global), m_right(global), m_bottom(global), m_left(global) {};
+    CCssGapData(int64_t vertical, int64_t horizontal) : m_top(vertical), m_right(horizontal), m_bottom(vertical), m_left(horizontal) {};
+    CCssGapData(int64_t top, int64_t horizontal, int64_t bottom) : m_top(top), m_right(horizontal), m_bottom(bottom), m_left(horizontal) {};
+    CCssGapData(int64_t top, int64_t right, int64_t bottom, int64_t left) : m_top(top), m_right(right), m_bottom(bottom), m_left(left) {};
 
     /* Css like directions */
-    int64_t top;
-    int64_t right;
-    int64_t bottom;
-    int64_t left;
+    int64_t m_top;
+    int64_t m_right;
+    int64_t m_bottom;
+    int64_t m_left;
 
     void    parseGapData(CVarList varlist) {
         switch (varlist.size()) {
@@ -122,10 +124,10 @@ class CCssGapData : public ICustomConfigValueData {
     }
 
     void reset(int64_t global) {
-        top    = global;
-        right  = global;
-        bottom = global;
-        left   = global;
+        m_top    = global;
+        m_right  = global;
+        m_bottom = global;
+        m_left   = global;
     }
 
     virtual eConfigValueDataTypes getDataType() {
@@ -133,6 +135,44 @@ class CCssGapData : public ICustomConfigValueData {
     }
 
     virtual std::string toString() {
-        return std::format("{} {} {} {}", top, right, bottom, left);
+        return std::format("{} {} {} {}", m_top, m_right, m_bottom, m_left);
+    }
+};
+
+class CFontWeightConfigValueData : public ICustomConfigValueData {
+  public:
+    CFontWeightConfigValueData() = default;
+    CFontWeightConfigValueData(const char* weight) {
+        parseWeight(weight);
+    }
+
+    int64_t                       m_value = 400; // default to normal weight
+
+    virtual eConfigValueDataTypes getDataType() {
+        return CVD_TYPE_FONT_WEIGHT;
+    }
+
+    virtual std::string toString() {
+        return std::format("{}", m_value);
+    }
+
+    void parseWeight(const std::string& strWeight) {
+        auto lcWeight{strWeight};
+        transform(strWeight.begin(), strWeight.end(), lcWeight.begin(), ::tolower);
+
+        // values taken from Pango weight enums
+        const auto WEIGHTS = std::map<std::string, int>{
+            {"thin", 100},   {"ultralight", 200}, {"light", 300}, {"semilight", 350}, {"book", 380},  {"normal", 400},
+            {"medium", 500}, {"semibold", 600},   {"bold", 700},  {"ultrabold", 800}, {"heavy", 900}, {"ultraheavy", 1000},
+        };
+
+        auto weight = WEIGHTS.find(lcWeight);
+        if (weight != WEIGHTS.end())
+            m_value = weight->second;
+        else {
+            int w_i = std::stoi(strWeight);
+            if (w_i < 100 || w_i > 1000)
+                m_value = 400;
+        }
     }
 };

src/config/ConfigDescriptions.hpp

@@ -247,6 +247,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_STRING_LONG,
         .data        = SConfigOptionDescription::SStringData{""}, //##TODO UNSET?
     },
+    SConfigOptionDescription{
+        .value       = "decoration:border_part_of_window",
+        .description = "whether the border should be treated as a part of the window.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
 
     /*
      * blur:
@@ -366,6 +372,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "animations:workspace_wraparound",
+        .description = "changes the direction of slide animations between the first and last workspaces",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
 
     /*
      * input:
@@ -891,6 +903,18 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_STRING_SHORT,
         .data        = SConfigOptionDescription::SStringData{STRVAL_EMPTY}, //##TODO UNSET?
     },
+    SConfigOptionDescription{
+        .value       = "group:groupbar:font_weight_active",
+        .description = "weight of the font used to display active groupbar titles",
+        .type        = CONFIG_OPTION_STRING_SHORT,
+        .data        = SConfigOptionDescription::SStringData{"normal"},
+    },
+    SConfigOptionDescription{
+        .value       = "group:groupbar:font_weight_inactive",
+        .description = "weight of the font used to display inactive groupbar titles",
+        .type        = CONFIG_OPTION_STRING_SHORT,
+        .data        = SConfigOptionDescription::SStringData{"normal"},
+    },
     SConfigOptionDescription{
         .value       = "group:groupbar:font_size",
         .description = "font size of groupbar title",
@@ -909,6 +933,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{14, 1, 64},
     },
+    SConfigOptionDescription{
+        .value       = "group:groupbar:indicator_gap",
+        .description = "height of the gap between the groupbar indicator and title",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{0, 0, 64},
+    },
     SConfigOptionDescription{
         .value       = "group:groupbar:indicator_height",
         .description = "height of the groupbar indicator",
@@ -1005,6 +1035,18 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{2, 0, 20},
     },
+    SConfigOptionDescription{
+        .value       = "group:groupbar:keep_upper_gap",
+        .description = "keep an upper gap above gradient",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
+    SConfigOptionDescription{
+        .value       = "group:groupbar:text_offset",
+        .description = "set an offset for a text",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SRangeData{0, -20, 20},
+    },
 
     /*
      * misc:
@@ -1217,6 +1259,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "misc:anr_missed_pings",
+        .description = "number of missed pings before showing the ANR dialog",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{1, 1, 10},
+    },
 
     /*
      * binds:
@@ -1240,6 +1288,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
+    SConfigOptionDescription{
+        .value       = "binds:hide_special_on_workspace_change",
+        .description = "If enabled, changing the active workspace (including to itself) will hide the special workspace on the monitor where the newly active workspace resides.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
     SConfigOptionDescription{
         .value       = "binds:allow_workspace_cycles",
         .description = "If enabled, workspaces don’t forget their previous workspace, so cycles can be created by switching to the first workspace in a sequence, then endlessly "
@@ -1296,6 +1350,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
+    SConfigOptionDescription{
+        .value       = "binds:drag_threshold",
+        .description = "Movement threshold in pixels for window dragging and c/g bind flags. 0 to disable and grab on mousedown.",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{0, 0, INT_MAX},
+    },
 
     /*
      * xwayland:
@@ -1390,6 +1450,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "render:send_content_type",
+        .description = "Report content type to allow monitor profile autoswitch (may result in a black screen during the switch)",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
 
     /*
      * cursor:
@@ -1444,6 +1510,13 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_CHOICE,
         .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Force"},
     },
+    SConfigOptionDescription{
+        .value       = "cursor:warp_on_toggle_special",
+        .description = "Move the cursor to the last focused window when toggling a special workspace. Options: 0 (Disabled), 1 (Enabled), "
+                       "2 (Force - ignores cursor:no_warps option)",
+        .type        = CONFIG_OPTION_CHOICE,
+        .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Force"},
+    },
     SConfigOptionDescription{
         .value       = "cursor:default_monitor",
         .description = "the name of a default monitor for the cursor to be set to on startup (see hyprctl monitors for names)",
@@ -1568,12 +1641,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
-    SConfigOptionDescription{
-        .value       = "debug:watchdog_timeout",
-        .description = "sets the timeout in seconds for watchdog to abort processing of a signal of the main thread. Set to 0 to disable.",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{5, 0, 20},
-    },
     SConfigOptionDescription{
         .value       = "debug:disable_scale_checks",
         .description = "disables verification of the scale factors. Will result in pixel alignment and rounding errors.",
@@ -1750,12 +1817,10 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{2, 0, 10}, //##TODO RANGE?
     },
-    SConfigOptionDescription{
-        .value       = "master:center_master_slaves_on_right",
-        .description = "set if the slaves should appear on right of master when slave_count_for_center_master > 2",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
+    SConfigOptionDescription{.value       = "master:center_master_fallback",
+                             .description = "Set fallback for center master when slaves are less than slave_count_for_center_master, can be left ,right ,top ,bottom",
+                             .type        = CONFIG_OPTION_STRING_SHORT,
+                             .data        = SConfigOptionDescription::SStringData{"left"}},
     SConfigOptionDescription{
         .value       = "master:center_ignores_reserved",
         .description = "centers the master window on monitor ignoring reserved areas",

src/config/ConfigManager.hpp

@@ -141,8 +141,18 @@ struct SFirstExecRequest {
 struct SFloatCache {
     size_t hash;
 
-    SFloatCache(PHLWINDOW window) {
-        hash = std::hash<std::string>{}(window->m_szClass) ^ (std::hash<std::string>{}(window->m_szTitle) << 1);
+    SFloatCache(PHLWINDOW window, bool initial) {
+        // Base hash from class/title
+        size_t baseHash = initial ? (std::hash<std::string>{}(window->m_initialClass) ^ (std::hash<std::string>{}(window->m_initialTitle) << 1)) :
+                                    (std::hash<std::string>{}(window->m_class) ^ (std::hash<std::string>{}(window->m_title) << 1));
+
+        // Use empty string as default tag value
+        std::string tagValue = "";
+        if (auto xdgTag = window->xdgTag())
+            tagValue = xdgTag.value();
+
+        // Combine hashes
+        hash = baseHash ^ (std::hash<std::string>{}(tagValue) << 2);
     }
 
     bool operator==(const SFloatCache& other) const {
@@ -244,48 +254,49 @@ class CConfigManager {
     std::optional<std::string> handleBindWS(const std::string&, const std::string&);
     std::optional<std::string> handleEnv(const std::string&, const std::string&);
     std::optional<std::string> handlePlugin(const std::string&, const std::string&);
+    std::optional<std::string> handlePermission(const std::string&, const std::string&);
 
-    std::string                configCurrentPath;
+    std::string                m_configCurrentPath;
 
-    bool                       m_bWantsMonitorReload                  = false;
-    bool                       m_bNoMonitorReload                     = false;
-    bool                       isLaunchingExecOnce                    = false; // For exec-once to skip initial ws tracking
-    bool                       m_bLastConfigVerificationWasSuccessful = true;
+    bool                       m_wantsMonitorReload                  = false;
+    bool                       m_noMonitorReload                     = false;
+    bool                       m_isLaunchingExecOnce                 = false; // For exec-once to skip initial ws tracking
+    bool                       m_lastConfigVerificationWasSuccessful = true;
 
     void                       storeFloatingSize(PHLWINDOW window, const Vector2D& size);
     std::optional<Vector2D>    getStoredFloatingSize(PHLWINDOW window);
 
   private:
-    UP<Hyprlang::CConfig>                            m_pConfig;
+    UP<Hyprlang::CConfig>                            m_config;
 
     std::vector<std::string>                         m_configPaths;
 
-    Hyprutils::Animation::CAnimationConfigTree       m_AnimationTree;
+    Hyprutils::Animation::CAnimationConfigTree       m_animationTree;
 
-    std::string                                      m_szCurrentSubmap = ""; // For storing the current keybind submap
+    std::string                                      m_currentSubmap = ""; // For storing the current keybind submap
 
-    std::vector<SExecRequestedRule>                  execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
+    std::vector<SExecRequestedRule>                  m_execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
 
-    std::vector<std::string>                         m_vDeclaredPlugins;
-    std::vector<SPluginKeyword>                      pluginKeywords;
-    std::vector<SPluginVariable>                     pluginVariables;
+    std::vector<std::string>                         m_declaredPlugins;
+    std::vector<SPluginKeyword>                      m_pluginKeywords;
+    std::vector<SPluginVariable>                     m_pluginVariables;
 
-    bool                                             isFirstLaunch = true; // For exec-once
+    bool                                             m_isFirstLaunch = true; // For exec-once
 
-    std::vector<SMonitorRule>                        m_vMonitorRules;
-    std::vector<SWorkspaceRule>                      m_vWorkspaceRules;
-    std::vector<SP<CWindowRule>>                     m_vWindowRules;
-    std::vector<SP<CLayerRule>>                      m_vLayerRules;
-    std::vector<std::string>                         m_dBlurLSNamespaces;
+    std::vector<SMonitorRule>                        m_monitorRules;
+    std::vector<SWorkspaceRule>                      m_workspaceRules;
+    std::vector<SP<CWindowRule>>                     m_windowRules;
+    std::vector<SP<CLayerRule>>                      m_layerRules;
+    std::vector<std::string>                         m_blurLSNamespaces;
 
-    bool                                             firstExecDispatched     = false;
-    bool                                             m_bManualCrashInitiated = false;
+    bool                                             m_firstExecDispatched  = false;
+    bool                                             m_manualCrashInitiated = false;
 
-    std::vector<SFirstExecRequest>                   firstExecRequests; // bool is for if with rules
-    std::vector<std::string>                         finalExecRequests;
+    std::vector<SFirstExecRequest>                   m_firstExecRequests; // bool is for if with rules
+    std::vector<std::string>                         m_finalExecRequests;
 
-    std::vector<std::pair<std::string, std::string>> m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
-    std::string                                      m_szConfigErrors = "";
+    std::vector<std::pair<std::string, std::string>> m_failedPluginConfigValues; // for plugin values of unloaded plugins
+    std::string                                      m_configErrors = "";
 
     uint32_t                                         m_configValueNumber = 0;
 

src/config/ConfigValue.cpp

@@ -0,0 +1,15 @@
+#include "ConfigValue.hpp"
+#include "ConfigManager.hpp"
+#include "../macros.hpp"
+
+void local__configValuePopulate(void* const** p, const std::string& val) {
+    const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
+
+    *p = PVHYPRLANG->getDataStaticPtr();
+}
+
+std::type_index local__configValueTypeIdx(const std::string& val) {
+    const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
+    const auto ANY        = PVHYPRLANG->getValue();
+    return std::type_index(ANY.type());
+}

src/config/ConfigValue.hpp

@@ -4,21 +4,19 @@
 #include <typeindex>
 #include <hyprlang.hpp>
 #include "../macros.hpp"
-#include "ConfigManager.hpp"
+
+// giga hack to avoid including configManager here
+// NOLINTNEXTLINE
+void            local__configValuePopulate(void* const** p, const std::string& val);
+std::type_index local__configValueTypeIdx(const std::string& val);
 
 template <typename T>
 class CConfigValue {
   public:
     CConfigValue(const std::string& val) {
-        const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
-
-        // NOLINTNEXTLINE
-        p_ = PVHYPRLANG->getDataStaticPtr();
-
 #ifdef HYPRLAND_DEBUG
         // verify type
-        const auto ANY  = PVHYPRLANG->getValue();
-        const auto TYPE = std::type_index(ANY.type());
+        const auto TYPE = local__configValueTypeIdx(val);
 
         // exceptions
         const bool STRINGEX = (typeid(T) == typeid(std::string) && TYPE == typeid(Hyprlang::STRING));
@@ -26,6 +24,8 @@ class CConfigValue {
 
         RASSERT(typeid(T) == TYPE || STRINGEX || CUSTOMEX, "Mismatched type in CConfigValue<T>, got {} but has {}", typeid(T).name(), TYPE.name());
 #endif
+
+        local__configValuePopulate(&p_, val);
     }
 
     T* ptr() const {

src/config/defaultConfig.hpp

@@ -65,6 +65,23 @@ env = XCURSOR_SIZE,24
 env = HYPRCURSOR_SIZE,24
 
 
+###################
+### PERMISSIONS ###
+###################
+
+# See https://wiki.hyprland.org/Configuring/Permissions/
+# Please note permission changes here require a Hyprland restart and are not applied on-the-fly
+# for security reasons
+
+# ecosystem {
+#   enforce_permissions = 1
+# }
+
+# permission = /usr/(bin|local/bin)/grim, screencopy, allow
+# permission = /usr/(lib|libexec|lib64)/xdg-desktop-portal-hyprland, screencopy, allow
+# permission = /usr/(bin|local/bin)/hyprpm, plugin, allow
+
+
 #####################
 ### LOOK AND FEEL ###
 #####################
@@ -273,8 +290,8 @@ bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume -l 1 @DEFAULT_AUDIO_SINK@
 bindel = ,XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-
 bindel = ,XF86AudioMute, exec, wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle
 bindel = ,XF86AudioMicMute, exec, wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle
-bindel = ,XF86MonBrightnessUp, exec, brightnessctl s 10%+
-bindel = ,XF86MonBrightnessDown, exec, brightnessctl s 10%-
+bindel = ,XF86MonBrightnessUp, exec, brightnessctl -e4 -n2 set 5%+
+bindel = ,XF86MonBrightnessDown, exec, brightnessctl -e4 -n2 set 5%-
 
 # Requires playerctl
 bindl = , XF86AudioNext, exec, playerctl next

src/debug/CrashReporter.cpp

@@ -130,11 +130,11 @@ void NCrashReporter::createAndSaveCrash(int sig) {
         for (size_t i = 0; i < count; i++) {
             auto p = plugins[i];
             finalCrashReport += '\t';
-            finalCrashReport += p->name;
+            finalCrashReport += p->m_name;
             finalCrashReport += " (";
-            finalCrashReport += p->author;
+            finalCrashReport += p->m_author;
             finalCrashReport += ") ";
-            finalCrashReport += p->version;
+            finalCrashReport += p->m_version;
             finalCrashReport += '\n';
         }
 
@@ -192,7 +192,7 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 #endif
     };
     u_int  miblen        = sizeof(mib) / sizeof(mib[0]);
-    char   exe[PATH_MAX] = "";
+    char   exe[PATH_MAX] = "/nonexistent";
     size_t sz            = sizeof(exe);
     sysctl(mib, miblen, &exe, &sz, NULL, 0);
     const auto FPATH = std::filesystem::canonical(exe);
@@ -242,5 +242,5 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "\n\nLog tail:\n";
 
-    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find('\n') + 1);
+    finalCrashReport += std::string_view(Debug::m_rollingLog).substr(Debug::m_rollingLog.find('\n') + 1);
 }

src/debug/HyprCtl.cpp

@@ -17,6 +17,7 @@
 #include <sys/poll.h>
 #include <filesystem>
 #include <ranges>
+#include <sys/eventfd.h>
 
 #include <sstream>
 #include <string>
@@ -24,6 +25,7 @@
 #include <numeric>
 
 #include <hyprutils/string/String.hpp>
+#include <hyprutils/os/FileDescriptor.hpp>
 using namespace Hyprutils::String;
 using namespace Hyprutils::OS;
 #include <aquamarine/input/Input.hpp>
@@ -51,6 +53,29 @@ using namespace Hyprutils::OS;
 #include "../managers/AnimationManager.hpp"
 #include "../debug/HyprNotificationOverlay.hpp"
 #include "../render/Renderer.hpp"
+#include "../render/OpenGL.hpp"
+
+#if defined(__DragonFly__) || defined(__FreeBSD__)
+#include <sys/ucred.h>
+#define CRED_T   xucred
+#define CRED_LVL SOL_LOCAL
+#define CRED_OPT LOCAL_PEERCRED
+#define CRED_PID cr_pid
+#elif defined(__NetBSD__)
+#define CRED_T   unpcbid
+#define CRED_LVL SOL_LOCAL
+#define CRED_OPT LOCAL_PEEREID
+#define CRED_PID unp_pid
+#else
+#if defined(__OpenBSD__)
+#define CRED_T sockpeercred
+#else
+#define CRED_T ucred
+#endif
+#define CRED_LVL SOL_SOCKET
+#define CRED_OPT SO_PEERCRED
+#define CRED_PID pid
+#endif
 
 static void trimTrailingComma(std::string& str) {
     if (!str.empty() && str.back() == ',')
@@ -72,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
@@ -86,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) {
@@ -127,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_szName)), m->activeSpecialWorkspaceID(),
-            escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
-            (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_pLastMonitor ? "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_szName),
-                              m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x,
-                              (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform,
-                              (m == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(),
-                              m->tearingState.activelyTearing, (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;
@@ -167,7 +193,7 @@ static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string requ
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
 
-        for (auto const& m : allMonitors ? g_pCompositor->m_vRealMonitors : g_pCompositor->m_vMonitors) {
+        for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) {
             result += CHyprCtl::getMonitorData(m, format);
         }
 
@@ -175,8 +201,8 @@ static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string requ
 
         result += "]";
     } else {
-        for (auto const& m : allMonitors ? g_pCompositor->m_vRealMonitors : g_pCompositor->m_vMonitors) {
-            if (!m->output || m->ID == -1)
+        for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) {
+            if (!m->m_output || m->m_id == -1)
                 continue;
 
             result += CHyprCtl::getMonitorData(m, format);
@@ -198,7 +224,7 @@ static std::string getTagsData(PHLWINDOW w, eHyprCtlOutputFormat format) {
 
 static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     const bool isJson = format == eHyprCtlOutputFormat::FORMAT_JSON;
-    if (w->m_sGroupData.pNextWindow.expired())
+    if (w->m_groupData.pNextWindow.expired())
         return isJson ? "" : "0";
 
     std::ostringstream result;
@@ -210,7 +236,7 @@ static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
             result << std::format("\"0x{:x}\"", (uintptr_t)curr.get());
         else
             result << std::format("{:x}", (uintptr_t)curr.get());
-        curr = curr->m_sGroupData.pNextWindow.lock();
+        curr = curr->m_groupData.pNextWindow.lock();
         // We've wrapped around to the start, break out without trailing comma
         if (curr == head)
             break;
@@ -222,8 +248,8 @@ static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
 
 std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     auto getFocusHistoryID = [](PHLWINDOW wnd) -> int {
-        for (size_t i = 0; i < g_pCompositor->m_vWindowFocusHistory.size(); ++i) {
-            if (g_pCompositor->m_vWindowFocusHistory[i].lock() == wnd)
+        for (size_t i = 0; i < g_pCompositor->m_windowFocusHistory.size(); ++i) {
+            if (g_pCompositor->m_windowFocusHistory[i].lock() == wnd)
                 return i;
         }
         return -1;
@@ -257,27 +283,29 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     "tags": [{}],
     "swallowing": "0x{:x}",
     "focusHistoryID": {},
-    "inhibitingIdle": {}
+    "inhibitingIdle": {},
+    "xdgTag": "{}",
+    "xdgDescription": "{}"
 }},)#",
-            (uintptr_t)w.get(), (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y,
-            (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID,
-            escapeJSONStrings(!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), ((int)w->m_bIsFloating == 1 ? "true" : "false"), (w->m_bIsPseudotiled ? "true" : "false"),
-            (int64_t)w->monitorID(), escapeJSONStrings(w->m_szClass), escapeJSONStrings(w->m_szTitle), escapeJSONStrings(w->m_szInitialClass),
-            escapeJSONStrings(w->m_szInitialTitle), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"),
-            (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(),
-            getFocusHistoryID(w), (g_pInputManager->isWindowInhibiting(w, false) ? "true" : "false"));
+            (uintptr_t)w.get(), (w->m_isMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_realPosition->goal().x, (int)w->m_realPosition->goal().y,
+            (int)w->m_realSize->goal().x, (int)w->m_realSize->goal().y, w->m_workspace ? w->workspaceID() : WORKSPACE_INVALID,
+            escapeJSONStrings(!w->m_workspace ? "" : w->m_workspace->m_name), ((int)w->m_isFloating == 1 ? "true" : "false"), (w->m_isPseudotiled ? "true" : "false"),
+            (int64_t)w->monitorID(), escapeJSONStrings(w->m_class), escapeJSONStrings(w->m_title), escapeJSONStrings(w->m_initialClass), escapeJSONStrings(w->m_initialTitle),
+            w->getPID(), ((int)w->m_isX11 == 1 ? "true" : "false"), (w->m_pinned ? "true" : "false"), (uint8_t)w->m_fullscreenState.internal, (uint8_t)w->m_fullscreenState.client,
+            getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_swallowed.get(), getFocusHistoryID(w),
+            (g_pInputManager->isWindowInhibiting(w, false) ? "true" : "false"), escapeJSONStrings(w->xdgTag().value_or("")), escapeJSONStrings(w->xdgDescription().value_or("")));
     } else {
         return std::format(
             "Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tpseudo: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
             "{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
             "{}\n\txwayland: {}\n\tpinned: "
-            "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\tinhibitingIdle: {}\n\n",
-            (uintptr_t)w.get(), w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y,
-            (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID,
-            (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->monitorID(), w->m_szClass, w->m_szTitle,
-            w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (uint8_t)w->m_sFullscreenState.internal,
-            (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(), getFocusHistoryID(w),
-            (int)g_pInputManager->isWindowInhibiting(w, false));
+            "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\tinhibitingIdle: {}\n\txdgTag: "
+            "{}\n\txdgDescription: {}\n\n",
+            (uintptr_t)w.get(), w->m_title, (int)w->m_isMapped, (int)w->isHidden(), (int)w->m_realPosition->goal().x, (int)w->m_realPosition->goal().y,
+            (int)w->m_realSize->goal().x, (int)w->m_realSize->goal().y, w->m_workspace ? w->workspaceID() : WORKSPACE_INVALID, (!w->m_workspace ? "" : w->m_workspace->m_name),
+            (int)w->m_isFloating, (int)w->m_isPseudotiled, (int64_t)w->monitorID(), w->m_class, w->m_title, w->m_initialClass, w->m_initialTitle, w->getPID(), (int)w->m_isX11,
+            (int)w->m_pinned, (uint8_t)w->m_fullscreenState.internal, (uint8_t)w->m_fullscreenState.client, getGroupedData(w, format), getTagsData(w, format),
+            (uintptr_t)w->m_swallowed.get(), getFocusHistoryID(w), (int)g_pInputManager->isWindowInhibiting(w, false), w->xdgTag().value_or(""), w->xdgDescription().value_or(""));
     }
 }
 
@@ -286,8 +314,8 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
 
-        for (auto const& w : g_pCompositor->m_vWindows) {
-            if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
+        for (auto const& w : g_pCompositor->m_windows) {
+            if (!w->m_isMapped && !g_pHyprCtl->m_currentRequestParams.all)
                 continue;
 
             result += CHyprCtl::getWindowData(w, format);
@@ -297,8 +325,8 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "]";
     } else {
-        for (auto const& w : g_pCompositor->m_vWindows) {
-            if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
+        for (auto const& w : g_pCompositor->m_windows) {
+            if (!w->m_isMapped && !g_pHyprCtl->m_currentRequestParams.all)
                 continue;
 
             result += CHyprCtl::getWindowData(w, format);
@@ -309,7 +337,7 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque
 
 std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format) {
     const auto PLASTW   = w->getLastFocusedWindow();
-    const auto PMONITOR = w->m_pMonitor.lock();
+    const auto PMONITOR = w->m_monitor.lock();
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         return std::format(R"#({{
     "id": {},
@@ -322,14 +350,14 @@ std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat form
     "lastwindowtitle": "{}",
     "ispersistent": {}
 }})#",
-                           w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"),
-                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_bHasFullscreenWindow ? "true" : "false",
-                           (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "", w->m_bPersistent ? "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_iID, w->m_szName, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_bHasFullscreenWindow,
-            (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "", (int)w->m_bPersistent);
+            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);
     }
 }
 
@@ -340,10 +368,10 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
         const std::string default_    = (bool)(r.isDefault) ? std::format(",\n    \"default\": {}", boolToString(r.isDefault)) : "";
         const std::string persistent  = (bool)(r.isPersistent) ? std::format(",\n    \"persistent\": {}", boolToString(r.isPersistent)) : "";
         const std::string gapsIn      = (bool)(r.gapsIn) ?
-                 std::format(",\n    \"gapsIn\": [{}, {}, {}, {}]", r.gapsIn.value().top, r.gapsIn.value().right, r.gapsIn.value().bottom, r.gapsIn.value().left) :
+                 std::format(",\n    \"gapsIn\": [{}, {}, {}, {}]", r.gapsIn.value().m_top, r.gapsIn.value().m_right, r.gapsIn.value().m_bottom, r.gapsIn.value().m_left) :
                  "";
         const std::string gapsOut     = (bool)(r.gapsOut) ?
-                std::format(",\n    \"gapsOut\": [{}, {}, {}, {}]", r.gapsOut.value().top, r.gapsOut.value().right, r.gapsOut.value().bottom, r.gapsOut.value().left) :
+                std::format(",\n    \"gapsOut\": [{}, {}, {}, {}]", r.gapsOut.value().m_top, r.gapsOut.value().m_right, r.gapsOut.value().m_bottom, r.gapsOut.value().m_left) :
                 "";
         const std::string borderSize  = (bool)(r.borderSize) ? std::format(",\n    \"borderSize\": {}", r.borderSize.value()) : "";
         const std::string border      = (bool)(r.noBorder) ? std::format(",\n    \"border\": {}", boolToString(!r.noBorder.value())) : "";
@@ -360,15 +388,15 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
 
         return result;
     } else {
-        const std::string monitor     = std::format("\tmonitor: {}\n", r.monitor.empty() ? "<unset>" : escapeJSONStrings(r.monitor));
-        const std::string default_    = std::format("\tdefault: {}\n", (bool)(r.isDefault) ? boolToString(r.isDefault) : "<unset>");
-        const std::string persistent  = std::format("\tpersistent: {}\n", (bool)(r.isPersistent) ? boolToString(r.isPersistent) : "<unset>");
-        const std::string gapsIn      = (bool)(r.gapsIn) ? std::format("\tgapsIn: {} {} {} {}\n", std::to_string(r.gapsIn.value().top), std::to_string(r.gapsIn.value().right),
-                                                                       std::to_string(r.gapsIn.value().bottom), std::to_string(r.gapsIn.value().left)) :
-                                                           std::format("\tgapsIn: <unset>\n");
-        const std::string gapsOut     = (bool)(r.gapsOut) ? std::format("\tgapsOut: {} {} {} {}\n", std::to_string(r.gapsOut.value().top), std::to_string(r.gapsOut.value().right),
-                                                                        std::to_string(r.gapsOut.value().bottom), std::to_string(r.gapsOut.value().left)) :
-                                                            std::format("\tgapsOut: <unset>\n");
+        const std::string monitor    = std::format("\tmonitor: {}\n", r.monitor.empty() ? "<unset>" : escapeJSONStrings(r.monitor));
+        const std::string default_   = std::format("\tdefault: {}\n", (bool)(r.isDefault) ? boolToString(r.isDefault) : "<unset>");
+        const std::string persistent = std::format("\tpersistent: {}\n", (bool)(r.isPersistent) ? boolToString(r.isPersistent) : "<unset>");
+        const std::string gapsIn     = (bool)(r.gapsIn) ? std::format("\tgapsIn: {} {} {} {}\n", std::to_string(r.gapsIn.value().m_top), std::to_string(r.gapsIn.value().m_right),
+                                                                      std::to_string(r.gapsIn.value().m_bottom), std::to_string(r.gapsIn.value().m_left)) :
+                                                          std::format("\tgapsIn: <unset>\n");
+        const std::string gapsOut = (bool)(r.gapsOut) ? std::format("\tgapsOut: {} {} {} {}\n", std::to_string(r.gapsOut.value().m_top), std::to_string(r.gapsOut.value().m_right),
+                                                                    std::to_string(r.gapsOut.value().m_bottom), std::to_string(r.gapsOut.value().m_left)) :
+                                                        std::format("\tgapsOut: <unset>\n");
         const std::string borderSize  = std::format("\tborderSize: {}\n", (bool)(r.borderSize) ? std::to_string(r.borderSize.value()) : "<unset>");
         const std::string border      = std::format("\tborder: {}\n", (bool)(r.noBorder) ? boolToString(!r.noBorder.value()) : "<unset>");
         const std::string rounding    = std::format("\trounding: {}\n", (bool)(r.noRounding) ? boolToString(!r.noRounding.value()) : "<unset>");
@@ -384,11 +412,11 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
 }
 
 static std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::string request) {
-    if (!g_pCompositor->m_pLastMonitor)
+    if (!g_pCompositor->m_lastMonitor)
         return "unsafe state";
 
     std::string result = "";
-    auto        w      = g_pCompositor->m_pLastMonitor->activeWorkspace;
+    auto        w      = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
     if (!valid(w))
         return "internal error";
@@ -401,7 +429,7 @@ static std::string workspacesRequest(eHyprCtlOutputFormat format, std::string re
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
-        for (auto const& w : g_pCompositor->m_vWorkspaces) {
+        for (auto const& w : g_pCompositor->m_workspaces) {
             result += CHyprCtl::getWorkspaceData(w, format);
             result += ",";
         }
@@ -409,7 +437,7 @@ static std::string workspacesRequest(eHyprCtlOutputFormat format, std::string re
         trimTrailingComma(result);
         result += "]";
     } else {
-        for (auto const& w : g_pCompositor->m_vWorkspaces) {
+        for (auto const& w : g_pCompositor->m_workspaces) {
             result += CHyprCtl::getWorkspaceData(w, format);
         }
     }
@@ -438,7 +466,7 @@ static std::string workspaceRulesRequest(eHyprCtlOutputFormat format, std::strin
 }
 
 static std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string request) {
-    const auto PWINDOW = g_pCompositor->m_pLastWindow.lock();
+    const auto PWINDOW = g_pCompositor->m_lastWindow.lock();
 
     if (!validMapped(PWINDOW))
         return format == eHyprCtlOutputFormat::FORMAT_JSON ? "{}" : "Invalid";
@@ -457,15 +485,15 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "{\n";
 
-        for (auto const& mon : g_pCompositor->m_vMonitors) {
+        for (auto const& mon : g_pCompositor->m_monitors) {
             result += std::format(
                 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"#(
         "{}": [
@@ -482,7 +510,7 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
                     "namespace": "{}",
                     "pid": {}
                 }},)#",
-                        (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace),
+                        (uintptr_t)layer.get(), layer->m_geometry.x, layer->m_geometry.y, layer->m_geometry.width, layer->m_geometry.height, escapeJSONStrings(layer->m_namespace),
                         layer->getPID());
                 }
 
@@ -506,16 +534,16 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
         result += "\n}\n";
 
     } else {
-        for (auto const& mon : g_pCompositor->m_vMonitors) {
-            result += std::format("Monitor {}:\n", mon->szName);
+        for (auto const& mon : g_pCompositor->m_monitors) {
+            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) {
-                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}, pid: {}\n", (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y,
-                                          layer->geometry.width, layer->geometry.height, layer->szNamespace, layer->getPID());
+                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}, pid: {}\n", (uintptr_t)layer.get(), layer->m_geometry.x, layer->m_geometry.y,
+                                          layer->m_geometry.width, layer->m_geometry.height, layer->m_namespace, layer->getPID());
                 }
 
                 layerLevel++;
@@ -576,26 +604,26 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
     std::string result = "";
 
     auto        getModState = [](SP<IKeyboard> keyboard, const char* xkbModName) -> bool {
-        auto IDX = xkb_keymap_mod_get_index(keyboard->xkbKeymap, xkbModName);
+        auto IDX = xkb_keymap_mod_get_index(keyboard->m_xkbKeymap, xkbModName);
 
         if (IDX == XKB_MOD_INVALID)
             return false;
 
-        return (keyboard->modifiersState.locked & (1 << IDX)) > 0;
+        return (keyboard->m_modifiersState.locked & (1 << IDX)) > 0;
     };
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "{\n";
         result += "\"mice\": [\n";
 
-        for (auto const& m : g_pInputManager->m_vPointers) {
+        for (auto const& m : g_pInputManager->m_pointers) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}",
         "defaultSpeed": {:.5f}
     }},)#",
-                (uintptr_t)m.get(), escapeJSONStrings(m->hlName),
+                (uintptr_t)m.get(), escapeJSONStrings(m->m_hlName),
                 m->aq() && m->aq()->getLibinputHandle() ? libinput_device_config_accel_get_default_speed(m->aq()->getLibinputHandle()) : 0.f);
         }
 
@@ -603,7 +631,7 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
         result += "\n],\n";
 
         result += "\"keyboards\": [\n";
-        for (auto const& k : g_pInputManager->m_vKeyboards) {
+        for (auto const& k : g_pInputManager->m_keyboards) {
             const auto KM = k->getActiveLayout();
             result += std::format(
                 R"#(    {{
@@ -619,9 +647,9 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
         "numLock": {},
         "main": {}
     }},)#",
-                (uintptr_t)k.get(), escapeJSONStrings(k->hlName), escapeJSONStrings(k->currentRules.rules), escapeJSONStrings(k->currentRules.model),
-                escapeJSONStrings(k->currentRules.layout), escapeJSONStrings(k->currentRules.variant), escapeJSONStrings(k->currentRules.options), escapeJSONStrings(KM),
-                (getModState(k, XKB_MOD_NAME_CAPS) ? "true" : "false"), (getModState(k, XKB_MOD_NAME_NUM) ? "true" : "false"), (k->active ? "true" : "false"));
+                (uintptr_t)k.get(), escapeJSONStrings(k->m_hlName), escapeJSONStrings(k->m_currentRules.rules), escapeJSONStrings(k->m_currentRules.model),
+                escapeJSONStrings(k->m_currentRules.layout), escapeJSONStrings(k->m_currentRules.variant), escapeJSONStrings(k->m_currentRules.options), escapeJSONStrings(KM),
+                (getModState(k, XKB_MOD_NAME_CAPS) ? "true" : "false"), (getModState(k, XKB_MOD_NAME_NUM) ? "true" : "false"), (k->m_active ? "true" : "false"));
         }
 
         trimTrailingComma(result);
@@ -629,7 +657,7 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "\"tablets\": [\n";
 
-        for (auto const& d : g_pInputManager->m_vTabletPads) {
+        for (auto const& d : g_pInputManager->m_tabletPads) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -639,19 +667,19 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
             "name": "{}"
         }}
     }},)#",
-                (uintptr_t)d.get(), (uintptr_t)d->parent.get(), escapeJSONStrings(d->parent ? d->parent->hlName : ""));
+                (uintptr_t)d.get(), (uintptr_t)d->m_parent.get(), escapeJSONStrings(d->m_parent ? d->m_parent->m_hlName : ""));
         }
 
-        for (auto const& d : g_pInputManager->m_vTablets) {
+        for (auto const& d : g_pInputManager->m_tablets) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}"
     }},)#",
-                (uintptr_t)d.get(), escapeJSONStrings(d->hlName));
+                (uintptr_t)d.get(), escapeJSONStrings(d->m_hlName));
         }
 
-        for (auto const& d : g_pInputManager->m_vTabletTools) {
+        for (auto const& d : g_pInputManager->m_tabletTools) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -665,13 +693,13 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "\"touch\": [\n";
 
-        for (auto const& d : g_pInputManager->m_vTouches) {
+        for (auto const& d : g_pInputManager->m_touches) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}"
     }},)#",
-                (uintptr_t)d.get(), escapeJSONStrings(d->hlName));
+                (uintptr_t)d.get(), escapeJSONStrings(d->m_hlName));
         }
 
         trimTrailingComma(result);
@@ -679,7 +707,7 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "\"switches\": [\n";
 
-        for (auto const& d : g_pInputManager->m_lSwitches) {
+        for (auto const& d : g_pInputManager->m_switches) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -696,45 +724,45 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
     } else {
         result += "mice:\n";
 
-        for (auto const& m : g_pInputManager->m_vPointers) {
-            result += std::format("\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)m.get(), m->hlName,
+        for (auto const& m : g_pInputManager->m_pointers) {
+            result += std::format("\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)m.get(), m->m_hlName,
                                   (m->aq() && m->aq()->getLibinputHandle() ? libinput_device_config_accel_get_default_speed(m->aq()->getLibinputHandle()) : 0.f));
         }
 
         result += "\n\nKeyboards:\n";
 
-        for (auto const& k : g_pInputManager->m_vKeyboards) {
+        for (auto const& k : g_pInputManager->m_keyboards) {
             const auto KM = k->getActiveLayout();
-            result +=
-                std::format("\tKeyboard at {:x}:\n\t\t{}\n\t\t\trules: r \"{}\", m \"{}\", l \"{}\", v \"{}\", o \"{}\"\n\t\t\tactive keymap: {}\n\t\t\tcapsLock: "
-                            "{}\n\t\t\tnumLock: {}\n\t\t\tmain: {}\n",
-                            (uintptr_t)k.get(), k->hlName, k->currentRules.rules, k->currentRules.model, k->currentRules.layout, k->currentRules.variant, k->currentRules.options,
-                            KM, (getModState(k, XKB_MOD_NAME_CAPS) ? "yes" : "no"), (getModState(k, XKB_MOD_NAME_NUM) ? "yes" : "no"), (k->active ? "yes" : "no"));
+            result += std::format("\tKeyboard at {:x}:\n\t\t{}\n\t\t\trules: r \"{}\", m \"{}\", l \"{}\", v \"{}\", o \"{}\"\n\t\t\tactive keymap: {}\n\t\t\tcapsLock: "
+                                  "{}\n\t\t\tnumLock: {}\n\t\t\tmain: {}\n",
+                                  (uintptr_t)k.get(), k->m_hlName, k->m_currentRules.rules, k->m_currentRules.model, k->m_currentRules.layout, k->m_currentRules.variant,
+                                  k->m_currentRules.options, KM, (getModState(k, XKB_MOD_NAME_CAPS) ? "yes" : "no"), (getModState(k, XKB_MOD_NAME_NUM) ? "yes" : "no"),
+                                  (k->m_active ? "yes" : "no"));
         }
 
         result += "\n\nTablets:\n";
 
-        for (auto const& d : g_pInputManager->m_vTabletPads) {
-            result += std::format("\tTablet Pad at {:x} (belongs to {:x} -> {})\n", (uintptr_t)d.get(), (uintptr_t)d->parent.get(), d->parent ? d->parent->hlName : "");
+        for (auto const& d : g_pInputManager->m_tabletPads) {
+            result += std::format("\tTablet Pad at {:x} (belongs to {:x} -> {})\n", (uintptr_t)d.get(), (uintptr_t)d->m_parent.get(), d->m_parent ? d->m_parent->m_hlName : "");
         }
 
-        for (auto const& d : g_pInputManager->m_vTablets) {
-            result += std::format("\tTablet at {:x}:\n\t\t{}\n\t\t\tsize: {}x{}mm\n", (uintptr_t)d.get(), d->hlName, d->aq()->physicalSize.x, d->aq()->physicalSize.y);
+        for (auto const& d : g_pInputManager->m_tablets) {
+            result += std::format("\tTablet at {:x}:\n\t\t{}\n\t\t\tsize: {}x{}mm\n", (uintptr_t)d.get(), d->m_hlName, d->aq()->physicalSize.x, d->aq()->physicalSize.y);
         }
 
-        for (auto const& d : g_pInputManager->m_vTabletTools) {
+        for (auto const& d : g_pInputManager->m_tabletTools) {
             result += std::format("\tTablet Tool at {:x}\n", (uintptr_t)d.get());
         }
 
         result += "\n\nTouch:\n";
 
-        for (auto const& d : g_pInputManager->m_vTouches) {
-            result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)d.get(), d->hlName);
+        for (auto const& d : g_pInputManager->m_touches) {
+            result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)d.get(), d->m_hlName);
         }
 
         result += "\n\nSwitches:\n";
 
-        for (auto const& d : g_pInputManager->m_lSwitches) {
+        for (auto const& d : g_pInputManager->m_switches) {
             result += std::format("\tSwitch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.pDevice ? d.pDevice->getName() : "");
         }
     }
@@ -800,10 +828,10 @@ static std::string rollinglogRequest(eHyprCtlOutputFormat format, std::string re
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[\n\"log\":\"";
-        result += escapeJSONStrings(Debug::rollingLog);
+        result += escapeJSONStrings(Debug::m_rollingLog);
         result += "\"]";
     } else {
-        result = Debug::rollingLog;
+        result = Debug::m_rollingLog;
     }
 
     return result;
@@ -838,7 +866,7 @@ static std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::stri
 static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
     std::string ret = "";
     if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
-        for (auto const& kb : g_pKeybindManager->m_vKeybinds) {
+        for (auto const& kb : g_pKeybindManager->m_keybinds) {
             ret += "bind";
             if (kb->locked)
                 ret += "l";
@@ -859,7 +887,7 @@ static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request
     } else {
         // json
         ret += "[";
-        for (auto const& kb : g_pKeybindManager->m_vKeybinds) {
+        for (auto const& kb : g_pKeybindManager->m_keybinds) {
             ret += std::format(
                 R"#(
 {{
@@ -1024,12 +1052,12 @@ std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request)
     result += "plugins:\n";
     if (g_pPluginSystem) {
         for (auto const& pl : g_pPluginSystem->getAllPlugins()) {
-            result += std::format("  {} by {} ver {}\n", pl->name, pl->author, pl->version);
+            result += std::format("  {} by {} ver {}\n", pl->m_name, pl->m_author, pl->m_version);
         }
     } else
         result += "\tunknown: not runtime\n";
 
-    if (g_pHyprCtl && g_pHyprCtl->m_sCurrentRequestParams.sysInfoConfig) {
+    if (g_pHyprCtl && g_pHyprCtl->m_currentRequestParams.sysInfoConfig) {
         result += "\n======Config-Start======\n";
         result += g_pConfigManager->getConfigString();
         result += "\n======Config-End========\n";
@@ -1048,8 +1076,8 @@ static std::string dispatchRequest(eHyprCtlOutputFormat format, std::string in)
     if ((int)in.find_first_of(' ') != -1)
         DISPATCHARG = in.substr(in.find_first_of(' ') + 1);
 
-    const auto DISPATCHER = g_pKeybindManager->m_mDispatchers.find(DISPATCHSTR);
-    if (DISPATCHER == g_pKeybindManager->m_mDispatchers.end())
+    const auto DISPATCHER = g_pKeybindManager->m_dispatchers.find(DISPATCHSTR);
+    if (DISPATCHER == g_pKeybindManager->m_dispatchers.end())
         return "Invalid dispatcher";
 
     SDispatchResult res = DISPATCHER->second(DISPATCHARG);
@@ -1085,7 +1113,7 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
 
     // if we are executing a dynamic source we have to reload everything, so every if will have a check for source.
     if (COMMAND == "monitor" || COMMAND == "source")
-        g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
+        g_pConfigManager->m_wantsMonitorReload = true; // for monitor keywords
 
     if (COMMAND.contains("input") || COMMAND.contains("device") || COMMAND == "source") {
         g_pInputManager->setKeyboardLayout();     // update kb layout
@@ -1100,10 +1128,10 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
         g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
 
     if (COMMAND.contains("decoration:screen_shader") || COMMAND == "source")
-        g_pHyprOpenGL->m_bReloadScreenShader = true;
+        g_pHyprOpenGL->m_reloadScreenShader = true;
 
     if (COMMAND.contains("blur") || COMMAND == "source") {
-        for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
+        for (auto& [m, rd] : g_pHyprOpenGL->m_monitorRenderResources) {
             rd.blurFBDirty = true;
         }
     }
@@ -1114,9 +1142,9 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
     // decorations will probably need a repaint
     if (COMMAND.contains("decoration:") || COMMAND.contains("border") || COMMAND == "workspace" || COMMAND.contains("zoom_factor") || COMMAND == "source" ||
         COMMAND.starts_with("windowrule")) {
-        for (auto const& m : g_pCompositor->m_vMonitors) {
+        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);
         }
     }
 
@@ -1133,7 +1161,7 @@ static std::string reloadRequest(eHyprCtlOutputFormat format, std::string reques
     const auto REQMODE = request.substr(request.find_last_of(' ') + 1);
 
     if (REQMODE == "config-only")
-        g_pConfigManager->m_bNoMonitorReload = true;
+        g_pConfigManager->m_noMonitorReload = true;
 
     g_pConfigManager->reload();
 
@@ -1147,7 +1175,7 @@ static std::string killRequest(eHyprCtlOutputFormat format, std::string request)
 }
 
 static std::string splashRequest(eHyprCtlOutputFormat format, std::string request) {
-    return g_pCompositor->m_szCurrentSplash;
+    return g_pCompositor->m_currentSplash;
 }
 
 static std::string cursorPosRequest(eHyprCtlOutputFormat format, std::string request) {
@@ -1227,19 +1255,20 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
     SP<IKeyboard> pKeyboard;
 
     auto          updateKeyboard = [](const SP<IKeyboard> KEEB, const std::string& CMD) -> std::optional<std::string> {
-        const auto         LAYOUTS      = xkb_keymap_num_layouts(KEEB->xkbKeymap);
+        const auto         LAYOUTS      = xkb_keymap_num_layouts(KEEB->m_xkbKeymap);
         xkb_layout_index_t activeLayout = 0;
         while (activeLayout < LAYOUTS) {
-            if (xkb_state_layout_index_is_active(KEEB->xkbState, activeLayout, XKB_STATE_LAYOUT_EFFECTIVE) == 1)
+            if (xkb_state_layout_index_is_active(KEEB->m_xkbState, activeLayout, XKB_STATE_LAYOUT_EFFECTIVE) == 1)
                 break;
 
             activeLayout++;
         }
 
         if (CMD == "next")
-            KEEB->updateModifiers(KEEB->modifiersState.depressed, KEEB->modifiersState.latched, KEEB->modifiersState.locked, activeLayout > LAYOUTS ? 0 : activeLayout + 1);
+            KEEB->updateModifiers(KEEB->m_modifiersState.depressed, KEEB->m_modifiersState.latched, KEEB->m_modifiersState.locked, activeLayout > LAYOUTS ? 0 : activeLayout + 1);
         else if (CMD == "prev")
-            KEEB->updateModifiers(KEEB->modifiersState.depressed, KEEB->modifiersState.latched, KEEB->modifiersState.locked, activeLayout == 0 ? LAYOUTS - 1 : activeLayout - 1);
+            KEEB->updateModifiers(KEEB->m_modifiersState.depressed, KEEB->m_modifiersState.latched, KEEB->m_modifiersState.locked,
+                                  activeLayout == 0 ? LAYOUTS - 1 : activeLayout - 1);
         else {
             int requestedLayout = 0;
             try {
@@ -1250,15 +1279,15 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
                 return "layout idx out of range of " + std::to_string(LAYOUTS);
             }
 
-            KEEB->updateModifiers(KEEB->modifiersState.depressed, KEEB->modifiersState.latched, KEEB->modifiersState.locked, requestedLayout);
+            KEEB->updateModifiers(KEEB->m_modifiersState.depressed, KEEB->m_modifiersState.latched, KEEB->m_modifiersState.locked, requestedLayout);
         }
 
         return std::nullopt;
     };
 
     if (KB == "main" || KB == "active" || KB == "current") {
-        for (auto const& k : g_pInputManager->m_vKeyboards) {
-            if (!k->active)
+        for (auto const& k : g_pInputManager->m_keyboards) {
+            if (!k->m_active)
                 continue;
 
             pKeyboard = k;
@@ -1266,17 +1295,17 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
         }
     } else if (KB == "all") {
         std::string result = "";
-        for (auto const& k : g_pInputManager->m_vKeyboards) {
+        for (auto const& k : g_pInputManager->m_keyboards) {
             auto res = updateKeyboard(k, CMD);
             if (res.has_value())
                 result += *res + "\n";
         }
         return result.empty() ? "ok" : result;
     } else {
-        auto k = std::find_if(g_pInputManager->m_vKeyboards.begin(), g_pInputManager->m_vKeyboards.end(),
-                              [&](const auto& other) { return other->hlName == g_pInputManager->deviceNameToInternalString(KB); });
+        auto k = std::find_if(g_pInputManager->m_keyboards.begin(), g_pInputManager->m_keyboards.end(),
+                              [&](const auto& other) { return other->m_hlName == g_pInputManager->deviceNameToInternalString(KB); });
 
-        if (k == g_pInputManager->m_vKeyboards.end())
+        if (k == g_pInputManager->m_keyboards.end())
             return "device not found";
 
         pKeyboard = *k;
@@ -1323,7 +1352,7 @@ static std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string req
 }
 
 static std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
-    auto result = g_pKeybindManager->m_mDispatchers["setprop"](request.substr(request.find_first_of(' ') + 1));
+    auto result = g_pKeybindManager->m_dispatchers["setprop"](request.substr(request.find_first_of(' ') + 1));
     return "DEPRECATED: use hyprctl dispatch setprop instead" + (result.success ? "" : "\n" + result.error);
 }
 
@@ -1393,7 +1422,7 @@ static std::string decorationRequest(eHyprCtlOutputFormat format, std::string re
     std::string result = "";
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
-        for (auto const& wd : PWINDOW->m_dWindowDecorations) {
+        for (auto const& wd : PWINDOW->m_windowDecorations) {
             result += "{\n\"decorationName\": \"" + wd->getDisplayName() + "\",\n\"priority\": " + std::to_string(wd->getPositioningInfo().priority) + "\n},";
         }
 
@@ -1401,7 +1430,7 @@ static std::string decorationRequest(eHyprCtlOutputFormat format, std::string re
         result += "]";
     } else {
         result = +"Decoration\tPriority\n";
-        for (auto const& wd : PWINDOW->m_dWindowDecorations) {
+        for (auto const& wd : PWINDOW->m_windowDecorations) {
             result += wd->getDisplayName() + "\t" + std::to_string(wd->getPositioningInfo().priority) + "\n";
         }
     }
@@ -1420,8 +1449,8 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
     bool       added = false;
 
     if (!vars[3].empty()) {
-        for (auto const& m : g_pCompositor->m_vRealMonitors) {
-            if (m->szName == vars[3])
+        for (auto const& m : g_pCompositor->m_realMonitors) {
+            if (m->m_name == vars[3])
                 return "Name already taken";
         }
     }
@@ -1430,7 +1459,7 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
         if (g_pCompositor->getMonitorFromName(vars[3]))
             return "A real monitor already uses that name.";
 
-        for (auto const& impl : g_pCompositor->m_pAqBackend->getImplementations() | std::views::reverse) {
+        for (auto const& impl : g_pCompositor->m_aqBackend->getImplementations() | std::views::reverse) {
             auto type = impl->type();
 
             if (type == Aquamarine::AQ_BACKEND_HEADLESS && (vars[2] == "headless" || vars[2] == "auto")) {
@@ -1455,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";
@@ -1477,10 +1506,18 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
         if (vars.size() < 3)
             return "not enough args";
 
-        const auto PLUGIN = g_pPluginSystem->loadPlugin(PATH);
+        g_pHyprCtl->m_currentRequestParams.pendingPromise = CPromise<std::string>::make([PATH](SP<CPromiseResolver<std::string>> resolver) {
+            g_pPluginSystem->loadPlugin(PATH)->then([resolver, PATH](SP<CPromiseResult<CPlugin*>> result) {
+                if (result->hasError()) {
+                    resolver->reject(result->error());
+                    return;
+                }
 
-        if (!PLUGIN)
-            return "error in loading plugin, last error: " + g_pPluginSystem->m_szLastError;
+                resolver->resolve("ok");
+            });
+        });
+
+        return "ok";
     } else if (OPERATION == "unload") {
         if (vars.size() < 3)
             return "not enough args";
@@ -1511,7 +1548,7 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
     "version": "{}",
     "description": "{}"
 }},)#",
-                    escapeJSONStrings(p->name), escapeJSONStrings(p->author), (uintptr_t)p->m_pHandle, escapeJSONStrings(p->version), escapeJSONStrings(p->description));
+                    escapeJSONStrings(p->m_name), escapeJSONStrings(p->m_author), (uintptr_t)p->m_handle, escapeJSONStrings(p->m_version), escapeJSONStrings(p->m_description));
             }
             trimTrailingComma(result);
             result += "]";
@@ -1520,8 +1557,8 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
                 return "no plugins loaded";
 
             for (auto const& p : PLUGINS) {
-                result +=
-                    std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->name, p->author, (uintptr_t)p->m_pHandle, p->version, p->description);
+                result += std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->m_name, p->m_author, (uintptr_t)p->m_handle, p->m_version,
+                                      p->m_description);
             }
         }
 
@@ -1643,6 +1680,13 @@ static std::string submapRequest(eHyprCtlOutputFormat format, std::string reques
     return format == FORMAT_JSON ? std::format("{{\"{}\"}}\n", escapeJSONStrings(submap)) : (submap + "\n");
 }
 
+static std::string reloadShaders(eHyprCtlOutputFormat format, std::string request) {
+    if (g_pHyprOpenGL->initShaders())
+        return format == FORMAT_JSON ? "{\"ok\": true}" : "ok";
+    else
+        return format == FORMAT_JSON ? "{\"ok\": false}" : "error";
+}
+
 CHyprCtl::CHyprCtl() {
     registerCommand(SHyprCtlCommand{"workspaces", true, workspacesRequest});
     registerCommand(SHyprCtlCommand{"workspacerules", true, workspaceRulesRequest});
@@ -1665,6 +1709,7 @@ CHyprCtl::CHyprCtl() {
     registerCommand(SHyprCtlCommand{"locked", true, getIsLocked});
     registerCommand(SHyprCtlCommand{"descriptions", true, getDescriptions});
     registerCommand(SHyprCtlCommand{"submap", true, submapRequest});
+    registerCommand(SHyprCtlCommand{.name = "reloadshaders", .exact = true, .fn = reloadShaders});
 
     registerCommand(SHyprCtlCommand{"monitors", false, monitorsRequest});
     registerCommand(SHyprCtlCommand{"reload", false, reloadRequest});
@@ -1693,17 +1738,18 @@ CHyprCtl::~CHyprCtl() {
 }
 
 SP<SHyprCtlCommand> CHyprCtl::registerCommand(SHyprCtlCommand cmd) {
-    return m_vCommands.emplace_back(makeShared<SHyprCtlCommand>(cmd));
+    return m_commands.emplace_back(makeShared<SHyprCtlCommand>(cmd));
 }
 
 void CHyprCtl::unregisterCommand(const SP<SHyprCtlCommand>& cmd) {
-    std::erase(m_vCommands, cmd);
+    std::erase(m_commands, cmd);
 }
 
 std::string CHyprCtl::getReply(std::string request) {
-    auto format             = eHyprCtlOutputFormat::FORMAT_NORMAL;
-    bool reloadAll          = false;
-    m_sCurrentRequestParams = {};
+    auto format                          = eHyprCtlOutputFormat::FORMAT_NORMAL;
+    bool reloadAll                       = false;
+    m_currentRequestParams.all           = false;
+    m_currentRequestParams.sysInfoConfig = false;
 
     // process flags for non-batch requests
     if (!request.starts_with("[[BATCH]]") && request.contains("/")) {
@@ -1727,9 +1773,9 @@ std::string CHyprCtl::getReply(std::string request) {
             else if (c == 'r')
                 reloadAll = true;
             else if (c == 'a')
-                m_sCurrentRequestParams.all = true;
+                m_currentRequestParams.all = true;
             else if (c == 'c')
-                m_sCurrentRequestParams.sysInfoConfig = true;
+                m_currentRequestParams.sysInfoConfig = true;
         }
 
         if (sepIndex < request.size())
@@ -1739,7 +1785,7 @@ std::string CHyprCtl::getReply(std::string request) {
     std::string result = "";
 
     // parse exact cmds first, then non-exact.
-    for (auto const& cmd : m_vCommands) {
+    for (auto const& cmd : m_commands) {
         if (!cmd->exact)
             continue;
 
@@ -1750,7 +1796,7 @@ std::string CHyprCtl::getReply(std::string request) {
     }
 
     if (result.empty())
-        for (auto const& cmd : m_vCommands) {
+        for (auto const& cmd : m_commands) {
             if (cmd->exact)
                 continue;
 
@@ -1764,7 +1810,7 @@ std::string CHyprCtl::getReply(std::string request) {
         return "unknown request";
 
     if (reloadAll) {
-        g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
+        g_pConfigManager->m_wantsMonitorReload = true; // for monitor keywords
 
         g_pInputManager->setKeyboardLayout();     // update kb layout
         g_pInputManager->setPointerConfigs();     // update mouse cfgs
@@ -1775,23 +1821,23 @@ std::string CHyprCtl::getReply(std::string request) {
 
         g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
 
-        g_pHyprOpenGL->m_bReloadScreenShader = true;
+        g_pHyprOpenGL->m_reloadScreenShader = true;
 
-        for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
+        for (auto& [m, rd] : g_pHyprOpenGL->m_monitorRenderResources) {
             rd.blurFBDirty = true;
         }
 
-        for (auto const& w : g_pCompositor->m_vWindows) {
-            if (!w->m_bIsMapped || !w->m_pWorkspace || !w->m_pWorkspace->isVisible())
+        for (auto const& w : g_pCompositor->m_windows) {
+            if (!w->m_isMapped || !w->m_workspace || !w->m_workspace->isVisible())
                 continue;
 
             w->updateDynamicRules();
             g_pCompositor->updateWindowAnimatedDecorationValues(w);
         }
 
-        for (auto const& m : g_pCompositor->m_vMonitors) {
+        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);
         }
     }
 
@@ -1846,16 +1892,26 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
     if (mask & WL_EVENT_ERROR || mask & WL_EVENT_HANGUP)
         return 0;
 
-    if (!g_pHyprCtl->m_iSocketFD.isValid())
+    if (!g_pHyprCtl->m_socketFD.isValid())
         return 0;
 
     sockaddr_in            clientAddress;
     socklen_t              clientSize = sizeof(clientAddress);
 
-    const auto             ACCEPTEDCONNECTION = accept4(g_pHyprCtl->m_iSocketFD.get(), (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);
+    const auto             ACCEPTEDCONNECTION = accept4(g_pHyprCtl->m_socketFD.get(), (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);
 
     std::array<char, 1024> readBuffer;
 
+    // try to get creds
+    CRED_T   creds;
+    uint32_t len = sizeof(creds);
+    if (getsockopt(ACCEPTEDCONNECTION, CRED_LVL, CRED_OPT, &creds, &len) == -1)
+        Debug::log(ERR, "Hyprctl: failed to get peer creds");
+    else {
+        g_pHyprCtl->m_currentRequestParams.pid = creds.CRED_PID;
+        Debug::log(LOG, "Hyprctl: new connection from pid {}", creds.CRED_PID);
+    }
+
     //
     pollfd pollfds[1] = {
         {
@@ -1892,45 +1948,61 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
         reply = "Err: " + std::string(e.what());
     }
 
-    successWrite(ACCEPTEDCONNECTION, reply);
+    if (g_pHyprCtl->m_currentRequestParams.pendingPromise) {
+        // we have a promise pending
+        g_pHyprCtl->m_currentRequestParams.pendingPromise->then([ACCEPTEDCONNECTION, request](SP<CPromiseResult<std::string>> result) {
+            const auto RES = result->hasError() ? result->error() : result->result();
+            successWrite(ACCEPTEDCONNECTION, RES);
 
-    if (isFollowUpRollingLogRequest(request)) {
-        Debug::log(LOG, "Followup rollinglog request received. Starting thread to write to socket.");
-        Debug::SRollingLogFollow::get().startFor(ACCEPTEDCONNECTION);
-        runWritingDebugLogThread(ACCEPTEDCONNECTION);
-        Debug::log(LOG, Debug::SRollingLogFollow::get().debugInfo());
-    } else
-        close(ACCEPTEDCONNECTION);
+            // No rollinglog or ensureMonitor here. These are only for plugins for now.
 
-    if (g_pConfigManager->m_bWantsMonitorReload)
-        g_pConfigManager->ensureMonitorStatus();
+            close(ACCEPTEDCONNECTION);
+        });
+
+        g_pHyprCtl->m_currentRequestParams.pendingPromise.reset();
+    } else {
+        successWrite(ACCEPTEDCONNECTION, reply);
+
+        if (isFollowUpRollingLogRequest(request)) {
+            Debug::log(LOG, "Followup rollinglog request received. Starting thread to write to socket.");
+            Debug::SRollingLogFollow::get().startFor(ACCEPTEDCONNECTION);
+            runWritingDebugLogThread(ACCEPTEDCONNECTION);
+            Debug::log(LOG, Debug::SRollingLogFollow::get().debugInfo());
+        } else
+            close(ACCEPTEDCONNECTION);
+
+        if (g_pConfigManager->m_wantsMonitorReload)
+            g_pConfigManager->ensureMonitorStatus();
+
+        g_pHyprCtl->m_currentRequestParams.pid = 0;
+    }
 
     return 0;
 }
 
 void CHyprCtl::startHyprCtlSocket() {
-    m_iSocketFD = CFileDescriptor{socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)};
+    m_socketFD = CFileDescriptor{socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)};
 
-    if (!m_iSocketFD.isValid()) {
+    if (!m_socketFD.isValid()) {
         Debug::log(ERR, "Couldn't start the Hyprland Socket. (1) IPC will not work.");
         return;
     }
 
     sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX};
 
-    m_socketPath = g_pCompositor->m_szInstancePath + "/.socket.sock";
+    m_socketPath = g_pCompositor->m_instancePath + "/.socket.sock";
 
     strcpy(SERVERADDRESS.sun_path, m_socketPath.c_str());
 
-    if (bind(m_iSocketFD.get(), (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
+    if (bind(m_socketFD.get(), (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
         Debug::log(ERR, "Couldn't start the Hyprland Socket. (2) IPC will not work.");
         return;
     }
 
     // 10 max queued.
-    listen(m_iSocketFD.get(), 10);
+    listen(m_socketFD.get(), 10);
 
     Debug::log(LOG, "Hypr socket started at {}", m_socketPath);
 
-    m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, m_iSocketFD.get(), WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
+    m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_wlEventLoop, m_socketFD.get(), WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
 }

src/debug/HyprCtl.hpp

@@ -2,8 +2,10 @@
 
 #include <fstream>
 #include "../helpers/MiscFunctions.hpp"
+#include "../helpers/defer/Promise.hpp"
 #include "../desktop/Window.hpp"
 #include <functional>
+#include <sys/types.h>
 #include <hyprutils/os/FileDescriptor.hpp>
 
 // exposed for main.cpp
@@ -20,12 +22,14 @@ class CHyprCtl {
     void                           unregisterCommand(const SP<SHyprCtlCommand>& cmd);
     std::string                    getReply(std::string);
 
-    Hyprutils::OS::CFileDescriptor m_iSocketFD;
+    Hyprutils::OS::CFileDescriptor m_socketFD;
 
     struct {
-        bool all           = false;
-        bool sysInfoConfig = false;
-    } m_sCurrentRequestParams;
+        bool                      all           = false;
+        bool                      sysInfoConfig = false;
+        pid_t                     pid           = 0;
+        SP<CPromise<std::string>> pendingPromise;
+    } m_currentRequestParams;
 
     static std::string getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format);
     static std::string getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format);
@@ -34,7 +38,7 @@ class CHyprCtl {
   private:
     void                             startHyprCtlSocket();
 
-    std::vector<SP<SHyprCtlCommand>> m_vCommands;
+    std::vector<SP<SHyprCtlCommand>> m_commands;
     wl_event_source*                 m_eventSource = nullptr;
     std::string                      m_socketPath;
 };

src/debug/HyprDebugOverlay.cpp

@@ -7,7 +7,7 @@
 #include "../managers/AnimationManager.hpp"
 
 CHyprDebugOverlay::CHyprDebugOverlay() {
-    m_pTexture = makeShared<CTexture>();
+    m_texture = makeShared<CTexture>();
 }
 
 void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
@@ -16,13 +16,13 @@ void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs)
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_dLastRenderTimes.emplace_back(durationUs / 1000.f);
+    m_lastRenderTimes.emplace_back(durationUs / 1000.f);
 
-    if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
-        m_dLastRenderTimes.pop_front();
+    if (m_lastRenderTimes.size() > (long unsigned int)pMonitor->m_refreshRate)
+        m_lastRenderTimes.pop_front();
 
-    if (!m_pMonitor)
-        m_pMonitor = pMonitor;
+    if (!m_monitor)
+        m_monitor = pMonitor;
 }
 
 void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
@@ -31,13 +31,13 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float du
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_dLastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
+    m_lastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
 
-    if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
-        m_dLastRenderTimesNoOverlay.pop_front();
+    if (m_lastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->m_refreshRate)
+        m_lastRenderTimesNoOverlay.pop_front();
 
-    if (!m_pMonitor)
-        m_pMonitor = pMonitor;
+    if (!m_monitor)
+        m_monitor = pMonitor;
 }
 
 void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
@@ -46,36 +46,36 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_dLastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
+    m_lastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_lastFrame).count() / 1000.f);
 
-    if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
-        m_dLastFrametimes.pop_front();
+    if (m_lastFrametimes.size() > (long unsigned int)pMonitor->m_refreshRate)
+        m_lastFrametimes.pop_front();
 
-    m_tpLastFrame = std::chrono::high_resolution_clock::now();
+    m_lastFrame = std::chrono::high_resolution_clock::now();
 
-    if (!m_pMonitor)
-        m_pMonitor = pMonitor;
+    if (!m_monitor)
+        m_monitor = pMonitor;
 
     // anim data too
-    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_pLastMonitor.lock();
+    const auto PMONITORFORTICKS = g_pHyprRenderer->m_mostHzMonitor ? g_pHyprRenderer->m_mostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock();
     if (PMONITORFORTICKS) {
-        if (m_dLastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
-            m_dLastAnimationTicks.pop_front();
+        if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate)
+            m_lastAnimationTicks.pop_front();
 
-        m_dLastAnimationTicks.push_back(g_pAnimationManager->m_fLastTickTime);
+        m_lastAnimationTicks.push_back(g_pAnimationManager->m_lastTickTimeMs);
     }
 }
 
 int CHyprMonitorDebugOverlay::draw(int offset) {
 
-    if (!m_pMonitor)
+    if (!m_monitor)
         return 0;
 
     // get avg fps
     float avgFrametime = 0;
     float maxFrametime = 0;
     float minFrametime = 9999;
-    for (auto const& ft : m_dLastFrametimes) {
+    for (auto const& ft : m_lastFrametimes) {
         if (ft > maxFrametime)
             maxFrametime = ft;
         if (ft < minFrametime)
@@ -83,12 +83,12 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgFrametime += ft;
     }
     float varFrametime = maxFrametime - minFrametime;
-    avgFrametime /= m_dLastFrametimes.size() == 0 ? 1 : m_dLastFrametimes.size();
+    avgFrametime /= m_lastFrametimes.size() == 0 ? 1 : m_lastFrametimes.size();
 
     float avgRenderTime = 0;
     float maxRenderTime = 0;
     float minRenderTime = 9999;
-    for (auto const& rt : m_dLastRenderTimes) {
+    for (auto const& rt : m_lastRenderTimes) {
         if (rt > maxRenderTime)
             maxRenderTime = rt;
         if (rt < minRenderTime)
@@ -96,12 +96,12 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgRenderTime += rt;
     }
     float varRenderTime = maxRenderTime - minRenderTime;
-    avgRenderTime /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
+    avgRenderTime /= m_lastRenderTimes.size() == 0 ? 1 : m_lastRenderTimes.size();
 
     float avgRenderTimeNoOverlay = 0;
     float maxRenderTimeNoOverlay = 0;
     float minRenderTimeNoOverlay = 9999;
-    for (auto const& rt : m_dLastRenderTimesNoOverlay) {
+    for (auto const& rt : m_lastRenderTimesNoOverlay) {
         if (rt > maxRenderTimeNoOverlay)
             maxRenderTimeNoOverlay = rt;
         if (rt < minRenderTimeNoOverlay)
@@ -109,12 +109,12 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgRenderTimeNoOverlay += rt;
     }
     float varRenderTimeNoOverlay = maxRenderTimeNoOverlay - minRenderTimeNoOverlay;
-    avgRenderTimeNoOverlay /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
+    avgRenderTimeNoOverlay /= m_lastRenderTimes.size() == 0 ? 1 : m_lastRenderTimes.size();
 
     float avgAnimMgrTick = 0;
     float maxAnimMgrTick = 0;
     float minAnimMgrTick = 9999;
-    for (auto const& at : m_dLastAnimationTicks) {
+    for (auto const& at : m_lastAnimationTicks) {
         if (at > maxAnimMgrTick)
             maxAnimMgrTick = at;
         if (at < minAnimMgrTick)
@@ -122,13 +122,13 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgAnimMgrTick += at;
     }
     float varAnimMgrTick = maxAnimMgrTick - minAnimMgrTick;
-    avgAnimMgrTick /= m_dLastAnimationTicks.size() == 0 ? 1 : m_dLastAnimationTicks.size();
+    avgAnimMgrTick /= m_lastAnimationTicks.size() == 0 ? 1 : m_lastAnimationTicks.size();
 
     const float           FPS      = 1.f / (avgFrametime / 1000.f); // frametimes are in ms
-    const float           idealFPS = m_dLastFrametimes.size();
+    const float           idealFPS = m_lastFrametimes.size();
 
     static auto           fontFamily = CConfigValue<std::string>("misc:font_family");
-    PangoLayout*          layoutText = pango_cairo_create_layout(g_pDebugOverlay->m_pCairo);
+    PangoLayout*          layoutText = pango_cairo_create_layout(g_pDebugOverlay->m_cairo);
     PangoFontDescription* pangoFD    = pango_font_description_new();
 
     pango_font_description_set_family(pangoFD, (*fontFamily).c_str());
@@ -137,7 +137,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     float maxTextW = 0;
     int   fontSize = 0;
-    auto  cr       = g_pDebugOverlay->m_pCairo;
+    auto  cr       = g_pDebugOverlay->m_cairo;
 
     auto  showText = [cr, layoutText, pangoFD, &maxTextW, &fontSize](const char* text, int size) {
         if (fontSize != size) {
@@ -163,22 +163,22 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     const int MARGIN_TOP  = 8;
     const int MARGIN_LEFT = 4;
     cairo_move_to(cr, MARGIN_LEFT, MARGIN_TOP + offset);
-    cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
+    cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f);
 
     std::string text;
-    showText(m_pMonitor->szName.c_str(), 10);
+    showText(m_monitor->m_name.c_str(), 10);
 
     if (FPS > idealFPS * 0.95f)
-        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 0.2f, 1.f, 0.2f, 1.f);
+        cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 0.2f, 1.f, 0.2f, 1.f);
     else if (FPS > idealFPS * 0.8f)
-        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 0.2f, 1.f);
+        cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 0.2f, 1.f);
     else
-        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 0.2f, 0.2f, 1.f);
+        cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 0.2f, 0.2f, 1.f);
 
     text = std::format("{} FPS", (int)FPS);
     showText(text.c_str(), 16);
 
-    cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
+    cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f);
 
     text = std::format("Avg Frametime: {:.2f}ms (var {:.2f}ms)", avgFrametime, varFrametime);
     showText(text.c_str(), 10);
@@ -198,10 +198,10 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     double posX = 0, posY = 0;
     cairo_get_current_point(cr, &posX, &posY);
 
-    g_pHyprRenderer->damageBox(m_wbLastDrawnBox);
-    m_wbLastDrawnBox = {(int)g_pCompositor->m_vMonitors.front()->vecPosition.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_vMonitors.front()->vecPosition.y + offset + MARGIN_TOP - 1,
-                        (int)maxTextW + 2, posY - offset - MARGIN_TOP + 2};
-    g_pHyprRenderer->damageBox(m_wbLastDrawnBox);
+    g_pHyprRenderer->damageBox(m_lastDrawnBox);
+    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);
 
     return posY - offset;
 }
@@ -212,7 +212,7 @@ void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs);
+    m_monitorOverlays[pMonitor].renderData(pMonitor, durationUs);
 }
 
 void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
@@ -221,7 +221,7 @@ void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationU
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
+    m_monitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
 }
 
 void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
@@ -230,37 +230,37 @@ void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_mMonitorOverlays[pMonitor].frameData(pMonitor);
+    m_monitorOverlays[pMonitor].frameData(pMonitor);
 }
 
 void CHyprDebugOverlay::draw() {
 
-    const auto PMONITOR = g_pCompositor->m_vMonitors.front();
+    const auto PMONITOR = g_pCompositor->m_monitors.front();
 
-    if (!m_pCairoSurface || !m_pCairo) {
-        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
-        m_pCairo        = cairo_create(m_pCairoSurface);
+    if (!m_cairoSurface || !m_cairo) {
+        m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
+        m_cairo        = cairo_create(m_cairoSurface);
     }
 
     // clear the pixmap
-    cairo_save(m_pCairo);
-    cairo_set_operator(m_pCairo, CAIRO_OPERATOR_CLEAR);
-    cairo_paint(m_pCairo);
-    cairo_restore(m_pCairo);
+    cairo_save(m_cairo);
+    cairo_set_operator(m_cairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(m_cairo);
+    cairo_restore(m_cairo);
 
     // draw the things
     int offsetY = 0;
-    for (auto const& m : g_pCompositor->m_vMonitors) {
-        offsetY += m_mMonitorOverlays[m].draw(offsetY);
+    for (auto const& m : g_pCompositor->m_monitors) {
+        offsetY += m_monitorOverlays[m].draw(offsetY);
         offsetY += 5; // for padding between mons
     }
 
-    cairo_surface_flush(m_pCairoSurface);
+    cairo_surface_flush(m_cairoSurface);
 
     // copy the data to an OpenGL texture we have
-    const auto DATA = cairo_image_surface_get_data(m_pCairoSurface);
-    m_pTexture->allocate();
-    glBindTexture(GL_TEXTURE_2D, m_pTexture->m_iTexID);
+    const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
+    m_texture->allocate();
+    glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
@@ -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_pTexture;
-    data.box = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
-    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
+    data.tex = m_texture;
+    data.box = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
+    g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
 }

src/debug/HyprDebugOverlay.hpp

@@ -17,13 +17,13 @@ class CHyprMonitorDebugOverlay {
     void frameData(PHLMONITOR pMonitor);
 
   private:
-    std::deque<float>                              m_dLastFrametimes;
-    std::deque<float>                              m_dLastRenderTimes;
-    std::deque<float>                              m_dLastRenderTimesNoOverlay;
-    std::deque<float>                              m_dLastAnimationTicks;
-    std::chrono::high_resolution_clock::time_point m_tpLastFrame;
-    PHLMONITORREF                                  m_pMonitor;
-    CBox                                           m_wbLastDrawnBox;
+    std::deque<float>                              m_lastFrametimes;
+    std::deque<float>                              m_lastRenderTimes;
+    std::deque<float>                              m_lastRenderTimesNoOverlay;
+    std::deque<float>                              m_lastAnimationTicks;
+    std::chrono::high_resolution_clock::time_point m_lastFrame;
+    PHLMONITORREF                                  m_monitor;
+    CBox                                           m_lastDrawnBox;
 
     friend class CHyprRenderer;
 };
@@ -37,12 +37,12 @@ class CHyprDebugOverlay {
     void frameData(PHLMONITOR);
 
   private:
-    std::map<PHLMONITORREF, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
+    std::map<PHLMONITORREF, CHyprMonitorDebugOverlay> m_monitorOverlays;
 
-    cairo_surface_t*                                  m_pCairoSurface = nullptr;
-    cairo_t*                                          m_pCairo        = nullptr;
+    cairo_surface_t*                                  m_cairoSurface = nullptr;
+    cairo_t*                                          m_cairo        = nullptr;
 
-    SP<CTexture>                                      m_pTexture;
+    SP<CTexture>                                      m_texture;
 
     friend class CHyprMonitorDebugOverlay;
     friend class CHyprRenderer;

src/debug/HyprNotificationOverlay.cpp

@@ -23,24 +23,24 @@ static inline auto iconBackendFromLayout(PangoLayout* layout) {
 
 CHyprNotificationOverlay::CHyprNotificationOverlay() {
     static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
-        if (m_vNotifications.size() == 0)
+        if (m_notifications.size() == 0)
             return;
 
-        g_pHyprRenderer->damageBox(m_bLastDamage);
+        g_pHyprRenderer->damageBox(m_lastDamage);
     });
 
-    m_pTexture = makeShared<CTexture>();
+    m_texture = makeShared<CTexture>();
 }
 
 CHyprNotificationOverlay::~CHyprNotificationOverlay() {
-    if (m_pCairo)
-        cairo_destroy(m_pCairo);
-    if (m_pCairoSurface)
-        cairo_surface_destroy(m_pCairoSurface);
+    if (m_cairo)
+        cairo_destroy(m_cairo);
+    if (m_cairoSurface)
+        cairo_surface_destroy(m_cairoSurface);
 }
 
 void CHyprNotificationOverlay::addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon, const float fontSize) {
-    const auto PNOTIF = m_vNotifications.emplace_back(makeUnique<SNotification>()).get();
+    const auto PNOTIF = m_notifications.emplace_back(makeUnique<SNotification>()).get();
 
     PNOTIF->text  = icon != eIcons::ICON_NONE ? " " + text /* tiny bit of padding otherwise icon touches text */ : text;
     PNOTIF->color = color == CHyprColor(0) ? ICONS_COLORS[icon] : color;
@@ -49,19 +49,19 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CH
     PNOTIF->icon     = icon;
     PNOTIF->fontSize = fontSize;
 
-    for (auto const& m : g_pCompositor->m_vMonitors) {
+    for (auto const& m : g_pCompositor->m_monitors) {
         g_pCompositor->scheduleFrameForMonitor(m);
     }
 }
 
 void CHyprNotificationOverlay::dismissNotifications(const int amount) {
     if (amount == -1)
-        m_vNotifications.clear();
+        m_notifications.clear();
     else {
-        const int AMT = std::min(amount, static_cast<int>(m_vNotifications.size()));
+        const int AMT = std::min(amount, static_cast<int>(m_notifications.size()));
 
         for (int i = 0; i < AMT; ++i) {
-            m_vNotifications.erase(m_vNotifications.begin());
+            m_notifications.erase(m_notifications.begin());
         }
     }
 }
@@ -77,12 +77,12 @@ 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");
 
-    PangoLayout*          layout  = pango_cairo_create_layout(m_pCairo);
+    PangoLayout*          layout  = pango_cairo_create_layout(m_cairo);
     PangoFontDescription* pangoFD = pango_font_description_new();
 
     pango_font_description_set_family(pangoFD, (*fontFamily).c_str());
@@ -92,9 +92,9 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     const auto iconBackendID = iconBackendFromLayout(layout);
     const auto PBEZIER       = g_pAnimationManager->getBezier("default");
 
-    for (auto const& notif : m_vNotifications) {
+    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 =
@@ -139,17 +139,17 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
         const auto NOTIFSIZE = Vector2D{textW + 20.0 + iconW + 2 * ICONPADFORNOTIF, textH + 10.0};
 
         // draw rects
-        cairo_set_source_rgba(m_pCairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
-        cairo_rectangle(m_pCairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, NOTIFSIZE.y);
-        cairo_fill(m_pCairo);
+        cairo_set_source_rgba(m_cairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
+        cairo_rectangle(m_cairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, NOTIFSIZE.y);
+        cairo_fill(m_cairo);
 
-        cairo_set_source_rgb(m_pCairo, 0.f, 0.f, 0.f);
-        cairo_rectangle(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC, offsetY, NOTIFSIZE.x * SECONDRECTPERC, NOTIFSIZE.y);
-        cairo_fill(m_pCairo);
+        cairo_set_source_rgb(m_cairo, 0.f, 0.f, 0.f);
+        cairo_rectangle(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC, offsetY, NOTIFSIZE.x * SECONDRECTPERC, NOTIFSIZE.y);
+        cairo_fill(m_cairo);
 
-        cairo_set_source_rgba(m_pCairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
-        cairo_rectangle(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + 3, offsetY + NOTIFSIZE.y - 4, THIRDRECTPERC * (NOTIFSIZE.x - 6), 2);
-        cairo_fill(m_pCairo);
+        cairo_set_source_rgba(m_cairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
+        cairo_rectangle(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + 3, offsetY + NOTIFSIZE.y - 4, THIRDRECTPERC * (NOTIFSIZE.x - 6), 2);
+        cairo_fill(m_cairo);
 
         // draw gradient
         if (notif->icon != ICON_NONE) {
@@ -158,23 +158,23 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
                                                   MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC + GRADIENT_SIZE, offsetY);
             cairo_pattern_add_color_stop_rgba(pattern, 0, ICONCOLOR.r, ICONCOLOR.g, ICONCOLOR.b, ICONCOLOR.a / 3.0);
             cairo_pattern_add_color_stop_rgba(pattern, 1, ICONCOLOR.r, ICONCOLOR.g, ICONCOLOR.b, 0);
-            cairo_rectangle(m_pCairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, GRADIENT_SIZE, NOTIFSIZE.y);
-            cairo_set_source(m_pCairo, pattern);
-            cairo_fill(m_pCairo);
+            cairo_rectangle(m_cairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, GRADIENT_SIZE, NOTIFSIZE.y);
+            cairo_set_source(m_cairo, pattern);
+            cairo_fill(m_cairo);
             cairo_pattern_destroy(pattern);
 
             // draw icon
-            cairo_set_source_rgb(m_pCairo, 1.f, 1.f, 1.f);
-            cairo_move_to(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + ICONPADFORNOTIF - 1, offsetY - 2 + std::round((NOTIFSIZE.y - iconH) / 2.0));
+            cairo_set_source_rgb(m_cairo, 1.f, 1.f, 1.f);
+            cairo_move_to(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + ICONPADFORNOTIF - 1, offsetY - 2 + std::round((NOTIFSIZE.y - iconH) / 2.0));
             pango_layout_set_text(layout, ICON.c_str(), -1);
-            pango_cairo_show_layout(m_pCairo, layout);
+            pango_cairo_show_layout(m_cairo, layout);
         }
 
         // draw text
-        cairo_set_source_rgb(m_pCairo, 1.f, 1.f, 1.f);
-        cairo_move_to(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + iconW + 2 * ICONPADFORNOTIF, offsetY - 2 + std::round((NOTIFSIZE.y - textH) / 2.0));
+        cairo_set_source_rgb(m_cairo, 1.f, 1.f, 1.f);
+        cairo_move_to(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + iconW + 2 * ICONPADFORNOTIF, offsetY - 2 + std::round((NOTIFSIZE.y - textH) / 2.0));
         pango_layout_set_text(layout, notif->text.c_str(), -1);
-        pango_cairo_show_layout(m_pCairo, layout);
+        pango_cairo_show_layout(m_cairo, layout);
 
         // adjust offset and move on
         offsetY += NOTIFSIZE.y + 10;
@@ -187,55 +187,55 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     g_object_unref(layout);
 
     // cleanup notifs
-    std::erase_if(m_vNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
+    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_pLastMonitor != pMonitor || m_vecLastSize != MONSIZE || !m_pCairo || !m_pCairoSurface) {
+    if (m_lastMonitor != pMonitor || m_lastSize != MONSIZE || !m_cairo || !m_cairoSurface) {
 
-        if (m_pCairo && m_pCairoSurface) {
-            cairo_destroy(m_pCairo);
-            cairo_surface_destroy(m_pCairoSurface);
+        if (m_cairo && m_cairoSurface) {
+            cairo_destroy(m_cairo);
+            cairo_surface_destroy(m_cairoSurface);
         }
 
-        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, MONSIZE.x, MONSIZE.y);
-        m_pCairo        = cairo_create(m_pCairoSurface);
-        m_pLastMonitor  = pMonitor;
-        m_vecLastSize   = MONSIZE;
+        m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, MONSIZE.x, MONSIZE.y);
+        m_cairo        = cairo_create(m_cairoSurface);
+        m_lastMonitor  = pMonitor;
+        m_lastSize     = MONSIZE;
     }
 
     // Draw the notifications
-    if (m_vNotifications.size() == 0)
+    if (m_notifications.size() == 0)
         return;
 
     // Render to the monitor
 
     // clear the pixmap
-    cairo_save(m_pCairo);
-    cairo_set_operator(m_pCairo, CAIRO_OPERATOR_CLEAR);
-    cairo_paint(m_pCairo);
-    cairo_restore(m_pCairo);
+    cairo_save(m_cairo);
+    cairo_set_operator(m_cairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(m_cairo);
+    cairo_restore(m_cairo);
 
-    cairo_surface_flush(m_pCairoSurface);
+    cairo_surface_flush(m_cairoSurface);
 
     CBox damage = drawNotifications(pMonitor);
 
     g_pHyprRenderer->damageBox(damage);
-    g_pHyprRenderer->damageBox(m_bLastDamage);
+    g_pHyprRenderer->damageBox(m_lastDamage);
 
     g_pCompositor->scheduleFrameForMonitor(pMonitor);
 
-    m_bLastDamage = damage;
+    m_lastDamage = damage;
 
     // copy the data to an OpenGL texture we have
-    const auto DATA = cairo_image_surface_get_data(m_pCairoSurface);
-    m_pTexture->allocate();
-    glBindTexture(GL_TEXTURE_2D, m_pTexture->m_iTexID);
+    const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
+    m_texture->allocate();
+    glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
@@ -247,13 +247,13 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, MONSIZE.x, MONSIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     CTexPassElement::SRenderData data;
-    data.tex = m_pTexture;
+    data.tex = m_texture;
     data.box = {0, 0, MONSIZE.x, MONSIZE.y};
     data.a   = 1.F;
 
-    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
+    g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
 }
 
 bool CHyprNotificationOverlay::hasAny() {
-    return !m_vNotifications.empty();
+    return !m_notifications.empty();
 }

src/debug/HyprNotificationOverlay.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../defines.hpp"
-#include "../helpers/Timer.hpp"
+#include "../helpers/time/Timer.hpp"
 #include "../render/Texture.hpp"
 #include "../SharedDefs.hpp"
 
@@ -47,17 +47,17 @@ class CHyprNotificationOverlay {
 
   private:
     CBox                           drawNotifications(PHLMONITOR pMonitor);
-    CBox                           m_bLastDamage;
+    CBox                           m_lastDamage;
 
-    std::vector<UP<SNotification>> m_vNotifications;
+    std::vector<UP<SNotification>> m_notifications;
 
-    cairo_surface_t*               m_pCairoSurface = nullptr;
-    cairo_t*                       m_pCairo        = nullptr;
+    cairo_surface_t*               m_cairoSurface = nullptr;
+    cairo_t*                       m_cairo        = nullptr;
 
-    PHLMONITORREF                  m_pLastMonitor;
-    Vector2D                       m_vecLastSize = Vector2D(-1, -1);
+    PHLMONITORREF                  m_lastMonitor;
+    Vector2D                       m_lastSize = Vector2D(-1, -1);
 
-    SP<CTexture>                   m_pTexture;
+    SP<CTexture>                   m_texture;
 };
 
 inline UP<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

src/debug/Log.cpp

@@ -7,21 +7,21 @@
 #include <fcntl.h>
 
 void Debug::init(const std::string& IS) {
-    logFile = IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
-    logOfs.open(logFile, std::ios::out | std::ios::app);
-    auto handle = logOfs.native_handle();
+    m_logFile = IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
+    m_logOfs.open(m_logFile, std::ios::out | std::ios::app);
+    auto handle = m_logOfs.native_handle();
     fcntl(handle, F_SETFD, FD_CLOEXEC);
 }
 
 void Debug::close() {
-    logOfs.close();
+    m_logOfs.close();
 }
 
 void Debug::log(eLogLevel level, std::string str) {
-    if (level == TRACE && !trace)
+    if (level == TRACE && !m_trace)
         return;
 
-    if (shuttingDown)
+    if (m_shuttingDown)
         return;
 
     std::string coloredStr = str;
@@ -55,20 +55,20 @@ void Debug::log(eLogLevel level, std::string str) {
     }
     //NOLINTEND
 
-    rollingLog += str + "\n";
-    if (rollingLog.size() > ROLLING_LOG_SIZE)
-        rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);
+    m_rollingLog += str + "\n";
+    if (m_rollingLog.size() > ROLLING_LOG_SIZE)
+        m_rollingLog = m_rollingLog.substr(m_rollingLog.size() - ROLLING_LOG_SIZE);
 
     if (SRollingLogFollow::get().isRunning())
         SRollingLogFollow::get().addLog(str);
 
-    if (!disableLogs || !**disableLogs) {
+    if (!m_disableLogs || !**m_disableLogs) {
         // log to a file
-        logOfs << str << "\n";
-        logOfs.flush();
+        m_logOfs << str << "\n";
+        m_logOfs.flush();
     }
 
     // log it to the stdout too.
-    if (!disableStdout)
-        std::println("{}", ((coloredLogs && !**coloredLogs) ? str : coloredStr));
+    if (!m_disableStdout)
+        std::println("{}", ((m_coloredLogs && !**m_coloredLogs) ? str : coloredStr));
 }

src/debug/Log.hpp

@@ -21,17 +21,17 @@ enum eLogLevel : int8_t {
 
 // NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
-    inline std::string     logFile;
-    inline std::ofstream   logOfs;
-    inline int64_t* const* disableLogs   = nullptr;
-    inline int64_t* const* disableTime   = nullptr;
-    inline bool            disableStdout = false;
-    inline bool            trace         = false;
-    inline bool            shuttingDown  = false;
-    inline int64_t* const* coloredLogs   = nullptr;
+    inline std::string     m_logFile;
+    inline std::ofstream   m_logOfs;
+    inline int64_t* const* m_disableLogs   = nullptr;
+    inline int64_t* const* m_disableTime   = nullptr;
+    inline bool            m_disableStdout = false;
+    inline bool            m_trace         = false;
+    inline bool            m_shuttingDown  = false;
+    inline int64_t* const* m_coloredLogs   = nullptr;
 
-    inline std::string     rollingLog = ""; // rolling log contains the ROLLING_LOG_SIZE tail of the log
-    inline std::mutex      logMutex;
+    inline std::string     m_rollingLog = ""; // rolling log contains the ROLLING_LOG_SIZE tail of the log
+    inline std::mutex      m_logMutex;
 
     void                   init(const std::string& IS);
     void                   close();
@@ -42,18 +42,18 @@ namespace Debug {
     template <typename... Args>
     //NOLINTNEXTLINE
     void log(eLogLevel level, std::format_string<Args...> fmt, Args&&... args) {
-        std::lock_guard<std::mutex> guard(logMutex);
+        std::lock_guard<std::mutex> guard(m_logMutex);
 
-        if (level == TRACE && !trace)
+        if (level == TRACE && !m_trace)
             return;
 
-        if (shuttingDown)
+        if (m_shuttingDown)
             return;
 
         std::string logMsg = "";
 
         // print date and time to the ofs
-        if (disableTime && !**disableTime) {
+        if (m_disableTime && !**m_disableTime) {
 #ifndef _LIBCPP_VERSION
             static auto current_zone = std::chrono::current_zone();
             const auto  zt           = std::chrono::zoned_time{current_zone, std::chrono::system_clock::now()};

src/debug/RollingLogFollow.hpp

@@ -5,55 +5,55 @@
 // NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
     struct SRollingLogFollow {
-        std::unordered_map<int, std::string> socketToRollingLogFollowQueue;
-        std::shared_mutex                    m;
-        bool                                 running                    = false;
+        std::unordered_map<int, std::string> m_socketToRollingLogFollowQueue;
+        std::shared_mutex                    m_mutex;
+        bool                                 m_running                  = false;
         static constexpr size_t              ROLLING_LOG_FOLLOW_TOO_BIG = 8192;
 
         // Returns true if the queue is empty for the given socket
         bool isEmpty(int socket) {
-            std::shared_lock<std::shared_mutex> r(m);
-            return socketToRollingLogFollowQueue[socket].empty();
+            std::shared_lock<std::shared_mutex> r(m_mutex);
+            return m_socketToRollingLogFollowQueue[socket].empty();
         }
 
         std::string debugInfo() {
-            std::shared_lock<std::shared_mutex> r(m);
-            return std::format("RollingLogFollow, got {} connections", socketToRollingLogFollowQueue.size());
+            std::shared_lock<std::shared_mutex> r(m_mutex);
+            return std::format("RollingLogFollow, got {} connections", m_socketToRollingLogFollowQueue.size());
         }
 
         std::string getLog(int socket) {
-            std::unique_lock<std::shared_mutex> w(m);
+            std::unique_lock<std::shared_mutex> w(m_mutex);
 
-            const std::string                   ret = socketToRollingLogFollowQueue[socket];
-            socketToRollingLogFollowQueue[socket]   = "";
+            const std::string                   ret = m_socketToRollingLogFollowQueue[socket];
+            m_socketToRollingLogFollowQueue[socket] = "";
 
             return ret;
         };
 
         void addLog(const std::string& log) {
-            std::unique_lock<std::shared_mutex> w(m);
-            running = true;
+            std::unique_lock<std::shared_mutex> w(m_mutex);
+            m_running = true;
             std::vector<int> to_erase;
-            for (const auto& p : socketToRollingLogFollowQueue)
-                socketToRollingLogFollowQueue[p.first] += log + "\n";
+            for (const auto& p : m_socketToRollingLogFollowQueue)
+                m_socketToRollingLogFollowQueue[p.first] += log + "\n";
         }
 
         bool isRunning() {
-            std::shared_lock<std::shared_mutex> r(m);
-            return running;
+            std::shared_lock<std::shared_mutex> r(m_mutex);
+            return m_running;
         }
 
         void stopFor(int socket) {
-            std::unique_lock<std::shared_mutex> w(m);
-            socketToRollingLogFollowQueue.erase(socket);
-            if (socketToRollingLogFollowQueue.empty())
-                running = false;
+            std::unique_lock<std::shared_mutex> w(m_mutex);
+            m_socketToRollingLogFollowQueue.erase(socket);
+            if (m_socketToRollingLogFollowQueue.empty())
+                m_running = false;
         }
 
         void startFor(int socket) {
-            std::unique_lock<std::shared_mutex> w(m);
-            socketToRollingLogFollowQueue[socket] = std::format("[LOG] Following log to socket: {} started\n", socket);
-            running                               = true;
+            std::unique_lock<std::shared_mutex> w(m_mutex);
+            m_socketToRollingLogFollowQueue[socket] = std::format("[LOG] Following log to socket: {} started\n", socket);
+            m_running                               = true;
         }
 
         static SRollingLogFollow& get() {

src/desktop/LayerRule.cpp

@@ -5,34 +5,36 @@
 #include "../debug/Log.hpp"
 
 static const auto RULES        = std::unordered_set<std::string>{"noanim", "blur", "blurpopups", "dimaround"};
-static const auto RULES_PREFIX = std::unordered_set<std::string>{"ignorealpha", "ignorezero", "xray", "animation", "order"};
+static const auto RULES_PREFIX = std::unordered_set<std::string>{"ignorealpha", "ignorezero", "xray", "animation", "order", "abovelock"};
 
-CLayerRule::CLayerRule(const std::string& rule_, const std::string& ns_) : targetNamespace(ns_), rule(rule_) {
-    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule_](const auto& prefix) { return rule_.starts_with(prefix); });
+CLayerRule::CLayerRule(const std::string& rule_, const std::string& ns_) : m_targetNamespace(ns_), m_rule(rule_) {
+    const bool VALID = RULES.contains(m_rule) || std::ranges::any_of(RULES_PREFIX, [&rule_](const auto& prefix) { return rule_.starts_with(prefix); });
 
     if (!VALID)
         return;
 
-    if (rule == "noanim")
-        ruleType = RULE_NOANIM;
-    else if (rule == "blur")
-        ruleType = RULE_BLUR;
-    else if (rule == "blurpopups")
-        ruleType = RULE_BLURPOPUPS;
-    else if (rule == "dimaround")
-        ruleType = RULE_DIMAROUND;
-    else if (rule.starts_with("ignorealpha"))
-        ruleType = RULE_IGNOREALPHA;
-    else if (rule.starts_with("ignorezero"))
-        ruleType = RULE_IGNOREZERO;
-    else if (rule.starts_with("xray"))
-        ruleType = RULE_XRAY;
-    else if (rule.starts_with("animation"))
-        ruleType = RULE_ANIMATION;
-    else if (rule.starts_with("order"))
-        ruleType = RULE_ORDER;
+    if (m_rule == "noanim")
+        m_ruleType = RULE_NOANIM;
+    else if (m_rule == "blur")
+        m_ruleType = RULE_BLUR;
+    else if (m_rule == "blurpopups")
+        m_ruleType = RULE_BLURPOPUPS;
+    else if (m_rule == "dimaround")
+        m_ruleType = RULE_DIMAROUND;
+    else if (m_rule.starts_with("ignorealpha"))
+        m_ruleType = RULE_IGNOREALPHA;
+    else if (m_rule.starts_with("ignorezero"))
+        m_ruleType = RULE_IGNOREZERO;
+    else if (m_rule.starts_with("xray"))
+        m_ruleType = RULE_XRAY;
+    else if (m_rule.starts_with("animation"))
+        m_ruleType = RULE_ANIMATION;
+    else if (m_rule.starts_with("order"))
+        m_ruleType = RULE_ORDER;
+    else if (m_rule.starts_with("abovelock"))
+        m_ruleType = RULE_ABOVELOCK;
     else {
         Debug::log(ERR, "CLayerRule: didn't match a rule that was found valid?!");
-        ruleType = RULE_INVALID;
+        m_ruleType = RULE_INVALID;
     }
-}
+}

src/desktop/LayerRule.hpp

@@ -14,6 +14,7 @@ class CLayerRule {
         RULE_BLUR,
         RULE_BLURPOPUPS,
         RULE_DIMAROUND,
+        RULE_ABOVELOCK,
         RULE_IGNOREALPHA,
         RULE_IGNOREZERO,
         RULE_XRAY,
@@ -22,10 +23,10 @@ class CLayerRule {
         RULE_ZUMBA,
     };
 
-    eRuleType           ruleType = RULE_INVALID;
+    eRuleType           m_ruleType = RULE_INVALID;
 
-    const std::string   targetNamespace;
-    const std::string   rule;
+    const std::string   m_targetNamespace;
+    const std::string   m_rule;
 
-    CRuleRegexContainer targetNamespaceRegex;
-};
+    CRuleRegexContainer m_targetNamespaceRegex;
+};

src/desktop/LayerSurface.cpp

@@ -15,424 +15,436 @@
 PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
     PHLLS pLS = SP<CLayerSurface>(new CLayerSurface(resource));
 
-    auto  pMonitor = resource->monitor.empty() ? g_pCompositor->m_pLastMonitor.lock() : g_pCompositor->getMonitorFromName(resource->monitor);
+    auto  pMonitor = resource->m_monitor.empty() ? g_pCompositor->m_lastMonitor.lock() : g_pCompositor->getMonitorFromName(resource->m_monitor);
 
-    pLS->surface->assign(resource->surface.lock(), pLS);
+    pLS->m_surface->assign(resource->m_surface.lock(), pLS);
 
     if (!pMonitor) {
         Debug::log(ERR, "New LS has no monitor??");
         return pLS;
     }
 
-    if (pMonitor->pMirrorOf)
-        pMonitor = g_pCompositor->m_vMonitors.front();
+    if (pMonitor->m_mirrorOf)
+        pMonitor = g_pCompositor->m_monitors.front();
 
-    pLS->self = pLS;
+    pLS->m_self = pLS;
 
-    pLS->szNamespace = resource->layerNamespace;
+    pLS->m_namespace = resource->m_layerNamespace;
 
-    pLS->layer     = resource->current.layer;
-    pLS->popupHead = CPopup::create(pLS);
-    pLS->monitor   = pMonitor;
-    pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);
+    pLS->m_layer     = resource->m_current.layer;
+    pLS->m_popupHead = CPopup::create(pLS);
+    pLS->m_monitor   = pMonitor;
+    pMonitor->m_layerSurfaceLayers[resource->m_current.layer].emplace_back(pLS);
 
-    pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);
+    pLS->m_forceBlur = g_pConfigManager->shouldBlurLS(pLS->m_namespace);
 
-    g_pAnimationManager->createAnimation(0.f, pLS->alpha, g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->realPosition, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->realSize, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pLS->m_alpha, g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->m_realPosition, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->m_realSize, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
 
     pLS->registerCallbacks();
 
-    pLS->alpha->setValueAndWarp(0.f);
+    pLS->m_alpha->setValueAndWarp(0.f);
 
-    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->layer, pMonitor->szName);
+    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->m_layerNamespace, (int)pLS->m_layer, pMonitor->m_name);
 
     return pLS;
 }
 
 void CLayerSurface::registerCallbacks() {
-    alpha->setUpdateCallback([this](auto) {
-        if (dimAround)
-            g_pHyprRenderer->damageMonitor(monitor.lock());
+    m_alpha->setUpdateCallback([this](auto) {
+        if (m_dimAround)
+            g_pHyprRenderer->damageMonitor(m_monitor.lock());
     });
 }
 
-CLayerSurface::CLayerSurface(SP<CLayerShellResource> resource_) : layerSurface(resource_) {
-    listeners.commit  = layerSurface->events.commit.registerListener([this](std::any d) { onCommit(); });
-    listeners.map     = layerSurface->events.map.registerListener([this](std::any d) { onMap(); });
-    listeners.unmap   = layerSurface->events.unmap.registerListener([this](std::any d) { onUnmap(); });
-    listeners.destroy = layerSurface->events.destroy.registerListener([this](std::any d) { onDestroy(); });
+CLayerSurface::CLayerSurface(SP<CLayerShellResource> resource_) : m_layerSurface(resource_) {
+    m_listeners.commit  = m_layerSurface->m_events.commit.registerListener([this](std::any d) { onCommit(); });
+    m_listeners.map     = m_layerSurface->m_events.map.registerListener([this](std::any d) { onMap(); });
+    m_listeners.unmap   = m_layerSurface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); });
+    m_listeners.destroy = m_layerSurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); });
 
-    surface = CWLSurface::create();
+    m_surface = CWLSurface::create();
 }
 
 CLayerSurface::~CLayerSurface() {
     if (!g_pHyprOpenGL)
         return;
 
-    if (surface)
-        surface->unassign();
+    if (m_surface)
+        m_surface->unassign();
     g_pHyprRenderer->makeEGLCurrent();
-    std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == self.lock(); });
+    std::erase_if(g_pHyprOpenGL->m_layerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); });
 
-    for (auto const& mon : g_pCompositor->m_vRealMonitors) {
-        for (auto& lsl : mon->m_aLayerSurfaceLayers) {
+    for (auto const& mon : g_pCompositor->m_realMonitors) {
+        for (auto& lsl : mon->m_layerSurfaceLayers) {
             std::erase_if(lsl, [this](auto& ls) { return ls.expired() || ls.get() == this; });
         }
     }
 }
 
 void CLayerSurface::onDestroy() {
-    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layerSurface.get());
+    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)m_layerSurface.get());
 
-    const auto PMONITOR = monitor.lock();
+    const auto PMONITOR = m_monitor.lock();
 
     if (!PMONITOR)
         Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
 
-    if (!fadingOut) {
-        if (mapped) {
+    if (!m_fadingOut) {
+        if (m_mapped) {
             Debug::log(LOG, "Forcing an unmap of a LS that did a straight destroy!");
             onUnmap();
         } else {
             Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-            if (alpha)
-                alpha->setValueAndWarp(0.f);
-            fadingOut = true;
-            g_pCompositor->addToFadingOutSafe(self.lock());
+            if (m_alpha)
+                m_alpha->setValueAndWarp(0.f);
+            m_fadingOut = true;
+            g_pCompositor->addToFadingOutSafe(m_self.lock());
         }
     }
 
-    popupHead.reset();
+    m_popupHead.reset();
 
-    noProcess = true;
+    m_noProcess = true;
 
     // 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 = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, 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);
     }
 
-    readyToDelete = true;
-    layerSurface.reset();
-    if (surface)
-        surface->unassign();
+    m_readyToDelete = true;
+    m_layerSurface.reset();
+    if (m_surface)
+        m_surface->unassign();
 
-    listeners.unmap.reset();
-    listeners.destroy.reset();
-    listeners.map.reset();
-    listeners.commit.reset();
+    m_listeners.unmap.reset();
+    m_listeners.destroy.reset();
+    m_listeners.map.reset();
+    m_listeners.commit.reset();
 }
 
 void CLayerSurface::onMap() {
-    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)layerSurface.get());
+    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)m_layerSurface.get());
 
-    mapped        = true;
-    interactivity = layerSurface->current.interactivity;
+    m_mapped        = true;
+    m_interactivity = m_layerSurface->m_current.interactivity;
 
-    layerSurface->surface->map();
+    m_layerSurface->m_surface->map();
 
     // this layer might be re-mapped.
-    fadingOut = false;
-    g_pCompositor->removeFromFadingOutSafe(self.lock());
+    m_fadingOut = false;
+    g_pCompositor->removeFromFadingOutSafe(m_self.lock());
 
     // fix if it changed its mon
-    const auto PMONITOR = monitor.lock();
+    const auto PMONITOR = m_monitor.lock();
 
     if (!PMONITOR)
         return;
 
     applyRules();
 
-    PMONITOR->scheduledRecalc = true;
+    PMONITOR->m_scheduledRecalc = true;
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
 
-    surface->resource()->enter(PMONITOR->self.lock());
+    m_surface->resource()->enter(PMONITOR->m_self.lock());
 
-    const bool ISEXCLUSIVE = layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
+    const bool ISEXCLUSIVE = m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
 
     if (ISEXCLUSIVE)
-        g_pInputManager->m_dExclusiveLSes.push_back(self);
+        g_pInputManager->m_exclusiveLSes.push_back(m_self);
 
     const bool GRABSFOCUS = ISEXCLUSIVE ||
-        (layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
+        (m_layerSurface->m_current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
          // don't focus if constrained
-         (g_pSeatManager->mouse.expired() || !g_pInputManager->isConstrained()));
+         (g_pSeatManager->m_mouse.expired() || !g_pInputManager->isConstrained()));
 
     if (GRABSFOCUS) {
         // TODO: use the new superb really very cool grab
         g_pSeatManager->setGrab(nullptr);
         g_pInputManager->releaseAllMouseButtons();
-        g_pCompositor->focusSurface(surface->resource());
+        g_pCompositor->focusSurface(m_surface->resource());
 
-        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y);
-        g_pSeatManager->setPointerFocus(surface->resource(), LOCAL);
-        g_pInputManager->m_bEmptyFocusCursorSet = false;
+        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_emptyFocusCursorSet = false;
     }
 
-    position = Vector2D(geometry.x, geometry.y);
+    m_position = Vector2D(m_geometry.x, m_geometry.y);
 
-    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, 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_bHasFullscreenWindow && PMONITOR->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN;
+    const bool FULLSCREEN = PMONITOR->m_activeWorkspace && PMONITOR->m_activeWorkspace->m_hasFullscreenWindow && PMONITOR->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN;
 
-    startAnimation(!(layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
-    readyToDelete = false;
-    fadingOut     = false;
+    startAnimation(!(m_layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
+    m_readyToDelete = false;
+    m_fadingOut     = false;
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", szNamespace});
-    EMIT_HOOK_EVENT("openLayer", self.lock());
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "openlayer", .data = m_namespace});
+    EMIT_HOOK_EVENT("openLayer", m_self.lock());
 
-    g_pCompositor->setPreferredScaleForSurface(surface->resource(), PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(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() {
-    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)layerSurface.get());
+    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)m_layerSurface.get());
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", layerSurface->layerNamespace});
-    EMIT_HOOK_EVENT("closeLayer", self.lock());
+    g_pEventManager->postEvent(SHyprIPCEvent{.event = "closelayer", .data = m_layerSurface->m_layerNamespace});
+    EMIT_HOOK_EVENT("closeLayer", m_self.lock());
 
-    std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
+    std::erase_if(g_pInputManager->m_exclusiveLSes, [this](const auto& other) { return !other || other == m_self; });
 
-    if (!monitor || g_pCompositor->m_bUnsafeState) {
+    if (!m_monitor || g_pCompositor->m_unsafeState) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
 
-        g_pCompositor->addToFadingOutSafe(self.lock());
+        g_pCompositor->addToFadingOutSafe(m_self.lock());
 
-        mapped = false;
-        if (layerSurface && layerSurface->surface)
-            layerSurface->surface->unmap();
+        m_mapped = false;
+        if (m_layerSurface && m_layerSurface->m_surface)
+            m_layerSurface->m_surface->unmap();
 
         startAnimation(false);
         return;
     }
 
+    // end any pending animations so that snapshot has right dimensions
+    m_realPosition->warp();
+    m_realSize->warp();
+
     // make a snapshot and start fade
-    g_pHyprRenderer->makeLayerSnapshot(self.lock());
+    g_pHyprRenderer->makeLayerSnapshot(m_self.lock());
 
     startAnimation(false);
 
-    mapped = false;
-    if (layerSurface && layerSurface->surface)
-        layerSurface->surface->unmap();
+    m_mapped = false;
+    if (m_layerSurface && m_layerSurface->m_surface)
+        m_layerSurface->m_surface->unmap();
 
-    g_pCompositor->addToFadingOutSafe(self.lock());
+    g_pCompositor->addToFadingOutSafe(m_self.lock());
 
-    const auto PMONITOR = monitor.lock();
+    const auto PMONITOR = m_monitor.lock();
 
-    const bool WASLASTFOCUS = g_pSeatManager->state.keyboardFocus == surface->resource() || g_pSeatManager->state.pointerFocus == surface->resource();
+    const bool WASLASTFOCUS = g_pSeatManager->m_state.keyboardFocus == m_surface->resource() || g_pSeatManager->m_state.pointerFocus == m_surface->resource();
 
     if (!PMONITOR)
         return;
 
     // refocus if needed
     //                                vvvvvvvvvvvvv if there is a last focus and the last focus is not keyboard focusable, fallback to window
-    if (WASLASTFOCUS || (g_pCompositor->m_pLastFocus && g_pCompositor->m_pLastFocus->hlSurface && !g_pCompositor->m_pLastFocus->hlSurface->keyboardFocusable()))
-        g_pInputManager->refocusLastWindow(PMONITOR);
-    else if (g_pCompositor->m_pLastFocus && g_pCompositor->m_pLastFocus != surface->resource())
-        g_pSeatManager->setKeyboardFocus(g_pCompositor->m_pLastFocus.lock());
+    if (WASLASTFOCUS || (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus->m_hlSurface && !g_pCompositor->m_lastFocus->m_hlSurface->keyboardFocusable())) {
+        if (!g_pInputManager->refocusLastWindow(PMONITOR))
+            g_pInputManager->refocus();
+    } else if (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus != m_surface->resource())
+        g_pSeatManager->setKeyboardFocus(g_pCompositor->m_lastFocus.lock());
 
-    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, 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 = {geometry.x + (int)PMONITOR->vecPosition.x, geometry.y + (int)PMONITOR->vecPosition.y, (int)layerSurface->surface->current.size.x,
-                 (int)layerSurface->surface->current.size.y};
+    geomFixed = {m_geometry.x + (int)PMONITOR->m_position.x, m_geometry.y + (int)PMONITOR->m_position.y, (int)m_layerSurface->m_surface->m_current.size.x,
+                 (int)m_layerSurface->m_surface->m_current.size.y};
     g_pHyprRenderer->damageBox(geomFixed);
 
     g_pInputManager->simulateMouseMovement();
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
 }
 
 void CLayerSurface::onCommit() {
-    if (!layerSurface)
+    if (!m_layerSurface)
         return;
 
-    if (!mapped) {
+    if (!m_mapped) {
         // we're re-mapping if this is the case
-        if (layerSurface->surface && !layerSurface->surface->current.texture) {
-            fadingOut = false;
-            geometry  = {};
+        if (m_layerSurface->m_surface && !m_layerSurface->m_surface->m_current.texture) {
+            m_fadingOut = false;
+            m_geometry  = {};
             g_pHyprRenderer->arrangeLayersForMonitor(monitorID());
         }
 
         return;
     }
 
-    const auto PMONITOR = monitor.lock();
+    const auto PMONITOR = m_monitor.lock();
 
     if (!PMONITOR)
         return;
 
-    if (layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+    if (m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
         g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
 
-    CBox geomFixed = {geometry.x, geometry.y, geometry.width, geometry.height};
+    CBox geomFixed = {m_geometry.x, m_geometry.y, m_geometry.width, m_geometry.height};
     g_pHyprRenderer->damageBox(geomFixed);
 
-    if (layerSurface->current.committed != 0) {
-        if (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
+    if (m_layerSurface->m_current.committed != 0) {
+        if (m_layerSurface->m_current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
 
-            for (auto it = PMONITOR->m_aLayerSurfaceLayers[layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[layer].end(); it++) {
-                if (*it == self) {
-                    if (layerSurface->current.layer == layer)
+            for (auto it = PMONITOR->m_layerSurfaceLayers[m_layer].begin(); it != PMONITOR->m_layerSurfaceLayers[m_layer].end(); it++) {
+                if (*it == m_self) {
+                    if (m_layerSurface->m_current.layer == m_layer)
                         break;
-                    PMONITOR->m_aLayerSurfaceLayers[layerSurface->current.layer].emplace_back(*it);
-                    PMONITOR->m_aLayerSurfaceLayers[layer].erase(it);
+                    PMONITOR->m_layerSurfaceLayers[m_layerSurface->m_current.layer].emplace_back(*it);
+                    PMONITOR->m_layerSurfaceLayers[m_layer].erase(it);
                     break;
                 }
             }
 
-            layer = layerSurface->current.layer;
+            m_layer = m_layerSurface->m_current.layer;
 
-            if (layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+            if (m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
                 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 {
-        position = Vector2D(geometry.x, geometry.y);
+        m_position = Vector2D(m_geometry.x, m_geometry.y);
 
         // update geom if it changed
-        if (layerSurface->surface->current.scale == 1 && PMONITOR->scale != 1.f && layerSurface->surface->current.viewport.hasDestination) {
+        if (m_layerSurface->m_surface->m_current.scale == 1 && PMONITOR->m_scale != 1.f && m_layerSurface->m_surface->m_current.viewport.hasDestination) {
             // fractional scaling. Dirty hack.
-            geometry = {geometry.pos(), layerSurface->surface->current.viewport.destination};
+            m_geometry = {m_geometry.pos(), m_layerSurface->m_surface->m_current.viewport.destination};
         } else {
             // this is because some apps like e.g. rofi-lbonn can't fucking use the protocol correctly.
-            geometry = {geometry.pos(), layerSurface->surface->current.size};
+            m_geometry = {m_geometry.pos(), m_layerSurface->m_surface->m_current.size};
         }
     }
 
-    if (realPosition->goal() != geometry.pos()) {
-        if (realPosition->isBeingAnimated())
-            *realPosition = geometry.pos();
+    if (m_realPosition->goal() != m_geometry.pos()) {
+        if (m_realPosition->isBeingAnimated())
+            *m_realPosition = m_geometry.pos();
         else
-            realPosition->setValueAndWarp(geometry.pos());
+            m_realPosition->setValueAndWarp(m_geometry.pos());
     }
-    if (realSize->goal() != geometry.size()) {
-        if (realSize->isBeingAnimated())
-            *realSize = geometry.size();
+    if (m_realSize->goal() != m_geometry.size()) {
+        if (m_realSize->isBeingAnimated())
+            *m_realSize = m_geometry.size();
         else
-            realSize->setValueAndWarp(geometry.size());
+            m_realSize->setValueAndWarp(m_geometry.size());
     }
 
-    if (mapped && (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_INTERACTIVITY)) {
+    if (m_mapped && (m_layerSurface->m_current.committed & CLayerShellResource::eCommittedState::STATE_INTERACTIVITY)) {
         bool WASLASTFOCUS = false;
-        layerSurface->surface->breadthfirst(
-            [&WASLASTFOCUS](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) { WASLASTFOCUS = WASLASTFOCUS || g_pSeatManager->state.keyboardFocus == surf; },
+        m_layerSurface->m_surface->breadthfirst(
+            [&WASLASTFOCUS](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) { WASLASTFOCUS = WASLASTFOCUS || g_pSeatManager->m_state.keyboardFocus == surf; },
             nullptr);
-        if (!WASLASTFOCUS && popupHead) {
-            popupHead->breadthfirst(
+        if (!WASLASTFOCUS && m_popupHead) {
+            m_popupHead->breadthfirst(
                 [&WASLASTFOCUS](WP<CPopup> popup, void* data) {
-                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_pWLSurface && g_pSeatManager->state.keyboardFocus == popup->m_pWLSurface->resource());
+                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_wlSurface && g_pSeatManager->m_state.keyboardFocus == popup->m_wlSurface->resource());
                 },
                 nullptr);
         }
-        const bool WASEXCLUSIVE = interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
-        const bool ISEXCLUSIVE  = layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
+        const bool WASEXCLUSIVE = m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
+        const bool ISEXCLUSIVE  = m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
 
         if (!WASEXCLUSIVE && ISEXCLUSIVE)
-            g_pInputManager->m_dExclusiveLSes.push_back(self);
+            g_pInputManager->m_exclusiveLSes.push_back(m_self);
         else if (WASEXCLUSIVE && !ISEXCLUSIVE)
-            std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
+            std::erase_if(g_pInputManager->m_exclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == m_self.lock(); });
 
         // if the surface was focused and interactive but now isn't, refocus
-        if (WASLASTFOCUS && layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE) {
+        if (WASLASTFOCUS && m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE) {
             // moveMouseUnified won't focus non interactive layers but it won't unfocus them either,
             // so unfocus the surface here.
             g_pCompositor->focusSurface(nullptr);
-            g_pInputManager->refocusLastWindow(monitor.lock());
-        } else if (WASLASTFOCUS && WASEXCLUSIVE && layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) {
+            g_pInputManager->refocusLastWindow(m_monitor.lock());
+        } else if (WASLASTFOCUS && WASEXCLUSIVE && m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) {
             g_pInputManager->simulateMouseMovement();
         } else if (!WASEXCLUSIVE && ISEXCLUSIVE) {
             // if now exclusive and not previously
             g_pSeatManager->setGrab(nullptr);
             g_pInputManager->releaseAllMouseButtons();
-            g_pCompositor->focusSurface(surface->resource());
+            g_pCompositor->focusSurface(m_surface->resource());
 
-            const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y);
-            g_pSeatManager->setPointerFocus(surface->resource(), LOCAL);
-            g_pInputManager->m_bEmptyFocusCursorSet = false;
+            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_emptyFocusCursorSet = false;
         }
     }
 
-    interactivity = layerSurface->current.interactivity;
+    m_interactivity = m_layerSurface->m_current.interactivity;
 
-    g_pHyprRenderer->damageSurface(surface->resource(), position.x, position.y);
+    g_pHyprRenderer->damageSurface(m_surface->resource(), m_position.x, m_position.y);
 
-    g_pCompositor->setPreferredScaleForSurface(surface->resource(), PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(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() {
-    noAnimations     = false;
-    forceBlur        = false;
-    ignoreAlpha      = false;
-    ignoreAlphaValue = 0.f;
-    dimAround        = false;
-    xray             = -1;
-    animationStyle.reset();
+    m_noAnimations     = false;
+    m_forceBlur        = false;
+    m_ignoreAlpha      = false;
+    m_ignoreAlphaValue = 0.f;
+    m_dimAround        = false;
+    m_xray             = -1;
+    m_animationStyle.reset();
 
-    for (auto const& rule : g_pConfigManager->getMatchingRules(self.lock())) {
-        switch (rule->ruleType) {
+    for (auto const& rule : g_pConfigManager->getMatchingRules(m_self.lock())) {
+        switch (rule->m_ruleType) {
             case CLayerRule::RULE_NOANIM: {
-                noAnimations = true;
+                m_noAnimations = true;
                 break;
             }
             case CLayerRule::RULE_BLUR: {
-                forceBlur = true;
+                m_forceBlur = true;
                 break;
             }
             case CLayerRule::RULE_BLURPOPUPS: {
-                forceBlurPopups = true;
+                m_forceBlurPopups = true;
                 break;
             }
             case CLayerRule::RULE_IGNOREALPHA:
             case CLayerRule::RULE_IGNOREZERO: {
-                const auto  FIRST_SPACE_POS = rule->rule.find_first_of(' ');
+                const auto  FIRST_SPACE_POS = rule->m_rule.find_first_of(' ');
                 std::string alphaValue      = "";
                 if (FIRST_SPACE_POS != std::string::npos)
-                    alphaValue = rule->rule.substr(FIRST_SPACE_POS + 1);
+                    alphaValue = rule->m_rule.substr(FIRST_SPACE_POS + 1);
 
                 try {
-                    ignoreAlpha = true;
+                    m_ignoreAlpha = true;
                     if (!alphaValue.empty())
-                        ignoreAlphaValue = std::stof(alphaValue);
+                        m_ignoreAlphaValue = std::stof(alphaValue);
                 } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
                 break;
             }
             case CLayerRule::RULE_DIMAROUND: {
-                dimAround = true;
+                m_dimAround = true;
                 break;
             }
             case CLayerRule::RULE_XRAY: {
-                CVarList vars{rule->rule, 0, ' '};
-                try {
-                    xray = configStringToInt(vars[1]).value_or(false);
-                } catch (...) {}
+                CVarList vars{rule->m_rule, 0, ' '};
+                m_xray = configStringToInt(vars[1]).value_or(false);
+
                 break;
             }
             case CLayerRule::RULE_ANIMATION: {
-                CVarList vars{rule->rule, 2, 's'};
-                animationStyle = vars[1];
+                CVarList vars{rule->m_rule, 2, 's'};
+                m_animationStyle = vars[1];
                 break;
             }
             case CLayerRule::RULE_ORDER: {
-                CVarList vars{rule->rule, 2, 's'};
+                CVarList vars{rule->m_rule, 2, 's'};
                 try {
-                    order = std::stoi(vars[1]);
+                    m_order = std::stoi(vars[1]);
                 } catch (...) { Debug::log(ERR, "Invalid value passed to order"); }
                 break;
             }
+            case CLayerRule::RULE_ABOVELOCK: {
+                m_aboveLockscreen = true;
+
+                CVarList vars{rule->m_rule, 0, ' '};
+                m_aboveLockscreenInteractable = configStringToInt(vars[1]).value_or(false);
+
+                break;
+            }
             default: break;
         }
     }
@@ -440,19 +452,19 @@ void CLayerSurface::applyRules() {
 
 void CLayerSurface::startAnimation(bool in, bool instant) {
     if (in) {
-        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
-        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
-        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
+        m_realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        m_realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
     } else {
-        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
-        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
-        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut"));
+        m_realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
+        m_realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
+        m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut"));
     }
 
-    const auto ANIMSTYLE = animationStyle.value_or(realPosition->getStyle());
+    const auto ANIMSTYLE = m_animationStyle.value_or(m_realPosition->getStyle());
     if (ANIMSTYLE.starts_with("slide")) {
         // get closest edge
-        const auto MIDDLE = geometry.middle();
+        const auto MIDDLE = m_geometry.middle();
 
         const auto PMONITOR = g_pCompositor->getMonitorFromVector(MIDDLE);
 
@@ -472,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();
@@ -490,38 +502,38 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
             }
         }
 
-        realSize->setValueAndWarp(geometry.size());
-        alpha->setValueAndWarp(in ? 0.f : 1.f);
-        *alpha = in ? 1.f : 0.f;
+        m_realSize->setValueAndWarp(m_geometry.size());
+        m_alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *m_alpha = in ? 1.f : 0.f;
 
         Vector2D prePos;
 
         switch (leader) {
             case 0:
                 // TOP
-                prePos = {geometry.x, PMONITOR->vecPosition.y - geometry.h};
+                prePos = {m_geometry.x, PMONITOR->m_position.y - m_geometry.h};
                 break;
             case 1:
                 // BOTTOM
-                prePos = {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 - geometry.w, geometry.y};
+                prePos = {PMONITOR->m_position.x - m_geometry.w, m_geometry.y};
                 break;
             case 3:
                 // RIGHT
-                prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, geometry.y};
+                prePos = {PMONITOR->m_position.x + PMONITOR->m_size.x, m_geometry.y};
                 break;
             default: UNREACHABLE();
         }
 
         if (in) {
-            realPosition->setValueAndWarp(prePos);
-            *realPosition = geometry.pos();
+            m_realPosition->setValueAndWarp(prePos);
+            *m_realPosition = m_geometry.pos();
         } else {
-            realPosition->setValueAndWarp(geometry.pos());
-            *realPosition = prePos;
+            m_realPosition->setValueAndWarp(m_geometry.pos());
+            *m_realPosition = prePos;
         }
 
     } else if (ANIMSTYLE.starts_with("popin")) {
@@ -537,62 +549,62 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
 
         minPerc *= 0.01;
 
-        const auto GOALSIZE = (geometry.size() * minPerc).clamp({5, 5});
-        const auto GOALPOS  = geometry.pos() + (geometry.size() - GOALSIZE) / 2.f;
+        const auto GOALSIZE = (m_geometry.size() * minPerc).clamp({5, 5});
+        const auto GOALPOS  = m_geometry.pos() + (m_geometry.size() - GOALSIZE) / 2.f;
 
-        alpha->setValueAndWarp(in ? 0.f : 1.f);
-        *alpha = in ? 1.f : 0.f;
+        m_alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *m_alpha = in ? 1.f : 0.f;
 
         if (in) {
-            realSize->setValueAndWarp(GOALSIZE);
-            realPosition->setValueAndWarp(GOALPOS);
-            *realSize     = geometry.size();
-            *realPosition = geometry.pos();
+            m_realSize->setValueAndWarp(GOALSIZE);
+            m_realPosition->setValueAndWarp(GOALPOS);
+            *m_realSize     = m_geometry.size();
+            *m_realPosition = m_geometry.pos();
         } else {
-            realSize->setValueAndWarp(geometry.size());
-            realPosition->setValueAndWarp(geometry.pos());
-            *realSize     = GOALSIZE;
-            *realPosition = GOALPOS;
+            m_realSize->setValueAndWarp(m_geometry.size());
+            m_realPosition->setValueAndWarp(m_geometry.pos());
+            *m_realSize     = GOALSIZE;
+            *m_realPosition = GOALPOS;
         }
     } else {
         // fade
-        realPosition->setValueAndWarp(geometry.pos());
-        realSize->setValueAndWarp(geometry.size());
-        *alpha = in ? 1.f : 0.f;
+        m_realPosition->setValueAndWarp(m_geometry.pos());
+        m_realSize->setValueAndWarp(m_geometry.size());
+        *m_alpha = in ? 1.f : 0.f;
     }
 
     if (!in)
-        fadingOut = true;
+        m_fadingOut = true;
 }
 
 bool CLayerSurface::isFadedOut() {
-    if (!fadingOut)
+    if (!m_fadingOut)
         return false;
 
-    return !realPosition->isBeingAnimated() && !realSize->isBeingAnimated() && !alpha->isBeingAnimated();
+    return !m_realPosition->isBeingAnimated() && !m_realSize->isBeingAnimated() && !m_alpha->isBeingAnimated();
 }
 
 int CLayerSurface::popupsCount() {
-    if (!layerSurface || !mapped || fadingOut)
+    if (!m_layerSurface || !m_mapped || m_fadingOut)
         return 0;
 
     int no = -1; // we have one dummy
-    popupHead->breadthfirst([](WP<CPopup> p, void* data) { *(int*)data += 1; }, &no);
+    m_popupHead->breadthfirst([](WP<CPopup> p, void* data) { *(int*)data += 1; }, &no);
     return no;
 }
 
 MONITORID CLayerSurface::monitorID() {
-    return monitor ? monitor->ID : MONITOR_INVALID;
+    return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
 }
 
 pid_t CLayerSurface::getPID() {
     pid_t PID = -1;
 
-    if (!layerSurface || !layerSurface->surface || !layerSurface->surface->getResource() || !layerSurface->surface->getResource()->resource() ||
-        !layerSurface->surface->getResource()->resource()->client)
+    if (!m_layerSurface || !m_layerSurface->m_surface || !m_layerSurface->m_surface->getResource() || !m_layerSurface->m_surface->getResource()->resource() ||
+        !m_layerSurface->m_surface->getResource()->resource()->client)
         return -1;
 
-    wl_client_get_credentials(layerSurface->surface->getResource()->resource()->client, &PID, nullptr, nullptr);
+    wl_client_get_credentials(m_layerSurface->m_surface->getResource()->resource()->client, &PID, nullptr, nullptr);
 
     return PID;
 }

src/desktop/LayerSurface.hpp

@@ -22,44 +22,45 @@ class CLayerSurface {
     bool                    isFadedOut();
     int                     popupsCount();
 
-    PHLANIMVAR<Vector2D>    realPosition;
-    PHLANIMVAR<Vector2D>    realSize;
-    PHLANIMVAR<float>       alpha;
+    PHLANIMVAR<Vector2D>    m_realPosition;
+    PHLANIMVAR<Vector2D>    m_realSize;
+    PHLANIMVAR<float>       m_alpha;
 
-    WP<CLayerShellResource> layerSurface;
-    wl_list                 link;
+    WP<CLayerShellResource> m_layerSurface;
 
     // the header providing the enum type cannot be imported here
-    int                        interactivity = 0;
+    int                        m_interactivity = 0;
 
-    SP<CWLSurface>             surface;
+    SP<CWLSurface>             m_surface;
 
-    bool                       mapped = false;
-    uint32_t                   layer  = 0;
+    bool                       m_mapped = false;
+    uint32_t                   m_layer  = 0;
 
-    PHLMONITORREF              monitor;
+    PHLMONITORREF              m_monitor;
 
-    bool                       fadingOut     = false;
-    bool                       readyToDelete = false;
-    bool                       noProcess     = false;
-    bool                       noAnimations  = false;
+    bool                       m_fadingOut     = false;
+    bool                       m_readyToDelete = false;
+    bool                       m_noProcess     = false;
+    bool                       m_noAnimations  = false;
 
-    bool                       forceBlur        = false;
-    bool                       forceBlurPopups  = false;
-    int64_t                    xray             = -1;
-    bool                       ignoreAlpha      = false;
-    float                      ignoreAlphaValue = 0.f;
-    bool                       dimAround        = false;
-    int64_t                    order            = 0;
+    bool                       m_forceBlur                   = false;
+    bool                       m_forceBlurPopups             = false;
+    int64_t                    m_xray                        = -1;
+    bool                       m_ignoreAlpha                 = false;
+    float                      m_ignoreAlphaValue            = 0.f;
+    bool                       m_dimAround                   = false;
+    int64_t                    m_order                       = 0;
+    bool                       m_aboveLockscreen             = false;
+    bool                       m_aboveLockscreenInteractable = false;
 
-    std::optional<std::string> animationStyle;
+    std::optional<std::string> m_animationStyle;
 
-    PHLLSREF                   self;
+    PHLLSREF                   m_self;
 
-    CBox                       geometry = {0, 0, 0, 0};
-    Vector2D                   position;
-    std::string                szNamespace = "";
-    UP<CPopup>                 popupHead;
+    CBox                       m_geometry = {0, 0, 0, 0};
+    Vector2D                   m_position;
+    std::string                m_namespace = "";
+    UP<CPopup>                 m_popupHead;
 
     pid_t                      getPID();
 
@@ -75,12 +76,12 @@ class CLayerSurface {
         CHyprSignalListener map;
         CHyprSignalListener unmap;
         CHyprSignalListener commit;
-    } listeners;
+    } m_listeners;
 
     void registerCallbacks();
 
     // For the list lookup
     bool operator==(const CLayerSurface& rhs) const {
-        return layerSurface == rhs.layerSurface && monitor == rhs.monitor;
+        return m_layerSurface == rhs.m_layerSurface && m_monitor == rhs.m_monitor;
     }
 };

src/desktop/Popup.cpp

@@ -5,7 +5,6 @@
 #include "../protocols/XDGShell.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../managers/SeatManager.hpp"
-#include "../managers/eventLoop/EventLoopManager.hpp"
 #include "../desktop/LayerSurface.hpp"
 #include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
@@ -13,32 +12,32 @@
 #include <ranges>
 
 UP<CPopup> CPopup::create(PHLWINDOW pOwner) {
-    auto popup            = UP<CPopup>(new CPopup());
-    popup->m_pWindowOwner = pOwner;
-    popup->m_pSelf        = popup;
+    auto popup           = UP<CPopup>(new CPopup());
+    popup->m_windowOwner = pOwner;
+    popup->m_self        = popup;
     popup->initAllSignals();
     return popup;
 }
 
 UP<CPopup> CPopup::create(PHLLS pOwner) {
-    auto popup           = UP<CPopup>(new CPopup());
-    popup->m_pLayerOwner = pOwner;
-    popup->m_pSelf       = popup;
+    auto popup          = UP<CPopup>(new CPopup());
+    popup->m_layerOwner = pOwner;
+    popup->m_self       = popup;
     popup->initAllSignals();
     return popup;
 }
 
 UP<CPopup> CPopup::create(SP<CXDGPopupResource> resource, WP<CPopup> pOwner) {
-    auto popup            = UP<CPopup>(new CPopup());
-    popup->m_pResource    = resource;
-    popup->m_pWindowOwner = pOwner->m_pWindowOwner;
-    popup->m_pLayerOwner  = pOwner->m_pLayerOwner;
-    popup->m_pParent      = pOwner;
-    popup->m_pSelf        = popup;
-    popup->m_pWLSurface   = CWLSurface::create();
-    popup->m_pWLSurface->assign(resource->surface->surface.lock(), popup.get());
+    auto popup           = UP<CPopup>(new CPopup());
+    popup->m_resource    = resource;
+    popup->m_windowOwner = pOwner->m_windowOwner;
+    popup->m_layerOwner  = pOwner->m_layerOwner;
+    popup->m_parent      = pOwner;
+    popup->m_self        = popup;
+    popup->m_wlSurface   = CWLSurface::create();
+    popup->m_wlSurface->assign(resource->m_surface->m_surface.lock(), popup.get());
 
-    popup->m_vLastSize = resource->surface->current.geometry.size();
+    popup->m_lastSize = resource->m_surface->m_current.geometry.size();
     popup->reposition();
 
     popup->initAllSignals();
@@ -46,104 +45,114 @@ UP<CPopup> CPopup::create(SP<CXDGPopupResource> resource, WP<CPopup> pOwner) {
 }
 
 CPopup::~CPopup() {
-    if (m_pWLSurface)
-        m_pWLSurface->unassign();
+    if (m_wlSurface)
+        m_wlSurface->unassign();
 }
 
 void CPopup::initAllSignals() {
 
-    if (!m_pResource) {
-        if (!m_pWindowOwner.expired())
-            listeners.newPopup = m_pWindowOwner->m_pXDGSurface->events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
-        else if (!m_pLayerOwner.expired())
-            listeners.newPopup = m_pLayerOwner->layerSurface->events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
+    if (!m_resource) {
+        if (!m_windowOwner.expired())
+            m_listeners.newPopup =
+                m_windowOwner->m_xdgSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
+        else if (!m_layerOwner.expired())
+            m_listeners.newPopup =
+                m_layerOwner->m_layerSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
         else
             ASSERT(false);
 
         return;
     }
 
-    listeners.reposition = m_pResource->events.reposition.registerListener([this](std::any d) { this->onReposition(); });
-    listeners.map        = m_pResource->surface->events.map.registerListener([this](std::any d) { this->onMap(); });
-    listeners.unmap      = m_pResource->surface->events.unmap.registerListener([this](std::any d) { this->onUnmap(); });
-    listeners.dismissed  = m_pResource->events.dismissed.registerListener([this](std::any d) { this->onUnmap(); });
-    listeners.destroy    = m_pResource->surface->events.destroy.registerListener([this](std::any d) { this->onDestroy(); });
-    listeners.commit     = m_pResource->surface->events.commit.registerListener([this](std::any d) { this->onCommit(); });
-    listeners.newPopup   = m_pResource->surface->events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
+    m_listeners.reposition = m_resource->m_events.reposition.registerListener([this](std::any d) { this->onReposition(); });
+    m_listeners.map        = m_resource->m_surface->m_events.map.registerListener([this](std::any d) { this->onMap(); });
+    m_listeners.unmap      = m_resource->m_surface->m_events.unmap.registerListener([this](std::any d) { this->onUnmap(); });
+    m_listeners.dismissed  = m_resource->m_events.dismissed.registerListener([this](std::any d) { this->onUnmap(); });
+    m_listeners.destroy    = m_resource->m_surface->m_events.destroy.registerListener([this](std::any d) { this->onDestroy(); });
+    m_listeners.commit     = m_resource->m_surface->m_events.commit.registerListener([this](std::any d) { this->onCommit(); });
+    m_listeners.newPopup   = m_resource->m_surface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
 }
 
 void CPopup::onNewPopup(SP<CXDGPopupResource> popup) {
-    const auto& POPUP = m_vChildren.emplace_back(CPopup::create(popup, m_pSelf));
-    POPUP->m_pSelf    = POPUP;
+    const auto& POPUP = m_children.emplace_back(CPopup::create(popup, m_self));
+    POPUP->m_self     = POPUP;
     Debug::log(LOG, "New popup at {:x}", (uintptr_t)POPUP);
 }
 
 void CPopup::onDestroy() {
-    m_bInert = true;
+    m_inert = true;
 
-    if (!m_pParent)
+    if (!m_parent)
         return; // head node
 
-    std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; });
+    std::erase_if(m_parent->m_children, [this](const auto& other) { return other.get() == this; });
 }
 
 void CPopup::onMap() {
-    if (m_bMapped)
+    if (m_mapped)
         return;
 
-    m_bMapped   = true;
-    m_vLastSize = m_pResource->surface->surface->current.size;
+    m_mapped   = true;
+    m_lastSize = m_resource->m_surface->m_surface->m_current.size;
 
     const auto COORDS   = coordsGlobal();
     const auto PMONITOR = g_pCompositor->getMonitorFromVector(COORDS);
 
-    CBox       box = m_pWLSurface->resource()->extends();
+    CBox       box = m_wlSurface->resource()->extends();
     box.translate(COORDS).expand(4);
     g_pHyprRenderer->damageBox(box);
 
-    m_vLastPos = coordsRelativeToParent();
+    m_lastPos = coordsRelativeToParent();
 
     g_pInputManager->simulateMouseMovement();
 
-    m_pSubsurfaceHead = CSubsurface::create(m_pSelf);
+    m_subsurfaceHead = CSubsurface::create(m_self);
 
     //unconstrain();
     sendScale();
-    m_pResource->surface->surface->enter(PMONITOR->self.lock());
+    m_resource->m_surface->m_surface->enter(PMONITOR->m_self.lock());
 
-    if (!m_pLayerOwner.expired() && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
+    if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
 }
 
 void CPopup::onUnmap() {
-    if (!m_bMapped)
+    if (!m_mapped)
         return;
 
-    if (!m_pResource || !m_pResource->surface) {
+    if (!m_resource || !m_resource->m_surface) {
         Debug::log(ERR, "CPopup: orphaned (no surface/resource) and unmaps??");
         onDestroy();
         return;
     }
 
-    m_bMapped = false;
+    m_mapped = false;
 
-    m_vLastSize = m_pResource->surface->surface->current.size;
+    // if the popup committed a different size right now, we also need to damage the old size.
+    const Vector2D MAX_DAMAGE_SIZE = {std::max(m_lastSize.x, m_resource->m_surface->m_surface->m_current.size.x),
+                                      std::max(m_lastSize.y, m_resource->m_surface->m_surface->m_current.size.y)};
+
+    m_lastSize = m_resource->m_surface->m_surface->m_current.size;
 
     const auto COORDS = coordsGlobal();
 
-    CBox       box = m_pWLSurface->resource()->extends();
+    CBox       box = m_wlSurface->resource()->extends();
     box.translate(COORDS).expand(4);
     g_pHyprRenderer->damageBox(box);
 
-    m_pSubsurfaceHead.reset();
+    // damage the last popup's explicit max size as well
+    box = CBox{COORDS, MAX_DAMAGE_SIZE}.expand(4);
+    g_pHyprRenderer->damageBox(box);
 
-    if (!m_pLayerOwner.expired() && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
+    m_subsurfaceHead.reset();
+
+    if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
 
     // damage all children
     breadthfirst(
         [](WP<CPopup> p, void* data) {
-            if (!p->m_pResource)
+            if (!p->m_resource)
                 return;
 
             auto box = CBox{p->coordsGlobal(), p->size()};
@@ -159,59 +168,59 @@ void CPopup::onUnmap() {
 }
 
 void CPopup::onCommit(bool ignoreSiblings) {
-    if (!m_pResource || !m_pResource->surface) {
+    if (!m_resource || !m_resource->m_surface) {
         Debug::log(ERR, "CPopup: orphaned (no surface/resource) and commits??");
         onDestroy();
         return;
     }
 
-    if (m_pResource->surface->initialCommit) {
-        m_pResource->surface->scheduleConfigure();
+    if (m_resource->m_surface->m_initialCommit) {
+        m_resource->m_surface->scheduleConfigure();
         return;
     }
 
-    if (!m_pWindowOwner.expired() && (!m_pWindowOwner->m_bIsMapped || !m_pWindowOwner->m_pWorkspace->m_bVisible)) {
-        m_vLastSize = m_pResource->surface->surface->current.size;
+    if (!m_windowOwner.expired() && (!m_windowOwner->m_isMapped || !m_windowOwner->m_workspace->m_visible)) {
+        m_lastSize = m_resource->m_surface->m_surface->m_current.size;
 
         static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
         if (*PLOGDAMAGE)
-            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowOwner.lock());
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_windowOwner.lock());
         return;
     }
 
-    if (!m_pResource->surface->mapped)
+    if (!m_resource->m_surface->m_mapped)
         return;
 
     const auto COORDS      = coordsGlobal();
     const auto COORDSLOCAL = coordsRelativeToParent();
 
-    if (m_vLastSize != m_pResource->surface->surface->current.size || m_bRequestedReposition || m_vLastPos != COORDSLOCAL) {
-        CBox box = {localToGlobal(m_vLastPos), m_vLastSize};
+    if (m_lastSize != m_resource->m_surface->m_surface->m_current.size || m_requestedReposition || m_lastPos != COORDSLOCAL) {
+        CBox box = {localToGlobal(m_lastPos), m_lastSize};
         g_pHyprRenderer->damageBox(box);
-        m_vLastSize = m_pResource->surface->surface->current.size;
-        box         = {COORDS, m_vLastSize};
+        m_lastSize = m_resource->m_surface->m_surface->m_current.size;
+        box        = {COORDS, m_lastSize};
         g_pHyprRenderer->damageBox(box);
 
-        m_vLastPos = COORDSLOCAL;
+        m_lastPos = COORDSLOCAL;
     }
 
-    if (!ignoreSiblings && m_pSubsurfaceHead)
-        m_pSubsurfaceHead->recheckDamageForSubsurfaces();
+    if (!ignoreSiblings && m_subsurfaceHead)
+        m_subsurfaceHead->recheckDamageForSubsurfaces();
 
-    g_pHyprRenderer->damageSurface(m_pWLSurface->resource(), COORDS.x, COORDS.y);
+    g_pHyprRenderer->damageSurface(m_wlSurface->resource(), COORDS.x, COORDS.y);
 
-    m_bRequestedReposition = false;
+    m_requestedReposition = false;
 
-    if (!m_pLayerOwner.expired() && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
+    if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
 }
 
 void CPopup::onReposition() {
     Debug::log(LOG, "Popup {:x} requests reposition", (uintptr_t)this);
 
-    m_bRequestedReposition = true;
+    m_requestedReposition = true;
 
-    m_vLastPos = coordsRelativeToParent();
+    m_lastPos = coordsRelativeToParent();
 
     reposition();
 }
@@ -223,32 +232,32 @@ void CPopup::reposition() {
     if (!PMONITOR)
         return;
 
-    CBox box = {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
-    m_pResource->applyPositioning(box, COORDS);
+    CBox box = {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
+    m_resource->applyPositioning(box, COORDS);
 }
 
 SP<CWLSurface> CPopup::getT1Owner() {
-    if (m_pWindowOwner)
-        return m_pWindowOwner->m_pWLSurface;
+    if (m_windowOwner)
+        return m_windowOwner->m_wlSurface;
     else
-        return m_pLayerOwner->surface;
+        return m_layerOwner->m_surface;
 }
 
 Vector2D CPopup::coordsRelativeToParent() {
     Vector2D offset;
 
-    if (!m_pResource)
+    if (!m_resource)
         return {};
 
-    WP<CPopup> current = m_pSelf;
-    offset -= current->m_pResource->surface->current.geometry.pos();
+    WP<CPopup> current = m_self;
+    offset -= current->m_resource->m_surface->m_current.geometry.pos();
 
-    while (current->m_pParent && current->m_pResource) {
+    while (current->m_parent && current->m_resource) {
 
-        offset += current->m_pWLSurface->resource()->current.offset;
-        offset += current->m_pResource->geometry.pos();
+        offset += current->m_wlSurface->resource()->m_current.offset;
+        offset += current->m_resource->m_geometry.pos();
 
-        current = current->m_pParent;
+        current = current->m_parent;
     }
 
     return offset;
@@ -263,30 +272,30 @@ Vector2D CPopup::localToGlobal(const Vector2D& rel) {
 }
 
 Vector2D CPopup::t1ParentCoords() {
-    if (!m_pWindowOwner.expired())
-        return m_pWindowOwner->m_vRealPosition->value();
-    if (!m_pLayerOwner.expired())
-        return m_pLayerOwner->realPosition->value();
+    if (!m_windowOwner.expired())
+        return m_windowOwner->m_realPosition->value();
+    if (!m_layerOwner.expired())
+        return m_layerOwner->m_realPosition->value();
 
     ASSERT(false);
     return {};
 }
 
 void CPopup::recheckTree() {
-    WP<CPopup> curr = m_pSelf;
-    while (curr->m_pParent) {
-        curr = curr->m_pParent;
+    WP<CPopup> curr = m_self;
+    while (curr->m_parent) {
+        curr = curr->m_parent;
     }
 
     curr->recheckChildrenRecursive();
 }
 
 void CPopup::recheckChildrenRecursive() {
-    if (m_bInert || !m_pWLSurface)
+    if (m_inert || !m_wlSurface)
         return;
 
     std::vector<WP<CPopup>> cpy;
-    std::ranges::for_each(m_vChildren, [&cpy](const auto& el) { cpy.emplace_back(el); });
+    std::ranges::for_each(m_children, [&cpy](const auto& el) { cpy.emplace_back(el); });
     for (auto const& c : cpy) {
         c->onCommit(true);
         c->recheckChildrenRecursive();
@@ -294,25 +303,25 @@ void CPopup::recheckChildrenRecursive() {
 }
 
 Vector2D CPopup::size() {
-    return m_vLastSize;
+    return m_lastSize;
 }
 
 void CPopup::sendScale() {
-    if (!m_pWindowOwner.expired())
-        g_pCompositor->setPreferredScaleForSurface(m_pWLSurface->resource(), m_pWindowOwner->m_pWLSurface->m_fLastScale);
-    else if (!m_pLayerOwner.expired())
-        g_pCompositor->setPreferredScaleForSurface(m_pWLSurface->resource(), m_pLayerOwner->surface->m_fLastScale);
+    if (!m_windowOwner.expired())
+        g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_windowOwner->m_wlSurface->m_lastScaleFloat);
+    else if (!m_layerOwner.expired())
+        g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_layerOwner->m_surface->m_lastScaleFloat);
     else
         UNREACHABLE();
 }
 
 bool CPopup::visible() {
-    if (!m_pWindowOwner.expired())
-        return g_pHyprRenderer->shouldRenderWindow(m_pWindowOwner.lock());
-    if (!m_pLayerOwner.expired())
+    if (!m_windowOwner.expired())
+        return g_pHyprRenderer->shouldRenderWindow(m_windowOwner.lock());
+    if (!m_layerOwner.expired())
         return true;
-    if (m_pParent)
-        return m_pParent->visible();
+    if (m_parent)
+        return m_parent->visible();
 
     return false;
 }
@@ -326,8 +335,8 @@ void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(W
     nodes2.reserve(nodes.size() * 2);
 
     for (auto const& n : nodes) {
-        for (auto const& c : n->m_vChildren) {
-            nodes2.push_back(c->m_pSelf);
+        for (auto const& c : n->m_children) {
+            nodes2.push_back(c->m_self);
         }
     }
 
@@ -337,7 +346,7 @@ void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(W
 
 void CPopup::breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data) {
     std::vector<WP<CPopup>> popups;
-    popups.push_back(m_pSelf);
+    popups.push_back(m_self);
     bfHelper(popups, fn, data);
 }
 
@@ -346,14 +355,14 @@ WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
     breadthfirst([&popups](WP<CPopup> popup, void* data) { popups.push_back(popup); }, &popups);
 
     for (auto const& p : popups | std::views::reverse) {
-        if (!p->m_pResource || !p->m_bMapped)
+        if (!p->m_resource || !p->m_mapped)
             continue;
 
         if (!allowsInput) {
-            const bool HASSURFACE = p->m_pResource && p->m_pResource->surface;
+            const bool HASSURFACE = p->m_resource && p->m_resource->m_surface;
 
-            Vector2D   offset = HASSURFACE ? p->m_pResource->surface->current.geometry.pos() : Vector2D{};
-            Vector2D   size   = HASSURFACE ? p->m_pResource->surface->current.geometry.size() : p->size();
+            Vector2D   offset = HASSURFACE ? p->m_resource->m_surface->m_current.geometry.pos() : Vector2D{};
+            Vector2D   size   = HASSURFACE ? p->m_resource->m_surface->m_current.geometry.size() : p->size();
 
             if (size == Vector2D{})
                 size = p->size();
@@ -362,7 +371,7 @@ WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
             if (BOX.containsPoint(globalCoords))
                 return p;
         } else {
-            const auto REGION = CRegion{p->m_pWLSurface->resource()->current.input}.intersect(CBox{{}, p->m_pWLSurface->resource()->current.size}).translate(p->coordsGlobal());
+            const auto REGION = CRegion{p->m_wlSurface->resource()->m_current.input}.intersect(CBox{{}, p->m_wlSurface->resource()->m_current.size}).translate(p->coordsGlobal());
             if (REGION.containsPoint(globalCoords))
                 return p;
         }
@@ -372,5 +381,5 @@ WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
 }
 
 bool CPopup::inert() const {
-    return m_bInert;
+    return m_inert;
 }

src/desktop/Popup.hpp

@@ -41,32 +41,32 @@ class CPopup {
     WP<CPopup> at(const Vector2D& globalCoords, bool allowsInput = false);
 
     //
-    SP<CWLSurface> m_pWLSurface;
-    WP<CPopup>     m_pSelf;
-    bool           m_bMapped = false;
+    SP<CWLSurface> m_wlSurface;
+    WP<CPopup>     m_self;
+    bool           m_mapped = false;
 
   private:
     CPopup() = default;
 
     // T1 owners, each popup has to have one of these
-    PHLWINDOWREF m_pWindowOwner;
-    PHLLSREF     m_pLayerOwner;
+    PHLWINDOWREF m_windowOwner;
+    PHLLSREF     m_layerOwner;
 
     // T2 owners
-    WP<CPopup>            m_pParent;
+    WP<CPopup>            m_parent;
 
-    WP<CXDGPopupResource> m_pResource;
+    WP<CXDGPopupResource> m_resource;
 
-    Vector2D              m_vLastSize = {};
-    Vector2D              m_vLastPos  = {};
+    Vector2D              m_lastSize = {};
+    Vector2D              m_lastPos  = {};
 
-    bool                  m_bRequestedReposition = false;
+    bool                  m_requestedReposition = false;
 
-    bool                  m_bInert = false;
+    bool                  m_inert = false;
 
     //
-    std::vector<UP<CPopup>> m_vChildren;
-    UP<CSubsurface>         m_pSubsurfaceHead;
+    std::vector<UP<CPopup>> m_children;
+    UP<CSubsurface>         m_subsurfaceHead;
 
     struct {
         CHyprSignalListener newPopup;
@@ -76,7 +76,7 @@ class CPopup {
         CHyprSignalListener commit;
         CHyprSignalListener dismissed;
         CHyprSignalListener reposition;
-    } listeners;
+    } m_listeners;
 
     void        initAllSignals();
     void        reposition();

src/desktop/Rule.cpp

@@ -6,17 +6,17 @@
 CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) {
     const bool NEGATIVE = regex_.starts_with("negative:");
 
-    negative = NEGATIVE;
-    regex    = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
+    m_negative = NEGATIVE;
+    m_regex    = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
 
     // TODO: maybe pop an error?
-    if (!regex->ok())
+    if (!m_regex->ok())
         Debug::log(ERR, "RuleRegexContainer: regex {} failed to parse!", regex_);
 }
 
 bool CRuleRegexContainer::passes(const std::string& str) const {
-    if (!regex)
+    if (!m_regex)
         return false;
 
-    return RE2::FullMatch(str, *regex) != negative;
+    return RE2::FullMatch(str, *m_regex) != m_negative;
 }

src/desktop/Rule.hpp

@@ -16,6 +16,6 @@ class CRuleRegexContainer {
     bool passes(const std::string& str) const;
 
   private:
-    Hyprutils::Memory::CUniquePointer<re2::RE2> regex;
-    bool                                        negative = false;
+    Hyprutils::Memory::CUniquePointer<re2::RE2> m_regex;
+    bool                                        m_negative = false;
 };

src/desktop/Subsurface.cpp

@@ -8,62 +8,62 @@
 #include "../managers/input/InputManager.hpp"
 
 UP<CSubsurface> CSubsurface::create(PHLWINDOW pOwner) {
-    auto subsurface             = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_pWindowParent = pOwner;
-    subsurface->m_pSelf         = subsurface;
+    auto subsurface            = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_windowParent = pOwner;
+    subsurface->m_self         = subsurface;
 
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+    subsurface->initExistingSubsurfaces(pOwner->m_wlSurface->resource());
     return subsurface;
 }
 
 UP<CSubsurface> CSubsurface::create(WP<CPopup> pOwner) {
-    auto subsurface            = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_pPopupParent = pOwner;
-    subsurface->m_pSelf        = subsurface;
+    auto subsurface           = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_popupParent = pOwner;
+    subsurface->m_self        = subsurface;
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+    subsurface->initExistingSubsurfaces(pOwner->m_wlSurface->resource());
     return subsurface;
 }
 
 UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner) {
-    auto subsurface             = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_pWindowParent = pOwner;
-    subsurface->m_pSubsurface   = pSubsurface;
-    subsurface->m_pSelf         = subsurface;
-    subsurface->m_pWLSurface    = CWLSurface::create();
-    subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get());
+    auto subsurface            = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_windowParent = pOwner;
+    subsurface->m_subsurface   = pSubsurface;
+    subsurface->m_self         = subsurface;
+    subsurface->m_wlSurface    = CWLSurface::create();
+    subsurface->m_wlSurface->assign(pSubsurface->m_surface.lock(), subsurface.get());
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
+    subsurface->initExistingSubsurfaces(pSubsurface->m_surface.lock());
     return subsurface;
 }
 
 UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner) {
-    auto subsurface            = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_pPopupParent = pOwner;
-    subsurface->m_pSubsurface  = pSubsurface;
-    subsurface->m_pSelf        = subsurface;
-    subsurface->m_pWLSurface   = CWLSurface::create();
-    subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get());
+    auto subsurface           = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_popupParent = pOwner;
+    subsurface->m_subsurface  = pSubsurface;
+    subsurface->m_self        = subsurface;
+    subsurface->m_wlSurface   = CWLSurface::create();
+    subsurface->m_wlSurface->assign(pSubsurface->m_surface.lock(), subsurface.get());
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
+    subsurface->initExistingSubsurfaces(pSubsurface->m_surface.lock());
     return subsurface;
 }
 
 void CSubsurface::initSignals() {
-    if (m_pSubsurface) {
-        listeners.commitSubsurface  = m_pSubsurface->surface->events.commit.registerListener([this](std::any d) { onCommit(); });
-        listeners.destroySubsurface = m_pSubsurface->events.destroy.registerListener([this](std::any d) { onDestroy(); });
-        listeners.mapSubsurface     = m_pSubsurface->surface->events.map.registerListener([this](std::any d) { onMap(); });
-        listeners.unmapSubsurface   = m_pSubsurface->surface->events.unmap.registerListener([this](std::any d) { onUnmap(); });
-        listeners.newSubsurface =
-            m_pSubsurface->surface->events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
+    if (m_subsurface) {
+        m_listeners.commitSubsurface  = m_subsurface->m_surface->m_events.commit.registerListener([this](std::any d) { onCommit(); });
+        m_listeners.destroySubsurface = m_subsurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); });
+        m_listeners.mapSubsurface     = m_subsurface->m_surface->m_events.map.registerListener([this](std::any d) { onMap(); });
+        m_listeners.unmapSubsurface   = m_subsurface->m_surface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); });
+        m_listeners.newSubsurface =
+            m_subsurface->m_surface->m_events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
     } else {
-        if (m_pWindowParent)
-            listeners.newSubsurface = m_pWindowParent->m_pWLSurface->resource()->events.newSubsurface.registerListener(
+        if (m_windowParent)
+            m_listeners.newSubsurface = m_windowParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener(
                 [this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
-        else if (m_pPopupParent)
-            listeners.newSubsurface = m_pPopupParent->m_pWLSurface->resource()->events.newSubsurface.registerListener(
+        else if (m_popupParent)
+            m_listeners.newSubsurface = m_popupParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener(
                 [this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
         else
             ASSERT(false);
@@ -71,115 +71,102 @@ void CSubsurface::initSignals() {
 }
 
 void CSubsurface::checkSiblingDamage() {
-    if (!m_pParent)
+    if (!m_parent)
         return; // ??????????
 
-    const double SCALE = m_pWindowParent.lock() && m_pWindowParent->m_bIsX11 ? 1.0 / m_pWindowParent->m_fX11SurfaceScaledBy : 1.0;
+    const double SCALE = m_windowParent.lock() && m_windowParent->m_isX11 ? 1.0 / m_windowParent->m_X11SurfaceScaledBy : 1.0;
 
-    for (auto const& n : m_pParent->m_vChildren) {
+    for (auto const& n : m_parent->m_children) {
         if (n.get() == this)
             continue;
 
         const auto COORDS = n->coordsGlobal();
-        g_pHyprRenderer->damageSurface(n->m_pWLSurface->resource(), COORDS.x, COORDS.y, SCALE);
+        g_pHyprRenderer->damageSurface(n->m_wlSurface->resource(), COORDS.x, COORDS.y, SCALE);
     }
 }
 
 void CSubsurface::recheckDamageForSubsurfaces() {
-    for (auto const& n : m_vChildren) {
+    for (auto const& n : m_children) {
         const auto COORDS = n->coordsGlobal();
-        g_pHyprRenderer->damageSurface(n->m_pWLSurface->resource(), COORDS.x, COORDS.y);
+        g_pHyprRenderer->damageSurface(n->m_wlSurface->resource(), COORDS.x, COORDS.y);
     }
 }
 
 void CSubsurface::onCommit() {
     // no damaging if it's not visible
-    if (!m_pWindowParent.expired() && (!m_pWindowParent->m_bIsMapped || !m_pWindowParent->m_pWorkspace->m_bVisible)) {
-        m_vLastSize = m_pWLSurface->resource()->current.size;
+    if (!m_windowParent.expired() && (!m_windowParent->m_isMapped || !m_windowParent->m_workspace->m_visible)) {
+        m_lastSize = m_wlSurface->resource()->m_current.size;
 
         static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
         if (*PLOGDAMAGE)
-            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowParent.lock());
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_windowParent.lock());
         return;
     }
 
     const auto COORDS = coordsGlobal();
 
-    g_pHyprRenderer->damageSurface(m_pWLSurface->resource(), COORDS.x, COORDS.y);
+    g_pHyprRenderer->damageSurface(m_wlSurface->resource(), COORDS.x, COORDS.y);
 
-    if (m_pPopupParent && !m_pPopupParent->inert() && m_pPopupParent->m_pWLSurface)
-        m_pPopupParent->recheckTree();
-    if (!m_pWindowParent.expired()) // I hate you firefox why are you doing this
-        m_pWindowParent->m_pPopupHead->recheckTree();
+    if (m_popupParent && !m_popupParent->inert() && m_popupParent->m_wlSurface)
+        m_popupParent->recheckTree();
+    if (!m_windowParent.expired()) // I hate you firefox why are you doing this
+        m_windowParent->m_popupHead->recheckTree();
 
     // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
     checkSiblingDamage();
 
-    if (m_vLastSize != m_pWLSurface->resource()->current.size) {
-        // TODO: fix this
-        // CBox box{COORDS, m_vLastSize};
-        // g_pHyprRenderer->damageBox(box);
-        // m_vLastSize = m_pWLSurface->resource()->current.size;
-        // box         = {COORDS, m_vLastSize};
-        // g_pHyprRenderer->damageBox(box);
-
-        CBox box;
-        if (m_pPopupParent && !m_pPopupParent->inert() && m_pPopupParent->m_pWLSurface)
-            box = m_pPopupParent->m_pWLSurface->getSurfaceBoxGlobal().value_or(CBox{});
-        else if (m_pWindowParent)
-            box = m_pWindowParent->getWindowMainSurfaceBox();
-
-        g_pHyprRenderer->damageBox(box);
+    if (m_lastSize != m_wlSurface->resource()->m_current.size || m_lastPosition != m_subsurface->m_position) {
+        damageLastArea();
+        m_lastSize     = m_wlSurface->resource()->m_current.size;
+        m_lastPosition = m_subsurface->m_position;
     }
 }
 
 void CSubsurface::onDestroy() {
     // destroy children
-    m_vChildren.clear();
+    m_children.clear();
 
-    m_bInert = true;
+    m_inert = true;
 
-    if (!m_pSubsurface)
+    if (!m_subsurface)
         return; // dummy node, nothing to do, it's the parent dying
 
     // kill ourselves
-    std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; });
+    std::erase_if(m_parent->m_children, [this](const auto& other) { return other.get() == this; });
 }
 
 void CSubsurface::onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface) {
     WP<CSubsurface> PSUBSURFACE;
 
-    if (!m_pWindowParent.expired())
-        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pWindowParent.lock()));
-    else if (m_pPopupParent)
-        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pPopupParent));
+    if (!m_windowParent.expired())
+        PSUBSURFACE = m_children.emplace_back(CSubsurface::create(pSubsurface, m_windowParent.lock()));
+    else if (m_popupParent)
+        PSUBSURFACE = m_children.emplace_back(CSubsurface::create(pSubsurface, m_popupParent));
 
-    PSUBSURFACE->m_pSelf = PSUBSURFACE;
+    PSUBSURFACE->m_self = PSUBSURFACE;
 
     ASSERT(PSUBSURFACE);
 
-    PSUBSURFACE->m_pParent = m_pSelf;
+    PSUBSURFACE->m_parent = m_self;
 }
 
 void CSubsurface::onMap() {
-    m_vLastSize = m_pWLSurface->resource()->current.size;
+    m_lastSize     = m_wlSurface->resource()->m_current.size;
+    m_lastPosition = m_subsurface->m_position;
 
     const auto COORDS = coordsGlobal();
-    CBox       box{COORDS, m_vLastSize};
+    CBox       box{COORDS, m_lastSize};
     box.expand(4);
     g_pHyprRenderer->damageBox(box);
 
-    if (!m_pWindowParent.expired())
-        m_pWindowParent->updateSurfaceScaleTransformDetails();
+    if (!m_windowParent.expired())
+        m_windowParent->updateSurfaceScaleTransformDetails();
 }
 
 void CSubsurface::onUnmap() {
-    const auto COORDS = coordsGlobal();
-    CBox       box{COORDS, m_vLastSize};
-    box.expand(4);
-    g_pHyprRenderer->damageBox(box);
+    damageLastArea();
 
-    if (m_pWLSurface->resource() == g_pCompositor->m_pLastFocus)
+    if (m_wlSurface->resource() == g_pCompositor->m_lastFocus)
         g_pInputManager->releaseAllMouseButtons();
 
     g_pInputManager->simulateMouseMovement();
@@ -187,42 +174,49 @@ void CSubsurface::onUnmap() {
     // TODO: should this remove children? Currently it won't, only on .destroy
 }
 
+void CSubsurface::damageLastArea() {
+    const auto COORDS = coordsGlobal() + m_lastPosition - m_subsurface->m_position;
+    CBox       box{COORDS, m_lastSize};
+    box.expand(4);
+    g_pHyprRenderer->damageBox(box);
+}
+
 Vector2D CSubsurface::coordsRelativeToParent() {
-    if (!m_pSubsurface)
+    if (!m_subsurface)
         return {};
-    return m_pSubsurface->posRelativeToParent();
+    return m_subsurface->posRelativeToParent();
 }
 
 Vector2D CSubsurface::coordsGlobal() {
     Vector2D coords = coordsRelativeToParent();
 
-    if (!m_pWindowParent.expired())
-        coords += m_pWindowParent->m_vRealPosition->value();
-    else if (m_pPopupParent)
-        coords += m_pPopupParent->coordsGlobal();
+    if (!m_windowParent.expired())
+        coords += m_windowParent->m_realPosition->value();
+    else if (m_popupParent)
+        coords += m_popupParent->coordsGlobal();
 
     return coords;
 }
 
 void CSubsurface::initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface) {
-    for (auto const& s : pSurface->subsurfaces) {
-        if (!s || s->surface->hlSurface /* already assigned */)
+    for (auto const& s : pSurface->m_subsurfaces) {
+        if (!s || s->m_surface->m_hlSurface /* already assigned */)
             continue;
         onNewSubsurface(s.lock());
     }
 }
 
 Vector2D CSubsurface::size() {
-    return m_pWLSurface->resource()->current.size;
+    return m_wlSurface->resource()->m_current.size;
 }
 
 bool CSubsurface::visible() {
-    if (!m_pWindowParent.expired())
-        return g_pHyprRenderer->shouldRenderWindow(m_pWindowParent.lock());
-    if (m_pPopupParent)
-        return m_pPopupParent->visible();
-    if (m_pParent)
-        return m_pParent->visible();
+    if (!m_windowParent.expired())
+        return g_pHyprRenderer->shouldRenderWindow(m_windowParent.lock());
+    if (m_popupParent)
+        return m_popupParent->visible();
+    if (m_parent)
+        return m_parent->visible();
 
     return false;
 }

src/desktop/Subsurface.hpp

@@ -34,7 +34,7 @@ class CSubsurface {
 
     void            recheckDamageForSubsurfaces();
 
-    WP<CSubsurface> m_pSelf;
+    WP<CSubsurface> m_self;
 
   private:
     CSubsurface() = default;
@@ -45,23 +45,25 @@ class CSubsurface {
         CHyprSignalListener mapSubsurface;
         CHyprSignalListener unmapSubsurface;
         CHyprSignalListener newSubsurface;
-    } listeners;
+    } m_listeners;
 
-    WP<CWLSubsurfaceResource> m_pSubsurface;
-    SP<CWLSurface>            m_pWLSurface;
-    Vector2D                  m_vLastSize = {};
+    WP<CWLSubsurfaceResource> m_subsurface;
+    SP<CWLSurface>            m_wlSurface;
+    Vector2D                  m_lastSize     = {};
+    Vector2D                  m_lastPosition = {};
 
     // if nullptr, means it's a dummy node
-    WP<CSubsurface>              m_pParent;
+    WP<CSubsurface>              m_parent;
 
-    PHLWINDOWREF                 m_pWindowParent;
-    WP<CPopup>                   m_pPopupParent;
+    PHLWINDOWREF                 m_windowParent;
+    WP<CPopup>                   m_popupParent;
 
-    std::vector<UP<CSubsurface>> m_vChildren;
+    std::vector<UP<CSubsurface>> m_children;
 
-    bool                         m_bInert = false;
+    bool                         m_inert = false;
 
     void                         initSignals();
     void                         initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
     void                         checkSiblingDamage();
+    void                         damageLastArea();
 };

src/desktop/WLSurface.cpp

@@ -6,37 +6,37 @@
 #include "../render/Renderer.hpp"
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface) {
-    m_pResource = pSurface;
+    m_resource = pSurface;
     init();
-    m_bInert = false;
+    m_inert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, PHLWINDOW pOwner) {
-    m_pWindowOwner = pOwner;
-    m_pResource    = pSurface;
+    m_windowOwner = pOwner;
+    m_resource    = pSurface;
     init();
-    m_bInert = false;
+    m_inert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, PHLLS pOwner) {
-    m_pLayerOwner = pOwner;
-    m_pResource   = pSurface;
+    m_layerOwner = pOwner;
+    m_resource   = pSurface;
     init();
-    m_bInert = false;
+    m_inert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, CSubsurface* pOwner) {
-    m_pSubsurfaceOwner = pOwner;
-    m_pResource        = pSurface;
+    m_subsurfaceOwner = pOwner;
+    m_resource        = pSurface;
     init();
-    m_bInert = false;
+    m_inert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, CPopup* pOwner) {
-    m_pPopupOwner = pOwner;
-    m_pResource   = pSurface;
+    m_popupOwner = pOwner;
+    m_resource   = pSurface;
     init();
-    m_bInert = false;
+    m_inert = false;
 }
 
 void CWLSurface::unassign() {
@@ -48,66 +48,67 @@ CWLSurface::~CWLSurface() {
 }
 
 bool CWLSurface::exists() const {
-    return m_pResource;
+    return m_resource;
 }
 
 SP<CWLSurfaceResource> CWLSurface::resource() const {
-    return m_pResource.lock();
+    return m_resource.lock();
 }
 
 bool CWLSurface::small() const {
-    if (!validMapped(m_pWindowOwner) || !exists())
+    if (!validMapped(m_windowOwner) || !exists())
         return false;
 
-    if (!m_pResource->current.texture)
+    if (!m_resource->m_current.texture)
         return false;
 
-    const auto O = m_pWindowOwner.lock();
+    const auto O = m_windowOwner.lock();
 
-    return O->m_vReportedSize.x > m_pResource->current.size.x + 1 || O->m_vReportedSize.y > m_pResource->current.size.y + 1;
+    return O->m_reportedSize.x > m_resource->m_current.size.x + 1 || O->m_reportedSize.y > m_resource->m_current.size.y + 1;
 }
 
 Vector2D CWLSurface::correctSmallVec() const {
-    if (!validMapped(m_pWindowOwner) || !exists() || !small() || m_bFillIgnoreSmall)
+    if (!validMapped(m_windowOwner) || !exists() || !small() || m_fillIgnoreSmall)
         return {};
 
     const auto SIZE = getViewporterCorrectedSize();
-    const auto O    = m_pWindowOwner.lock();
+    const auto O    = m_windowOwner.lock();
 
-    return Vector2D{(O->m_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize->value() / O->m_vReportedSize);
+    return Vector2D{(O->m_reportedSize.x - SIZE.x) / 2, (O->m_reportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_realSize->value() / O->m_reportedSize);
 }
 
 Vector2D CWLSurface::correctSmallVecBuf() const {
-    if (!exists() || !small() || m_bFillIgnoreSmall || !m_pResource->current.texture)
+    if (!exists() || !small() || m_fillIgnoreSmall || !m_resource->m_current.texture)
         return {};
 
     const auto SIZE = getViewporterCorrectedSize();
-    const auto BS   = m_pResource->current.bufferSize;
+    const auto BS   = m_resource->m_current.bufferSize;
 
     return Vector2D{(BS.x - SIZE.x) / 2, (BS.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY});
 }
 
 Vector2D CWLSurface::getViewporterCorrectedSize() const {
-    if (!exists() || !m_pResource->current.texture)
+    if (!exists() || !m_resource->m_current.texture)
         return {};
 
-    return m_pResource->current.viewport.hasDestination ? m_pResource->current.viewport.destination : m_pResource->current.bufferSize;
+    return m_resource->m_current.viewport.hasDestination ? m_resource->m_current.viewport.destination : m_resource->m_current.bufferSize;
 }
 
 CRegion CWLSurface::computeDamage() const {
-    if (!m_pResource->current.texture)
+    if (!m_resource->m_current.texture)
         return {};
 
-    CRegion damage = m_pResource->current.accumulateBufferDamage();
-    damage.transform(wlTransformToHyprutils(m_pResource->current.transform), m_pResource->current.bufferSize.x, m_pResource->current.bufferSize.y);
+    CRegion damage = m_resource->m_current.accumulateBufferDamage();
+    damage.transform(wlTransformToHyprutils(m_resource->m_current.transform), m_resource->m_current.bufferSize.x, m_resource->m_current.bufferSize.y);
 
-    const auto BUFSIZE    = m_pResource->current.bufferSize;
+    const auto BUFSIZE    = m_resource->m_current.bufferSize;
     const auto CORRECTVEC = correctSmallVecBuf();
 
-    if (m_pResource->current.viewport.hasSource)
-        damage.intersect(m_pResource->current.viewport.source);
+    if (m_resource->m_current.viewport.hasSource)
+        damage.intersect(m_resource->m_current.viewport.source);
 
-    const auto SCALEDSRCSIZE = m_pResource->current.viewport.hasSource ? m_pResource->current.viewport.source.size() * m_pResource->current.scale : m_pResource->current.bufferSize;
+    const auto SCALEDSRCSIZE =
+        m_resource->m_current.viewport.hasSource ? m_resource->m_current.viewport.source.size() * m_resource->m_current.scale : m_resource->m_current.bufferSize;
 
     damage.scale({BUFSIZE.x / SCALEDSRCSIZE.x, BUFSIZE.y / SCALEDSRCSIZE.y});
     damage.translate(CORRECTVEC);
@@ -115,120 +116,120 @@ CRegion CWLSurface::computeDamage() const {
     // go from buffer coords in the damage to hl logical
 
     const auto     BOX   = getSurfaceBoxGlobal();
-    const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_pResource->current.bufferSize :
-                                             Vector2D{1.0 / m_pResource->current.scale, 1.0 / m_pResource->current.scale /* Wrong... but we can't really do better */};
+    const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_resource->m_current.bufferSize :
+                                             Vector2D{1.0 / m_resource->m_current.scale, 1.0 / m_resource->m_current.scale /* Wrong... but we can't really do better */};
 
     damage.scale(SCALE);
 
-    if (m_pWindowOwner)
-        damage.scale(m_pWindowOwner->m_fX11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit
+    if (m_windowOwner)
+        damage.scale(m_windowOwner->m_X11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit
 
     return damage;
 }
 
 void CWLSurface::destroy() {
-    if (!m_pResource)
+    if (!m_resource)
         return;
 
-    events.destroy.emit();
+    m_events.destroy.emit();
 
-    m_pConstraint.reset();
+    m_constraint.reset();
 
-    listeners.destroy.reset();
-    m_pResource->hlSurface.reset();
-    m_pWindowOwner.reset();
-    m_pLayerOwner.reset();
-    m_pPopupOwner      = nullptr;
-    m_pSubsurfaceOwner = nullptr;
-    m_bInert           = true;
+    m_listeners.destroy.reset();
+    m_resource->m_hlSurface.reset();
+    m_windowOwner.reset();
+    m_layerOwner.reset();
+    m_popupOwner      = nullptr;
+    m_subsurfaceOwner = nullptr;
+    m_inert           = true;
 
-    if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf && g_pHyprRenderer->m_sLastCursorData.surf->get() == this)
-        g_pHyprRenderer->m_sLastCursorData.surf.reset();
+    if (g_pHyprRenderer && g_pHyprRenderer->m_lastCursorData.surf && g_pHyprRenderer->m_lastCursorData.surf->get() == this)
+        g_pHyprRenderer->m_lastCursorData.surf.reset();
 
-    m_pResource.reset();
+    m_resource.reset();
 
     Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this);
 }
 
 void CWLSurface::init() {
-    if (!m_pResource)
+    if (!m_resource)
         return;
 
-    RASSERT(!m_pResource->hlSurface, "Attempted to duplicate CWLSurface ownership!");
+    RASSERT(!m_resource->m_hlSurface, "Attempted to duplicate CWLSurface ownership!");
 
-    m_pResource->hlSurface = self.lock();
+    m_resource->m_hlSurface = m_self.lock();
 
-    listeners.destroy = m_pResource->events.destroy.registerListener([this](std::any d) { destroy(); });
+    m_listeners.destroy = m_resource->m_events.destroy.registerListener([this](std::any d) { destroy(); });
 
     Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
 }
 
 PHLWINDOW CWLSurface::getWindow() const {
-    return m_pWindowOwner.lock();
+    return m_windowOwner.lock();
 }
 
 PHLLS CWLSurface::getLayer() const {
-    return m_pLayerOwner.lock();
+    return m_layerOwner.lock();
 }
 
 CPopup* CWLSurface::getPopup() const {
-    return m_pPopupOwner;
+    return m_popupOwner;
 }
 
 CSubsurface* CWLSurface::getSubsurface() const {
-    return m_pSubsurfaceOwner;
+    return m_subsurfaceOwner;
 }
 
 bool CWLSurface::desktopComponent() const {
-    return !m_pLayerOwner.expired() || !m_pWindowOwner.expired() || m_pSubsurfaceOwner || m_pPopupOwner;
+    return !m_layerOwner.expired() || !m_windowOwner.expired() || m_subsurfaceOwner || m_popupOwner;
 }
 
 std::optional<CBox> CWLSurface::getSurfaceBoxGlobal() const {
     if (!desktopComponent())
         return {};
 
-    if (!m_pWindowOwner.expired())
-        return m_pWindowOwner->getWindowMainSurfaceBox();
-    if (!m_pLayerOwner.expired())
-        return m_pLayerOwner->geometry;
-    if (m_pPopupOwner)
-        return CBox{m_pPopupOwner->coordsGlobal(), m_pPopupOwner->size()};
-    if (m_pSubsurfaceOwner)
-        return CBox{m_pSubsurfaceOwner->coordsGlobal(), m_pSubsurfaceOwner->size()};
+    if (!m_windowOwner.expired())
+        return m_windowOwner->getWindowMainSurfaceBox();
+    if (!m_layerOwner.expired())
+        return m_layerOwner->m_geometry;
+    if (m_popupOwner)
+        return CBox{m_popupOwner->coordsGlobal(), m_popupOwner->size()};
+    if (m_subsurfaceOwner)
+        return CBox{m_subsurfaceOwner->coordsGlobal(), m_subsurfaceOwner->size()};
 
     return {};
 }
 
 void CWLSurface::appendConstraint(WP<CPointerConstraint> constraint) {
-    m_pConstraint = constraint;
+    m_constraint = constraint;
 }
 
 SP<CPointerConstraint> CWLSurface::constraint() const {
-    return m_pConstraint.lock();
+    return m_constraint.lock();
 }
 
 bool CWLSurface::visible() {
-    if (!m_pWindowOwner.expired())
-        return g_pHyprRenderer->shouldRenderWindow(m_pWindowOwner.lock());
-    if (!m_pLayerOwner.expired())
+    if (!m_windowOwner.expired())
+        return g_pHyprRenderer->shouldRenderWindow(m_windowOwner.lock());
+    if (!m_layerOwner.expired())
         return true;
-    if (m_pPopupOwner)
-        return m_pPopupOwner->visible();
-    if (m_pSubsurfaceOwner)
-        return m_pSubsurfaceOwner->visible();
+    if (m_popupOwner)
+        return m_popupOwner->visible();
+    if (m_subsurfaceOwner)
+        return m_subsurfaceOwner->visible();
     return true; // non-desktop, we don't know much.
 }
 
 SP<CWLSurface> CWLSurface::fromResource(SP<CWLSurfaceResource> pSurface) {
     if (!pSurface)
         return nullptr;
-    return pSurface->hlSurface.lock();
+    return pSurface->m_hlSurface.lock();
 }
 
 bool CWLSurface::keyboardFocusable() const {
-    if (m_pWindowOwner || m_pPopupOwner || m_pSubsurfaceOwner)
+    if (m_windowOwner || m_popupOwner || m_subsurfaceOwner)
         return true;
-    if (m_pLayerOwner && m_pLayerOwner->layerSurface)
-        return m_pLayerOwner->layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE;
+    if (m_layerOwner && m_layerOwner->m_layerSurface)
+        return m_layerOwner->m_layerSurface->m_current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE;
     return false;
 }

src/desktop/WLSurface.hpp

@@ -12,8 +12,8 @@ class CWLSurfaceResource;
 class CWLSurface {
   public:
     static SP<CWLSurface> create() {
-        auto p  = SP<CWLSurface>(new CWLSurface);
-        p->self = p;
+        auto p    = SP<CWLSurface>(new CWLSurface);
+        p->m_self = p;
         return p;
     }
     ~CWLSurface();
@@ -53,17 +53,17 @@ class CWLSurface {
     SP<CPointerConstraint> constraint() const;
 
     // allow stretching. Useful for plugins.
-    bool m_bFillIgnoreSmall = false;
+    bool m_fillIgnoreSmall = false;
 
     // track surface data and avoid dupes
-    float               m_fLastScale     = 0;
-    int                 m_iLastScale     = 0;
-    wl_output_transform m_eLastTransform = (wl_output_transform)-1;
+    float               m_lastScaleFloat = 0;
+    int                 m_lastScaleInt   = 0;
+    wl_output_transform m_lastTransform  = (wl_output_transform)-1;
 
     //
     CWLSurface& operator=(SP<CWLSurfaceResource> pSurface) {
         destroy();
-        m_pResource = pSurface;
+        m_resource = pSurface;
         init();
 
         return *this;
@@ -84,32 +84,32 @@ class CWLSurface {
     static SP<CWLSurface> fromResource(SP<CWLSurfaceResource> pSurface);
 
     // used by the alpha-modifier protocol
-    float m_fAlphaModifier = 1.F;
+    float m_alphaModifier = 1.F;
 
     // used by the hyprland-surface protocol
-    float   m_fOverallOpacity = 1.F;
+    float   m_overallOpacity = 1.F;
     CRegion m_visibleRegion;
 
     struct {
         CSignal destroy;
-    } events;
+    } m_events;
 
-    WP<CWLSurface> self;
+    WP<CWLSurface> m_self;
 
   private:
     CWLSurface() = default;
 
-    bool                   m_bInert = true;
+    bool                   m_inert = true;
 
-    WP<CWLSurfaceResource> m_pResource;
+    WP<CWLSurfaceResource> m_resource;
 
-    PHLWINDOWREF           m_pWindowOwner;
-    PHLLSREF               m_pLayerOwner;
-    CPopup*                m_pPopupOwner      = nullptr;
-    CSubsurface*           m_pSubsurfaceOwner = nullptr;
+    PHLWINDOWREF           m_windowOwner;
+    PHLLSREF               m_layerOwner;
+    CPopup*                m_popupOwner      = nullptr;
+    CSubsurface*           m_subsurfaceOwner = nullptr;
 
     //
-    WP<CPointerConstraint> m_pConstraint;
+    WP<CPointerConstraint> m_constraint;
 
     void                   destroy();
     void                   init();
@@ -117,7 +117,7 @@ class CWLSurface {
 
     struct {
         CHyprSignalListener destroy;
-    } listeners;
+    } m_listeners;
 
     friend class CPointerConstraint;
     friend class CXxColorManagerV4;

src/desktop/Window.hpp

@@ -6,8 +6,6 @@
 
 #include "../config/ConfigDataValues.hpp"
 #include "../helpers/AnimatedVariable.hpp"
-#include "../helpers/math/Math.hpp"
-#include "../helpers/signal/Signal.hpp"
 #include "../helpers/TagKeeper.hpp"
 #include "../macros.hpp"
 #include "../managers/XWaylandManager.hpp"
@@ -19,6 +17,7 @@
 #include "WLSurface.hpp"
 #include "Workspace.hpp"
 #include "WindowRule.hpp"
+#include "WindowOverridableVar.hpp"
 #include "../protocols/types/ContentType.hpp"
 
 class CXDGSurfaceResource;
@@ -44,13 +43,14 @@ enum eGroupRules : uint8_t {
 };
 
 enum eGetWindowProperties : uint8_t {
-    WINDOW_ONLY      = 0,
-    RESERVED_EXTENTS = 1 << 0,
-    INPUT_EXTENTS    = 1 << 1,
-    FULL_EXTENTS     = 1 << 2,
-    FLOATING_ONLY    = 1 << 3,
-    ALLOW_FLOATING   = 1 << 4,
-    USE_PROP_TILED   = 1 << 5,
+    WINDOW_ONLY              = 0,
+    RESERVED_EXTENTS         = 1 << 0,
+    INPUT_EXTENTS            = 1 << 1,
+    FULL_EXTENTS             = 1 << 2,
+    FLOATING_ONLY            = 1 << 3,
+    ALLOW_FLOATING           = 1 << 4,
+    USE_PROP_TILED           = 1 << 5,
+    SKIP_FULLSCREEN_PRIORITY = 1 << 6,
 };
 
 enum eSuppressEvents : uint8_t {
@@ -65,103 +65,21 @@ enum eSuppressEvents : uint8_t {
 class IWindowTransformer;
 
 struct SAlphaValue {
-    float m_fAlpha;
-    bool  m_bOverride;
+    float alpha;
+    bool  overridden;
 
-    float applyAlpha(float alpha) const {
-        if (m_bOverride)
-            return m_fAlpha;
+    float applyAlpha(float a) const {
+        if (overridden)
+            return alpha;
         else
-            return m_fAlpha * alpha;
+            return alpha * a;
     };
 };
 
-enum eOverridePriority : uint8_t {
-    PRIORITY_LAYOUT = 0,
-    PRIORITY_WORKSPACE_RULE,
-    PRIORITY_WINDOW_RULE,
-    PRIORITY_SET_PROP,
-};
-
-template <typename T>
-class CWindowOverridableVar {
-  public:
-    CWindowOverridableVar(T const& value, eOverridePriority priority) {
-        values[priority] = value;
-    }
-    CWindowOverridableVar(T const& value) : defaultValue{value} {}
-
-    CWindowOverridableVar()  = default;
-    ~CWindowOverridableVar() = default;
-
-    CWindowOverridableVar<T>& operator=(CWindowOverridableVar<T> const& other) {
-        // Self-assignment check
-        if (this == &other)
-            return *this;
-
-        for (auto const& value : other.values) {
-            values[value.first] = value.second;
-        }
-
-        return *this;
-    }
-
-    void unset(eOverridePriority priority) {
-        values.erase(priority);
-    }
-
-    bool hasValue() {
-        return !values.empty();
-    }
-
-    T value() {
-        if (!values.empty())
-            return std::prev(values.end())->second;
-        else
-            throw std::bad_optional_access();
-    }
-
-    T valueOr(T const& other) {
-        if (hasValue())
-            return value();
-        else
-            return other;
-    }
-
-    T valueOrDefault() {
-        return valueOr(defaultValue);
-    }
-
-    eOverridePriority getPriority() {
-        if (!values.empty())
-            return std::prev(values.end())->first;
-        else
-            throw std::bad_optional_access();
-    }
-
-    void matchOptional(std::optional<T> const& optValue, eOverridePriority priority) {
-        if (optValue.has_value())
-            values[priority] = optValue.value();
-        else
-            unset(priority);
-    }
-
-    operator std::optional<T>() {
-        if (hasValue())
-            return value();
-        else
-            return std::nullopt;
-    }
-
-  private:
-    std::map<eOverridePriority, T> values;
-    T                              defaultValue; // used for toggling, so required for bool
-};
-
 struct SWindowData {
-    CWindowOverridableVar<SAlphaValue>        alpha           = SAlphaValue{1.f, false};
-    CWindowOverridableVar<SAlphaValue>        alphaInactive   = SAlphaValue{1.f, false};
-    CWindowOverridableVar<SAlphaValue>        alphaFullscreen = SAlphaValue{1.f, false};
+    CWindowOverridableVar<SAlphaValue>        alpha           = SAlphaValue{.alpha = 1.f, .overridden = false};
+    CWindowOverridableVar<SAlphaValue>        alphaInactive   = SAlphaValue{.alpha = 1.f, .overridden = false};
+    CWindowOverridableVar<SAlphaValue>        alphaFullscreen = SAlphaValue{.alpha = 1.f, .overridden = false};
 
     CWindowOverridableVar<bool>               allowsInput        = false;
     CWindowOverridableVar<bool>               dimAround          = false;
@@ -184,13 +102,14 @@ struct SWindowData {
     CWindowOverridableVar<bool>               tearing            = false;
     CWindowOverridableVar<bool>               xray               = false;
     CWindowOverridableVar<bool>               renderUnfocused    = false;
+    CWindowOverridableVar<bool>               noFollowMouse      = false;
 
-    CWindowOverridableVar<int>                rounding;
-    CWindowOverridableVar<float>              roundingPower;
-    CWindowOverridableVar<int>                borderSize;
+    CWindowOverridableVar<Hyprlang::INT>      borderSize = {std::string("general:border_size"), Hyprlang::INT(0), std::nullopt};
+    CWindowOverridableVar<Hyprlang::INT>      rounding   = {std::string("decoration:rounding"), Hyprlang::INT(0), std::nullopt};
 
-    CWindowOverridableVar<float>              scrollMouse;
-    CWindowOverridableVar<float>              scrollTouchpad;
+    CWindowOverridableVar<Hyprlang::FLOAT>    roundingPower  = {std::string("decoration:rounding_power")};
+    CWindowOverridableVar<Hyprlang::FLOAT>    scrollMouse    = {std::string("input:scroll_factor")};
+    CWindowOverridableVar<Hyprlang::FLOAT>    scrollTouchpad = {std::string("input:touchpad:scroll_factor")};
 
     CWindowOverridableVar<std::string>        animationStyle;
     CWindowOverridableVar<Vector2D>           maxSize;
@@ -224,154 +143,151 @@ class CWindow {
   public:
     ~CWindow();
 
-    SP<CWLSurface> m_pWLSurface;
+    SP<CWLSurface> m_wlSurface;
 
     struct {
         CSignal destroy;
-    } events;
+    } m_events;
 
-    WP<CXDGSurfaceResource> m_pXDGSurface;
-    WP<CXWaylandSurface>    m_pXWaylandSurface;
+    WP<CXDGSurfaceResource> m_xdgSurface;
+    WP<CXWaylandSurface>    m_xwaylandSurface;
 
     // this is the position and size of the "bounding box"
-    Vector2D m_vPosition = Vector2D(0, 0);
-    Vector2D m_vSize     = Vector2D(0, 0);
+    Vector2D m_position = Vector2D(0, 0);
+    Vector2D m_size     = Vector2D(0, 0);
 
     // this is the real position and size used to draw the thing
-    PHLANIMVAR<Vector2D> m_vRealPosition;
-    PHLANIMVAR<Vector2D> m_vRealSize;
+    PHLANIMVAR<Vector2D> m_realPosition;
+    PHLANIMVAR<Vector2D> m_realSize;
 
     // for not spamming the protocols
-    Vector2D                                     m_vReportedPosition;
-    Vector2D                                     m_vReportedSize;
-    Vector2D                                     m_vPendingReportedSize;
-    std::optional<std::pair<uint32_t, Vector2D>> m_pPendingSizeAck;
-    std::vector<std::pair<uint32_t, Vector2D>>   m_vPendingSizeAcks;
+    Vector2D                                     m_reportedPosition;
+    Vector2D                                     m_reportedSize;
+    Vector2D                                     m_pendingReportedSize;
+    std::optional<std::pair<uint32_t, Vector2D>> m_pendingSizeAck;
+    std::vector<std::pair<uint32_t, Vector2D>>   m_pendingSizeAcks;
 
     // for restoring floating statuses
-    Vector2D m_vLastFloatingSize;
-    Vector2D m_vLastFloatingPosition;
+    Vector2D m_lastFloatingSize;
+    Vector2D m_lastFloatingPosition;
 
     // for floating window offset in workspace animations
-    Vector2D m_vFloatingOffset = Vector2D(0, 0);
+    Vector2D m_floatingOffset = Vector2D(0, 0);
 
     // this is used for pseudotiling
-    bool     m_bIsPseudotiled = false;
-    Vector2D m_vPseudoSize    = Vector2D(1280, 720);
+    bool     m_isPseudotiled = false;
+    Vector2D m_pseudoSize    = Vector2D(1280, 720);
 
     // for recovering relative cursor position
-    Vector2D         m_vRelativeCursorCoordsOnLastWarp = Vector2D(-1, -1);
+    Vector2D         m_relativeCursorCoordsOnLastWarp = Vector2D(-1, -1);
 
-    bool             m_bFirstMap        = false; // for layouts
-    bool             m_bIsFloating      = false;
-    bool             m_bDraggingTiled   = false; // for dragging around tiled windows
-    bool             m_bWasMaximized    = false;
-    SFullscreenState m_sFullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
-    std::string      m_szTitle          = "";
-    std::string      m_szClass          = "";
-    std::string      m_szInitialTitle   = "";
-    std::string      m_szInitialClass   = "";
-    PHLWORKSPACE     m_pWorkspace;
-    PHLMONITORREF    m_pMonitor;
+    bool             m_firstMap        = false; // for layouts
+    bool             m_isFloating      = false;
+    bool             m_draggingTiled   = false; // for dragging around tiled windows
+    SFullscreenState m_fullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
+    std::string      m_title           = "";
+    std::string      m_class           = "";
+    std::string      m_initialTitle    = "";
+    std::string      m_initialClass    = "";
+    PHLWORKSPACE     m_workspace;
+    PHLMONITORREF    m_monitor;
 
-    bool             m_bIsMapped = false;
+    bool             m_isMapped = false;
 
-    bool             m_bRequestsFloat = false;
+    bool             m_requestsFloat = false;
 
     // This is for fullscreen apps
-    bool m_bCreatedOverFullscreen = false;
+    bool m_createdOverFullscreen = false;
 
     // XWayland stuff
-    bool         m_bIsX11 = false;
-    PHLWINDOWREF m_pX11Parent;
-    bool         m_bX11DoesntWantBorders = false;
-    bool         m_bX11ShouldntFocus     = false;
-    float        m_fX11SurfaceScaledBy   = 1.f;
+    bool  m_isX11                = false;
+    bool  m_X11DoesntWantBorders = false;
+    bool  m_X11ShouldntFocus     = false;
+    float m_X11SurfaceScaledBy   = 1.f;
     //
 
     // For nofocus
-    bool m_bNoInitialFocus = false;
+    bool m_noInitialFocus = false;
 
     // Fullscreen and Maximize
-    bool      m_bWantsInitialFullscreen        = false;
-    MONITORID m_iWantsInitialFullscreenMonitor = MONITOR_INVALID;
+    bool      m_wantsInitialFullscreen        = false;
+    MONITORID m_wantsInitialFullscreenMonitor = MONITOR_INVALID;
 
-    // bitfield eSuppressEvents
-    uint64_t m_eSuppressedEvents = SUPPRESS_NONE;
+    // bitfield suppressEvents
+    uint64_t m_suppressedEvents = SUPPRESS_NONE;
 
     // desktop components
-    UP<CSubsurface> m_pSubsurfaceHead;
-    UP<CPopup>      m_pPopupHead;
+    UP<CSubsurface> m_subsurfaceHead;
+    UP<CPopup>      m_popupHead;
 
     // Animated border
-    CGradientValueData m_cRealBorderColor         = {0};
-    CGradientValueData m_cRealBorderColorPrevious = {0};
-    PHLANIMVAR<float>  m_fBorderFadeAnimationProgress;
-    PHLANIMVAR<float>  m_fBorderAngleAnimationProgress;
+    CGradientValueData m_realBorderColor         = {0};
+    CGradientValueData m_realBorderColorPrevious = {0};
+    PHLANIMVAR<float>  m_borderFadeAnimationProgress;
+    PHLANIMVAR<float>  m_borderAngleAnimationProgress;
 
     // Fade in-out
-    PHLANIMVAR<float> m_fAlpha;
-    bool              m_bFadingOut     = false;
-    bool              m_bReadyToDelete = false;
-    Vector2D          m_vOriginalClosedPos;  // these will be used for calculations later on in
-    Vector2D          m_vOriginalClosedSize; // drawing the closing animations
-    SBoxExtents       m_eOriginalClosedExtents;
-    bool              m_bAnimatingIn = false;
+    PHLANIMVAR<float> m_alpha;
+    bool              m_fadingOut     = false;
+    bool              m_readyToDelete = false;
+    Vector2D          m_originalClosedPos;  // these will be used for calculations later on in
+    Vector2D          m_originalClosedSize; // drawing the closing animations
+    SBoxExtents       m_originalClosedExtents;
+    bool              m_animatingIn = false;
 
     // For pinned (sticky) windows
-    bool m_bPinned = false;
+    bool m_pinned = false;
 
     // For preserving pinned state when fullscreening a pinned window
-    bool m_bPinFullscreened = false;
+    bool m_pinFullscreened = false;
 
     // urgency hint
-    bool m_bIsUrgent = false;
+    bool m_isUrgent = false;
 
     // for proper cycling. While cycling we can't just move the pointers, so we need to keep track of the last cycled window.
-    PHLWINDOWREF m_pLastCycledWindow;
+    PHLWINDOWREF m_lastCycledWindow;
 
     // Window decorations
     // TODO: make this a SP.
-    std::vector<UP<IHyprWindowDecoration>> m_dWindowDecorations;
-    std::vector<IHyprWindowDecoration*>    m_vDecosToRemove;
+    std::vector<UP<IHyprWindowDecoration>> m_windowDecorations;
+    std::vector<IHyprWindowDecoration*>    m_decosToRemove;
 
     // Special render data, rules, etc
-    SWindowData m_sWindowData;
+    SWindowData m_windowData;
 
     // Transformers
-    std::vector<UP<IWindowTransformer>> m_vTransformers;
+    std::vector<UP<IWindowTransformer>> m_transformers;
 
     // for alpha
-    PHLANIMVAR<float> m_fActiveInactiveAlpha;
-    PHLANIMVAR<float> m_fMovingFromWorkspaceAlpha;
+    PHLANIMVAR<float> m_activeInactiveAlpha;
+    PHLANIMVAR<float> m_movingFromWorkspaceAlpha;
 
     // animated shadow color
-    PHLANIMVAR<CHyprColor> m_cRealShadowColor;
+    PHLANIMVAR<CHyprColor> m_realShadowColor;
 
     // animated tint
-    PHLANIMVAR<float> m_fDimPercent;
+    PHLANIMVAR<float> m_dimPercent;
 
     // animate moving to an invisible workspace
-    int               m_iMonitorMovedFrom = -1; // -1 means not moving
-    PHLANIMVAR<float> m_fMovingToWorkspaceAlpha;
+    int               m_monitorMovedFrom = -1; // -1 means not moving
+    PHLANIMVAR<float> m_movingToWorkspaceAlpha;
 
     // swallowing
-    PHLWINDOWREF m_pSwallowed;
-    bool         m_bCurrentlySwallowed = false;
-    bool         m_bGroupSwallowed     = false;
+    PHLWINDOWREF m_swallowed;
+    bool         m_currentlySwallowed = false;
+    bool         m_groupSwallowed     = false;
 
     // focus stuff
-    bool m_bStayFocused = false;
+    bool m_stayFocused = false;
 
     // for toplevel monitor events
-    MONITORID m_iLastToplevelMonitorID = -1;
-    MONITORID m_iLastSurfaceMonitorID  = -1;
+    MONITORID m_lastSurfaceMonitorID = -1;
 
     // for idle inhibiting windows
-    eIdleInhibitMode m_eIdleInhibitMode = IDLEINHIBIT_NONE;
+    eIdleInhibitMode m_idleInhibitMode = IDLEINHIBIT_NONE;
 
     // initial token. Will be unregistered on workspace change or timeout of 2 minutes
-    std::string m_szInitialWorkspaceToken = "";
+    std::string m_initialWorkspaceToken = "";
 
     // for groups
     struct SGroupData {
@@ -379,13 +295,13 @@ class CWindow {
         bool         head   = false;
         bool         locked = false; // per group lock
         bool         deny   = false; // deny window from enter a group or made a group
-    } m_sGroupData;
-    uint16_t m_eGroupRules = GROUP_NONE;
+    } m_groupData;
+    uint16_t m_groupRules = GROUP_NONE;
 
-    bool     m_bTearingHint = false;
+    bool     m_tearingHint = false;
 
     // stores the currently matched window rules
-    std::vector<SP<CWindowRule>> m_vMatchedRules;
+    std::vector<SP<CWindowRule>> m_matchedRules;
 
     // window tags
     CTagKeeper m_tags;
@@ -393,10 +309,13 @@ class CWindow {
     // ANR
     PHLANIMVAR<float> m_notRespondingTint;
 
+    // For the noclosefor windowrule
+    Time::steady_tp m_closeableSince = Time::steadyNow();
+
     // For the list lookup
     bool operator==(const CWindow& rhs) const {
-        return m_pXDGSurface == rhs.m_pXDGSurface && m_pXWaylandSurface == rhs.m_pXWaylandSurface && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize &&
-            m_bFadingOut == rhs.m_bFadingOut;
+        return m_xdgSurface == rhs.m_xdgSurface && m_xwaylandSurface == rhs.m_xwaylandSurface && m_position == rhs.m_position && m_size == rhs.m_size &&
+            m_fadingOut == rhs.m_fadingOut;
     }
 
     // methods
@@ -486,9 +405,12 @@ class CWindow {
     void                       setContentType(NContentType::eContentType contentType);
     void                       deactivateGroupMembers();
     bool                       isNotResponding();
+    std::optional<std::string> xdgTag();
+    std::optional<std::string> xdgDescription();
+    PHLWINDOW                  parent();
 
     CBox                       getWindowMainSurfaceBox() const {
-        return {m_vRealPosition->value().x, m_vRealPosition->value().y, m_vRealSize->value().x, m_vRealSize->value().y};
+        return {m_realPosition->value().x, m_realPosition->value().y, m_realSize->value().x, m_realSize->value().y};
     }
 
     // listeners
@@ -498,7 +420,7 @@ class CWindow {
     std::unordered_map<std::string, std::string> getEnv();
 
     //
-    PHLWINDOWREF m_pSelf;
+    PHLWINDOWREF m_self;
 
     // make private once we move listeners to inside CWindow
     struct {
@@ -513,13 +435,13 @@ class CWindow {
         CHyprSignalListener updateState;
         CHyprSignalListener updateMetadata;
         CHyprSignalListener resourceChange;
-    } listeners;
+    } m_listeners;
 
   private:
     // For hidden windows and stuff
-    bool        m_bHidden        = false;
-    bool        m_bSuspended     = false;
-    WORKSPACEID m_iLastWorkspace = WORKSPACE_INVALID;
+    bool        m_hidden        = false;
+    bool        m_suspended     = false;
+    WORKSPACEID m_lastWorkspace = WORKSPACE_INVALID;
 };
 
 inline bool valid(PHLWINDOW w) {
@@ -533,48 +455,49 @@ inline bool valid(PHLWINDOWREF w) {
 inline bool validMapped(PHLWINDOW w) {
     if (!valid(w))
         return false;
-    return w->m_bIsMapped;
+    return w->m_isMapped;
 }
 
 inline bool validMapped(PHLWINDOWREF w) {
     if (!valid(w))
         return false;
-    return w->m_bIsMapped;
+    return w->m_isMapped;
 }
 
 namespace NWindowProperties {
     static const std::unordered_map<std::string, std::function<CWindowOverridableVar<bool>*(const PHLWINDOW&)>> boolWindowProperties = {
-        {"allowsinput", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.allowsInput; }},
-        {"dimaround", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.dimAround; }},
-        {"decorate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.decorate; }},
-        {"focusonactivate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.focusOnActivate; }},
-        {"keepaspectratio", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.keepAspectRatio; }},
-        {"nearestneighbor", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.nearestNeighbor; }},
-        {"noanim", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noAnim; }},
-        {"noblur", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noBlur; }},
-        {"noborder", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noBorder; }},
-        {"nodim", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noDim; }},
-        {"nofocus", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noFocus; }},
-        {"nomaxsize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noMaxSize; }},
-        {"norounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noRounding; }},
-        {"noshadow", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noShadow; }},
-        {"noshortcutsinhibit", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noShortcutsInhibit; }},
-        {"opaque", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.opaque; }},
-        {"forcergbx", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.RGBX; }},
-        {"syncfullscreen", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.syncFullscreen; }},
-        {"immediate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.tearing; }},
-        {"xray", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.xray; }},
+        {"allowsinput", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.allowsInput; }},
+        {"dimaround", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.dimAround; }},
+        {"decorate", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.decorate; }},
+        {"focusonactivate", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.focusOnActivate; }},
+        {"keepaspectratio", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.keepAspectRatio; }},
+        {"nearestneighbor", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.nearestNeighbor; }},
+        {"noanim", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noAnim; }},
+        {"noblur", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noBlur; }},
+        {"noborder", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noBorder; }},
+        {"nodim", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noDim; }},
+        {"nofocus", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noFocus; }},
+        {"nomaxsize", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noMaxSize; }},
+        {"norounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noRounding; }},
+        {"noshadow", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noShadow; }},
+        {"noshortcutsinhibit", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noShortcutsInhibit; }},
+        {"opaque", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.opaque; }},
+        {"forcergbx", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.RGBX; }},
+        {"syncfullscreen", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.syncFullscreen; }},
+        {"immediate", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.tearing; }},
+        {"xray", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.xray; }},
+        {"nofollowmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noFollowMouse; }},
     };
 
-    const std::unordered_map<std::string, std::function<CWindowOverridableVar<int>*(const PHLWINDOW&)>> intWindowProperties = {
-        {"rounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.rounding; }},
-        {"bordersize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.borderSize; }},
+    const std::unordered_map<std::string, std::function<CWindowOverridableVar<Hyprlang::INT>*(const PHLWINDOW&)>> intWindowProperties = {
+        {"rounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.rounding; }},
+        {"bordersize", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.borderSize; }},
     };
 
-    const std::unordered_map<std::string, std::function<CWindowOverridableVar<float>*(PHLWINDOW)>> floatWindowProperties = {
-        {"roundingpower", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.roundingPower; }},
-        {"scrollmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.scrollMouse; }},
-        {"scrolltouchpad", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.scrollTouchpad; }},
+    const std::unordered_map<std::string, std::function<CWindowOverridableVar<Hyprlang::FLOAT>*(PHLWINDOW)>> floatWindowProperties = {
+        {"roundingpower", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.roundingPower; }},
+        {"scrollmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.scrollMouse; }},
+        {"scrolltouchpad", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.scrollTouchpad; }},
     };
 };
 
@@ -608,13 +531,13 @@ struct std::formatter<PHLWINDOW, CharT> : std::formatter<CharT> {
             return std::format_to(out, "[Window nullptr]");
 
         std::format_to(out, "[");
-        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w.get(), w->m_szTitle);
+        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w.get(), w->m_title);
         if (formatWorkspace)
-            std::format_to(out, ", workspace: {}", w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID);
+            std::format_to(out, ", workspace: {}", w->m_workspace ? w->workspaceID() : WORKSPACE_INVALID);
         if (formatMonitor)
             std::format_to(out, ", monitor: {}", w->monitorID());
         if (formatClass)
-            std::format_to(out, ", class: {}", w->m_szClass);
+            std::format_to(out, ", class: {}", w->m_class);
         return std::format_to(out, "]");
     }
 };

src/desktop/WindowOverridableVar.hpp

@@ -0,0 +1,132 @@
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+#include <any>
+#include "../config/ConfigValue.hpp"
+
+enum eOverridePriority : uint8_t {
+    PRIORITY_LAYOUT = 0,
+    PRIORITY_WORKSPACE_RULE,
+    PRIORITY_WINDOW_RULE,
+    PRIORITY_SET_PROP,
+};
+
+template <typename T>
+T clampOptional(T const& value, std::optional<T> const& min, std::optional<T> const& max) {
+    return std::clamp(value, min.value_or(std::numeric_limits<T>::min()), max.value_or(std::numeric_limits<T>::max()));
+}
+
+template <typename T, bool Extended = std::is_same_v<T, bool> || std::is_same_v<T, Hyprlang::INT> || std::is_same_v<T, Hyprlang::FLOAT>>
+class CWindowOverridableVar {
+  public:
+    CWindowOverridableVar(T const& value, eOverridePriority priority) {
+        m_values[priority] = value;
+    }
+
+    CWindowOverridableVar(T const& value) : m_defaultValue{value} {}
+    CWindowOverridableVar(T const& value, std::optional<T> const& min, std::optional<T> const& max = std::nullopt) : m_defaultValue{value}, m_minValue{min}, m_maxValue{max} {}
+    CWindowOverridableVar(std::string const& value)
+        requires(Extended && !std::is_same_v<T, bool>)
+        : m_configValue(SP<CConfigValue<T>>(new CConfigValue<T>(value))) {}
+    CWindowOverridableVar(std::string const& value, std::optional<T> const& min, std::optional<T> const& max = std::nullopt)
+        requires(Extended && !std::is_same_v<T, bool>)
+        : m_minValue(min), m_maxValue(max), m_configValue(SP<CConfigValue<T>>(new CConfigValue<T>(value))) {}
+
+    CWindowOverridableVar()  = default;
+    ~CWindowOverridableVar() = default;
+
+    CWindowOverridableVar& operator=(CWindowOverridableVar<T> const& other) {
+        // Self-assignment check
+        if (this == &other)
+            return *this;
+
+        for (auto const& value : other.m_values) {
+            if constexpr (Extended && !std::is_same_v<T, bool>)
+                m_values[value.first] = clampOptional(value.second, m_minValue, m_maxValue);
+            else
+                m_values[value.first] = value.second;
+        }
+
+        return *this;
+    }
+
+    void unset(eOverridePriority priority) {
+        m_values.erase(priority);
+    }
+
+    bool hasValue() {
+        return !m_values.empty();
+    }
+
+    T value() {
+        if (!m_values.empty())
+            return std::prev(m_values.end())->second;
+        else
+            throw std::bad_optional_access();
+    }
+
+    T valueOr(T const& other) {
+        if (hasValue())
+            return value();
+        else
+            return other;
+    }
+
+    T valueOrDefault()
+        requires(Extended && !std::is_same_v<T, bool>)
+    {
+        if (hasValue())
+            return value();
+        else if (m_defaultValue.has_value())
+            return m_defaultValue.value();
+        else
+            return **std::any_cast<SP<CConfigValue<T>>>(m_configValue);
+    }
+
+    T valueOrDefault()
+        requires(!Extended || std::is_same_v<T, bool>)
+    {
+        if (hasValue())
+            return value();
+        else if (!m_defaultValue.has_value())
+            throw std::bad_optional_access();
+        else
+            return m_defaultValue.value();
+    }
+
+    eOverridePriority getPriority() {
+        if (!m_values.empty())
+            return std::prev(m_values.end())->first;
+        else
+            throw std::bad_optional_access();
+    }
+
+    void increment(T const& other, eOverridePriority priority) {
+        if constexpr (std::is_same_v<T, bool>)
+            m_values[priority] = valueOr(false) ^ other;
+        else
+            m_values[priority] = clampOptional(valueOrDefault() + other, m_minValue, m_maxValue);
+    }
+
+    void matchOptional(std::optional<T> const& optValue, eOverridePriority priority) {
+        if (optValue.has_value())
+            m_values[priority] = optValue.value();
+        else
+            unset(priority);
+    }
+
+    operator std::optional<T>() {
+        if (hasValue())
+            return value();
+        else
+            return std::nullopt;
+    }
+
+  private:
+    std::map<eOverridePriority, T> m_values;
+    std::optional<T>               m_defaultValue; // used for toggling, so required for bool
+    std::optional<T>               m_minValue;
+    std::optional<T>               m_maxValue;
+    std::any                       m_configValue; // only there for select variables
+};

src/desktop/WindowRule.cpp

@@ -8,89 +8,90 @@ static const auto RULES = std::unordered_set<std::string>{
     "float", "fullscreen", "maximize", "noinitialfocus", "pin", "stayfocused", "tile", "renderunfocused", "persistentsize",
 };
 static const auto RULES_PREFIX = std::unordered_set<std::string>{
-    "animation", "bordercolor",   "bordersize", "center",    "content", "fullscreenstate", "group",    "idleinhibit",   "maxsize",     "minsize",
-    "monitor",   "move",          "opacity",    "plugin:",   "prop",    "pseudo",          "rounding", "roundingpower", "scrollmouse", "scrolltouchpad",
-    "size",      "suppressevent", "tag",        "workspace", "xray",
+    "animation",     "bordercolor", "bordersize", "center",  "content", "fullscreenstate", "group",    "idleinhibit",   "maxsize",     "minsize",        "monitor",
+    "move",          "noclosefor",  "opacity",    "plugin:", "prop",    "pseudo",          "rounding", "roundingpower", "scrollmouse", "scrolltouchpad", "size",
+    "suppressevent", "tag",         "workspace",  "xray",
 };
 
-CWindowRule::CWindowRule(const std::string& rule, const std::string& value, bool isV2, bool isExecRule) : szValue(value), szRule(rule), v2(isV2), execRule(isExecRule) {
+CWindowRule::CWindowRule(const std::string& rule, const std::string& value, bool isV2, bool isExecRule) : m_value(value), m_rule(rule), m_v2(isV2), m_execRule(isExecRule) {
     const auto VALS  = CVarList(rule, 2, ' ');
-    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule](auto prefix) { return rule.starts_with(prefix); }) ||
-        (NWindowProperties::boolWindowProperties.find(VALS[0]) != NWindowProperties::boolWindowProperties.end()) ||
-        (NWindowProperties::intWindowProperties.find(VALS[0]) != NWindowProperties::intWindowProperties.end()) ||
-        (NWindowProperties::floatWindowProperties.find(VALS[0]) != NWindowProperties::floatWindowProperties.end());
+    const bool VALID = RULES.contains(rule) || std::ranges::any_of(RULES_PREFIX, [&rule](auto prefix) { return rule.starts_with(prefix); }) ||
+        (NWindowProperties::boolWindowProperties.contains(VALS[0])) || (NWindowProperties::intWindowProperties.contains(VALS[0])) ||
+        (NWindowProperties::floatWindowProperties.contains(VALS[0]));
 
     if (!VALID)
         return;
 
     if (rule == "float")
-        ruleType = RULE_FLOAT;
+        m_ruleType = RULE_FLOAT;
     else if (rule == "fullscreen")
-        ruleType = RULE_FULLSCREEN;
+        m_ruleType = RULE_FULLSCREEN;
     else if (rule == "maximize")
-        ruleType = RULE_MAXIMIZE;
+        m_ruleType = RULE_MAXIMIZE;
     else if (rule == "noinitialfocus")
-        ruleType = RULE_NOINITIALFOCUS;
+        m_ruleType = RULE_NOINITIALFOCUS;
     else if (rule == "pin")
-        ruleType = RULE_PIN;
+        m_ruleType = RULE_PIN;
     else if (rule == "stayfocused")
-        ruleType = RULE_STAYFOCUSED;
+        m_ruleType = RULE_STAYFOCUSED;
     else if (rule == "tile")
-        ruleType = RULE_TILE;
+        m_ruleType = RULE_TILE;
     else if (rule == "renderunfocused")
-        ruleType = RULE_RENDERUNFOCUSED;
+        m_ruleType = RULE_RENDERUNFOCUSED;
     else if (rule == "persistentsize")
-        ruleType = RULE_PERSISTENTSIZE;
+        m_ruleType = RULE_PERSISTENTSIZE;
     else if (rule.starts_with("animation"))
-        ruleType = RULE_ANIMATION;
+        m_ruleType = RULE_ANIMATION;
     else if (rule.starts_with("bordercolor"))
-        ruleType = RULE_BORDERCOLOR;
+        m_ruleType = RULE_BORDERCOLOR;
     else if (rule.starts_with("center"))
-        ruleType = RULE_CENTER;
+        m_ruleType = RULE_CENTER;
     else if (rule.starts_with("fullscreenstate"))
-        ruleType = RULE_FULLSCREENSTATE;
+        m_ruleType = RULE_FULLSCREENSTATE;
     else if (rule.starts_with("group"))
-        ruleType = RULE_GROUP;
+        m_ruleType = RULE_GROUP;
     else if (rule.starts_with("idleinhibit"))
-        ruleType = RULE_IDLEINHIBIT;
+        m_ruleType = RULE_IDLEINHIBIT;
     else if (rule.starts_with("maxsize"))
-        ruleType = RULE_MAXSIZE;
+        m_ruleType = RULE_MAXSIZE;
     else if (rule.starts_with("minsize"))
-        ruleType = RULE_MINSIZE;
+        m_ruleType = RULE_MINSIZE;
     else if (rule.starts_with("monitor"))
-        ruleType = RULE_MONITOR;
+        m_ruleType = RULE_MONITOR;
     else if (rule.starts_with("move"))
-        ruleType = RULE_MOVE;
+        m_ruleType = RULE_MOVE;
     else if (rule.starts_with("opacity"))
-        ruleType = RULE_OPACITY;
+        m_ruleType = RULE_OPACITY;
     else if (rule.starts_with("plugin:"))
-        ruleType = RULE_PLUGIN;
+        m_ruleType = RULE_PLUGIN;
     else if (rule.starts_with("pseudo"))
-        ruleType = RULE_PSEUDO;
+        m_ruleType = RULE_PSEUDO;
     else if (rule.starts_with("size"))
-        ruleType = RULE_SIZE;
+        m_ruleType = RULE_SIZE;
     else if (rule.starts_with("suppressevent"))
-        ruleType = RULE_SUPPRESSEVENT;
+        m_ruleType = RULE_SUPPRESSEVENT;
     else if (rule.starts_with("tag"))
-        ruleType = RULE_TAG;
+        m_ruleType = RULE_TAG;
     else if (rule.starts_with("workspace"))
-        ruleType = RULE_WORKSPACE;
+        m_ruleType = RULE_WORKSPACE;
     else if (rule.starts_with("prop"))
-        ruleType = RULE_PROP;
+        m_ruleType = RULE_PROP;
     else if (rule.starts_with("content"))
-        ruleType = RULE_CONTENT;
+        m_ruleType = RULE_CONTENT;
+    else if (rule.starts_with("noclosefor"))
+        m_ruleType = RULE_NOCLOSEFOR;
     else {
         // check if this is a prop.
         const CVarList VARS(rule, 0, 's', true);
-        if (NWindowProperties::intWindowProperties.find(VARS[0]) != NWindowProperties::intWindowProperties.end() ||
-            NWindowProperties::boolWindowProperties.find(VARS[0]) != NWindowProperties::boolWindowProperties.end() ||
-            NWindowProperties::floatWindowProperties.find(VARS[0]) != NWindowProperties::floatWindowProperties.end()) {
-            *const_cast<std::string*>(&szRule) = "prop " + rule;
-            ruleType                           = RULE_PROP;
-            Debug::log(LOG, "CWindowRule: direct prop rule found, rewritten {} -> {}", rule, szRule);
+        const bool     ISPROP = NWindowProperties::intWindowProperties.contains(VARS[0]) || NWindowProperties::boolWindowProperties.contains(VARS[0]) ||
+            NWindowProperties::floatWindowProperties.contains(VARS[0]);
+        if (ISPROP) {
+            *const_cast<std::string*>(&m_rule) = "prop " + rule;
+            m_ruleType                         = RULE_PROP;
+            Debug::log(LOG, "CWindowRule: direct prop rule found, rewritten {} -> {}", rule, m_rule);
         } else {
             Debug::log(ERR, "CWindowRule: didn't match a rule that was found valid?!");
-            ruleType = RULE_INVALID;
+            m_ruleType = RULE_INVALID;
         }
     }
 }

src/desktop/WindowRule.hpp

@@ -38,34 +38,36 @@ class CWindowRule {
         RULE_PROP,
         RULE_CONTENT,
         RULE_PERSISTENTSIZE,
+        RULE_NOCLOSEFOR,
     };
 
-    eRuleType         ruleType = RULE_INVALID;
+    eRuleType         m_ruleType = RULE_INVALID;
 
-    const std::string szValue;
-    const std::string szRule;
-    const bool        v2       = false;
-    const bool        execRule = false;
+    const std::string m_value;
+    const std::string m_rule;
+    const bool        m_v2       = false;
+    const bool        m_execRule = false;
 
-    std::string       szTitle;
-    std::string       szClass;
-    std::string       szInitialTitle;
-    std::string       szInitialClass;
-    std::string       szTag;
-    int               bX11              = -1; // -1 means "ANY"
-    int               bFloating         = -1;
-    int               bFullscreen       = -1;
-    int               bPinned           = -1;
-    int               bFocus            = -1;
-    std::string       szFullscreenState = ""; // empty means any
-    std::string       szOnWorkspace     = ""; // empty means any
-    std::string       szWorkspace       = ""; // empty means any
-    std::string       szContentType     = ""; // empty means any
+    std::string       m_title;
+    std::string       m_class;
+    std::string       m_initialTitle;
+    std::string       m_initialClass;
+    std::string       m_tag;
+    int               m_X11             = -1; // -1 means "ANY"
+    int               m_floating        = -1;
+    int               m_fullscreen      = -1;
+    int               m_pinned          = -1;
+    int               m_focus           = -1;
+    std::string       m_fullscreenState = ""; // empty means any
+    std::string       m_onWorkspace     = ""; // empty means any
+    std::string       m_workspace       = ""; // empty means any
+    std::string       m_contentType     = ""; // empty means any
+    std::string       m_xdgTag          = ""; // empty means any
 
     // precompiled regexes
-    CRuleRegexContainer rTitle;
-    CRuleRegexContainer rClass;
-    CRuleRegexContainer rInitialTitle;
-    CRuleRegexContainer rInitialClass;
-    CRuleRegexContainer rV1Regex;
+    CRuleRegexContainer m_titleRegex;
+    CRuleRegexContainer m_classRegex;
+    CRuleRegexContainer m_initialTitleRegex;
+    CRuleRegexContainer m_initialClassRegex;
+    CRuleRegexContainer m_v1Regex;
 };

src/desktop/Workspace.cpp

@@ -17,76 +17,76 @@ PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string
 }
 
 CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) :
-    m_iID(id), m_szName(name), m_pMonitor(monitor), m_bIsSpecialWorkspace(special), m_bWasCreatedEmpty(isEmpty) {
+    m_id(id), m_name(name), m_monitor(monitor), m_isSpecialWorkspace(special), m_wasCreatedEmpty(isEmpty) {
     ;
 }
 
 void CWorkspace::init(PHLWORKSPACE self) {
-    m_pSelf = self;
+    m_self = self;
 
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_vRenderOffset,
-                                         g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(1.f, m_fAlpha, g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_renderOffset, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"),
+                                         self, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, m_alpha, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
                                          AVARDAMAGE_ENTIRE);
 
     const auto RULEFORTHIS = g_pConfigManager->getWorkspaceRuleFor(self);
     if (RULEFORTHIS.defaultName.has_value())
-        m_szName = RULEFORTHIS.defaultName.value();
+        m_name = RULEFORTHIS.defaultName.value();
 
-    m_pFocusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
+    m_focusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
         const auto PWINDOW = std::any_cast<PHLWINDOW>(param);
 
-        if (PWINDOW == m_pLastFocusedWindow.lock())
-            m_pLastFocusedWindow.reset();
+        if (PWINDOW == m_lastFocusedWindow.lock())
+            m_lastFocusedWindow.reset();
     });
 
-    m_bInert = false;
+    m_inert = false;
 
     const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(self);
-    m_bPersistent            = WORKSPACERULE.isPersistent;
+    m_persistent             = WORKSPACERULE.isPersistent;
 
-    if (self->m_bWasCreatedEmpty)
+    if (self->m_wasCreatedEmpty)
         if (auto cmd = WORKSPACERULE.onCreatedEmptyRunCmd)
-            g_pKeybindManager->spawnWithRules(*cmd, self);
+            CKeybindManager::spawnWithRules(*cmd, self);
 
-    g_pEventManager->postEvent({"createworkspace", m_szName});
-    g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_iID, m_szName)});
+    g_pEventManager->postEvent({.event = "createworkspace", .data = m_name});
+    g_pEventManager->postEvent({.event = "createworkspacev2", .data = std::format("{},{}", m_id, m_name)});
     EMIT_HOOK_EVENT("createWorkspace", this);
 }
 
 SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const {
-    return m_sPrevWorkspace;
+    return m_prevWorkspace;
 }
 
 CWorkspace::~CWorkspace() {
-    Debug::log(LOG, "Destroying workspace ID {}", m_iID);
+    Debug::log(LOG, "Destroying workspace ID {}", m_id);
 
     // check if g_pHookSystem and g_pEventManager exist, they might be destroyed as in when the compositor is closing.
     if (g_pHookSystem)
-        g_pHookSystem->unhook(m_pFocusedWindowHook);
+        g_pHookSystem->unhook(m_focusedWindowHook);
 
     if (g_pEventManager) {
-        g_pEventManager->postEvent({"destroyworkspace", m_szName});
-        g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_iID, m_szName)});
+        g_pEventManager->postEvent({.event = "destroyworkspace", .data = m_name});
+        g_pEventManager->postEvent({.event = "destroyworkspacev2", .data = std::format("{},{}", m_id, m_name)});
         EMIT_HOOK_EVENT("destroyWorkspace", this);
     }
 }
 
 void CWorkspace::startAnim(bool in, bool left, bool instant) {
     if (!instant) {
-        const std::string ANIMNAME = std::format("{}{}", m_bIsSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
+        const std::string ANIMNAME = std::format("{}{}", m_isSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
 
-        m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
-        m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_renderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
     }
 
-    const auto  ANIMSTYLE     = m_fAlpha->getStyle();
+    const auto  ANIMSTYLE     = m_alpha->getStyle();
     static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
 
     // set floating windows offset callbacks
-    m_vRenderOffset->setUpdateCallback([&](auto) {
-        for (auto const& w : g_pCompositor->m_vWindows) {
-            if (!validMapped(w) || w->workspaceID() != m_iID)
+    m_renderOffset->setUpdateCallback([&](auto) {
+        for (auto const& w : g_pCompositor->m_windows) {
+            if (!validMapped(w) || w->workspaceID() != m_id)
                 continue;
 
             w->onWorkspaceAnimUpdate();
@@ -94,7 +94,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     });
 
     if (ANIMSTYLE.starts_with("slidefade")) {
-        const auto PMONITOR = m_pMonitor.lock();
+        const auto PMONITOR = m_monitor.lock();
         float      movePerc = 100.f;
 
         if (ANIMSTYLE.find('%') != std::string::npos) {
@@ -104,84 +104,84 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
             } catch (std::exception& e) { Debug::log(ERR, "Error in startAnim: invalid percentage"); }
         }
 
-        m_fAlpha->setValueAndWarp(1.f);
-        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
+        m_alpha->setValueAndWarp(1.f);
+        m_renderOffset->setValueAndWarp(Vector2D(0, 0));
 
         if (ANIMSTYLE.starts_with("slidefadevert")) {
             if (in) {
-                m_fAlpha->setValueAndWarp(0.f);
-                m_vRenderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
-                *m_fAlpha        = 1.f;
-                *m_vRenderOffset = Vector2D(0, 0);
+                m_alpha->setValueAndWarp(0.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_fAlpha->setValueAndWarp(1.f);
-                *m_fAlpha        = 0.f;
-                *m_vRenderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
+                m_alpha->setValueAndWarp(1.f);
+                *m_alpha        = 0.f;
+                *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->m_size.y : PMONITOR->m_size.y) * (movePerc / 100.f));
             }
         } else {
             if (in) {
-                m_fAlpha->setValueAndWarp(0.f);
-                m_vRenderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0));
-                *m_fAlpha        = 1.f;
-                *m_vRenderOffset = Vector2D(0, 0);
+                m_alpha->setValueAndWarp(0.f);
+                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_fAlpha->setValueAndWarp(1.f);
-                *m_fAlpha        = 0.f;
-                *m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0);
+                m_alpha->setValueAndWarp(1.f);
+                *m_alpha        = 0.f;
+                *m_renderOffset = Vector2D((left ? -PMONITOR->m_size.x : PMONITOR->m_size.x) * (movePerc / 100.f), 0.0);
             }
         }
     } else if (ANIMSTYLE == "fade") {
-        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
+        m_renderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
 
         if (in) {
-            m_fAlpha->setValueAndWarp(0.f);
-            *m_fAlpha = 1.f;
+            m_alpha->setValueAndWarp(0.f);
+            *m_alpha = 1.f;
         } else {
-            m_fAlpha->setValueAndWarp(1.f);
-            *m_fAlpha = 0.f;
+            m_alpha->setValueAndWarp(1.f);
+            *m_alpha = 0.f;
         }
     } else if (ANIMSTYLE == "slidevert") {
         // fallback is slide
-        const auto PMONITOR  = m_pMonitor.lock();
-        const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
+        const auto PMONITOR  = m_monitor.lock();
+        const auto YDISTANCE = PMONITOR->m_size.y + *PWORKSPACEGAP;
 
-        m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
-            m_vRenderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
-            *m_vRenderOffset = Vector2D(0, 0);
+            m_renderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
+            *m_renderOffset = Vector2D(0, 0);
         } else {
-            *m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
+            *m_renderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
         }
     } else {
         // fallback is slide
-        const auto PMONITOR  = m_pMonitor.lock();
-        const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
+        const auto PMONITOR  = m_monitor.lock();
+        const auto XDISTANCE = PMONITOR->m_size.x + *PWORKSPACEGAP;
 
-        m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
-            m_vRenderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
-            *m_vRenderOffset = Vector2D(0, 0);
+            m_renderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
+            *m_renderOffset = Vector2D(0, 0);
         } else {
-            *m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
+            *m_renderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
         }
     }
 
-    if (m_bIsSpecialWorkspace) {
+    if (m_isSpecialWorkspace) {
         // required for open/close animations
         if (in) {
-            m_fAlpha->setValueAndWarp(0.f);
-            *m_fAlpha = 1.f;
+            m_alpha->setValueAndWarp(0.f);
+            *m_alpha = 1.f;
         } else {
-            m_fAlpha->setValueAndWarp(1.f);
-            *m_fAlpha = 0.f;
+            m_alpha->setValueAndWarp(1.f);
+            *m_alpha = 0.f;
         }
     }
 
     if (instant) {
-        m_vRenderOffset->warp();
-        m_fAlpha->warp();
+        m_renderOffset->warp();
+        m_alpha->warp();
     }
 }
 
@@ -194,39 +194,39 @@ void CWorkspace::moveToMonitor(const MONITORID& id) {
 }
 
 PHLWINDOW CWorkspace::getLastFocusedWindow() {
-    if (!validMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow->workspaceID() != m_iID)
+    if (!validMapped(m_lastFocusedWindow) || m_lastFocusedWindow->workspaceID() != m_id)
         return nullptr;
 
-    return m_pLastFocusedWindow.lock();
+    return m_lastFocusedWindow.lock();
 }
 
 void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
     if (!prev) {
-        m_sPrevWorkspace.id   = -1;
-        m_sPrevWorkspace.name = "";
+        m_prevWorkspace.id   = -1;
+        m_prevWorkspace.name = "";
         return;
     }
 
-    if (prev->m_iID == m_iID) {
+    if (prev->m_id == m_id) {
         Debug::log(LOG, "Tried to set prev workspace to the same as current one");
         return;
     }
 
-    m_sPrevWorkspace.id   = prev->m_iID;
-    m_sPrevWorkspace.name = prev->m_szName;
+    m_prevWorkspace.id   = prev->m_id;
+    m_prevWorkspace.name = prev->m_name;
 
-    prev->m_pMonitor->addPrevWorkspaceID(prev->m_iID);
+    prev->m_monitor->addPrevWorkspaceID(prev->m_id);
 }
 
 std::string CWorkspace::getConfigName() {
-    if (m_bIsSpecialWorkspace) {
-        return m_szName;
+    if (m_isSpecialWorkspace) {
+        return m_name;
     }
 
-    if (m_iID > 0)
-        return std::to_string(m_iID);
+    if (m_id > 0)
+        return std::to_string(m_id);
 
-    return "name:" + m_szName;
+    return "name:" + m_name;
 }
 
 bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
@@ -241,12 +241,12 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
         if (wsid == WORKSPACE_INVALID)
             return false;
 
-        return wsid == m_iID;
+        return wsid == m_id;
 
     } else if (selector.starts_with("name:")) {
-        return m_szName == selector.substr(5);
+        return m_name == selector.substr(5);
     } else if (selector.starts_with("special")) {
-        return m_szName == selector;
+        return m_name == selector;
     } else {
         // parse selector
 
@@ -306,7 +306,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                     return false;
                 }
 
-                if (std::clamp(m_iID, from, to) != m_iID)
+                if (std::clamp(m_id, from, to) != m_id)
                     return false;
                 continue;
             }
@@ -321,7 +321,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto SHOULDBESPECIAL = configStringToInt(prop);
 
-                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_bIsSpecialWorkspace)
+                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_isSpecialWorkspace)
                     return false;
                 continue;
             }
@@ -336,7 +336,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto PMONITOR = g_pCompositor->getMonitorFromString(prop);
 
-                if (!(PMONITOR ? PMONITOR == m_pMonitor : false))
+                if (!(PMONITOR ? PMONITOR == m_monitor : false))
                     return false;
                 continue;
             }
@@ -349,14 +349,14 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 prop = prop.substr(2, prop.length() - 3);
 
-                if (prop.starts_with("s:") && !m_szName.starts_with(prop.substr(2)))
+                if (prop.starts_with("s:") && !m_name.starts_with(prop.substr(2)))
                     return false;
-                if (prop.starts_with("e:") && !m_szName.ends_with(prop.substr(2)))
+                if (prop.starts_with("e:") && !m_name.ends_with(prop.substr(2)))
                     return false;
 
                 const auto WANTSNAMED = configStringToInt(prop);
 
-                if (WANTSNAMED && *WANTSNAMED != (m_iID <= -1337))
+                if (WANTSNAMED && *WANTSNAMED != (m_id <= -1337))
                     return false;
                 continue;
             }
@@ -481,15 +481,15 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 switch (FSSTATE) {
                     case -1: // no fullscreen
-                        if (m_bHasFullscreenWindow)
+                        if (m_hasFullscreenWindow)
                             return false;
                         break;
                     case 0: // fullscreen full
-                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_FULLSCREEN)
+                        if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_FULLSCREEN)
                             return false;
                         break;
                     case 1: // maximized
-                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_MAXIMIZED)
+                        if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_MAXIMIZED)
                             return false;
                         break;
                     default: break;
@@ -509,23 +509,23 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 }
 
 void CWorkspace::markInert() {
-    m_bInert   = true;
-    m_iID      = WORKSPACE_INVALID;
-    m_bVisible = false;
-    m_pMonitor.reset();
+    m_inert   = true;
+    m_id      = WORKSPACE_INVALID;
+    m_visible = false;
+    m_monitor.reset();
 }
 
 bool CWorkspace::inert() {
-    return m_bInert;
+    return m_inert;
 }
 
 MONITORID CWorkspace::monitorID() {
-    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
+    return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
 }
 
 PHLWINDOW CWorkspace::getFullscreenWindow() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace == m_pSelf && w->isFullscreen())
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->m_workspace == m_self && w->isFullscreen())
             return w;
     }
 
@@ -533,25 +533,25 @@ PHLWINDOW CWorkspace::getFullscreenWindow() {
 }
 
 bool CWorkspace::isVisible() {
-    return m_bVisible;
+    return m_visible;
 }
 
 bool CWorkspace::isVisibleNotCovered() {
-    const auto PMONITOR = m_pMonitor.lock();
-    if (PMONITOR->activeSpecialWorkspace)
-        return PMONITOR->activeSpecialWorkspace->m_iID == m_iID;
+    const auto PMONITOR = m_monitor.lock();
+    if (PMONITOR->m_activeSpecialWorkspace)
+        return PMONITOR->m_activeSpecialWorkspace->m_id == m_id;
 
-    return PMONITOR->activeWorkspace->m_iID == m_iID;
+    return PMONITOR->m_activeWorkspace->m_id == m_id;
 }
 
 int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
     int no = 0;
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->workspaceID() != m_id || !w->m_isMapped)
             continue;
-        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
+        if (onlyTiled.has_value() && w->m_isFloating == onlyTiled.value())
             continue;
-        if (onlyPinned.has_value() && w->m_bPinned != onlyPinned.value())
+        if (onlyPinned.has_value() && w->m_pinned != onlyPinned.value())
             continue;
         if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
             continue;
@@ -563,14 +563,14 @@ int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> on
 
 int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
     int no = 0;
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->workspaceID() != m_id || !w->m_isMapped)
             continue;
-        if (!w->m_sGroupData.head)
+        if (!w->m_groupData.head)
             continue;
-        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
+        if (onlyTiled.has_value() && w->m_isFloating == onlyTiled.value())
             continue;
-        if (onlyPinned.has_value() && w->m_bPinned != onlyPinned.value())
+        if (onlyPinned.has_value() && w->m_pinned != onlyPinned.value())
             continue;
         if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
             continue;
@@ -580,8 +580,8 @@ int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onl
 }
 
 PHLWINDOW CWorkspace::getFirstWindow() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && !w->isHidden())
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->m_workspace == m_self && w->m_isMapped && !w->isHidden())
             return w;
     }
 
@@ -589,32 +589,27 @@ PHLWINDOW CWorkspace::getFirstWindow() {
 }
 
 PHLWINDOW CWorkspace::getTopLeftWindow() {
-    const auto PMONITOR = m_pMonitor.lock();
+    const auto PMONITOR = m_monitor.lock();
 
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->m_workspace != m_self || !w->m_isMapped || w->isHidden())
             continue;
 
         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;
 }
 
 bool CWorkspace::hasUrgentWindow() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && w->m_bIsUrgent)
-            return true;
-    }
-
-    return false;
+    return std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_workspace == m_self && w->m_isMapped && w->m_isUrgent; });
 }
 
 void CWorkspace::updateWindowDecos() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf)
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->m_workspace != m_self)
             continue;
 
         w->updateWindowDecos();
@@ -622,10 +617,10 @@ void CWorkspace::updateWindowDecos() {
 }
 
 void CWorkspace::updateWindowData() {
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock());
 
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf)
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->m_workspace != m_self)
             continue;
 
         w->updateWindowData(WORKSPACERULE);
@@ -633,8 +628,8 @@ void CWorkspace::updateWindowData() {
 }
 
 void CWorkspace::forceReportSizesToWindows() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (w->m_workspace != m_self || !w->m_isMapped || w->isHidden())
             continue;
 
         w->sendWindowSize(true);
@@ -642,26 +637,26 @@ void CWorkspace::forceReportSizesToWindows() {
 }
 
 void CWorkspace::rename(const std::string& name) {
-    if (g_pCompositor->isWorkspaceSpecial(m_iID))
+    if (g_pCompositor->isWorkspaceSpecial(m_id))
         return;
 
-    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_iID, name);
-    m_szName = name;
+    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_id, name);
+    m_name = name;
 
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
-    m_bPersistent            = WORKSPACERULE.isPersistent;
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock());
+    m_persistent             = WORKSPACERULE.isPersistent;
 
     if (WORKSPACERULE.isPersistent)
-        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_pSelf.lock());
+        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_self.lock());
 
-    g_pEventManager->postEvent({"renameworkspace", std::to_string(m_iID) + "," + m_szName});
+    g_pEventManager->postEvent({.event = "renameworkspace", .data = std::to_string(m_id) + "," + m_name});
 }
 
 void CWorkspace::updateWindows() {
-    m_bHasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_vWindows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_pSelf && w->isFullscreen(); });
+    m_hasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_isMapped && w->m_workspace == m_self && w->isFullscreen(); });
 
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (!w->m_bIsMapped || w->m_pWorkspace != m_pSelf)
+    for (auto const& w : g_pCompositor->m_windows) {
+        if (!w->m_isMapped || w->m_workspace != m_self)
             continue;
 
         w->updateDynamicRules();

src/desktop/Workspace.hpp

@@ -2,7 +2,6 @@
 
 #include "../helpers/AnimatedVariable.hpp"
 #include <string>
-#include "../defines.hpp"
 #include "DesktopTypes.hpp"
 #include "../helpers/MiscFunctions.hpp"
 
@@ -24,39 +23,39 @@ class CWorkspace {
 
     // Workspaces ID-based have IDs > 0
     // and workspaces name-based have IDs starting with -1337
-    WORKSPACEID     m_iID    = WORKSPACE_INVALID;
-    std::string     m_szName = "";
-    PHLMONITORREF   m_pMonitor;
+    WORKSPACEID     m_id   = WORKSPACE_INVALID;
+    std::string     m_name = "";
+    PHLMONITORREF   m_monitor;
 
-    bool            m_bHasFullscreenWindow = false;
-    eFullscreenMode m_efFullscreenMode     = FSMODE_NONE;
+    bool            m_hasFullscreenWindow = false;
+    eFullscreenMode m_fullscreenMode      = FSMODE_NONE;
 
     wl_array        m_wlrCoordinateArr;
 
     // for animations
-    PHLANIMVAR<Vector2D> m_vRenderOffset;
-    PHLANIMVAR<float>    m_fAlpha;
-    bool                 m_bForceRendering = false;
+    PHLANIMVAR<Vector2D> m_renderOffset;
+    PHLANIMVAR<float>    m_alpha;
+    bool                 m_forceRendering = false;
 
     // allows damage to propagate.
-    bool m_bVisible = false;
+    bool m_visible = false;
 
     // "scratchpad"
-    bool m_bIsSpecialWorkspace = false;
+    bool m_isSpecialWorkspace = false;
 
     // last window
-    PHLWINDOWREF m_pLastFocusedWindow;
+    PHLWINDOWREF m_lastFocusedWindow;
 
     // user-set
-    bool m_bDefaultFloating = false;
-    bool m_bDefaultPseudo   = false;
+    bool m_defaultFloating = false;
+    bool m_defaultPseudo   = false;
 
     // last monitor (used on reconnect)
-    std::string m_szLastMonitor = "";
+    std::string m_lastMonitor = "";
 
-    bool        m_bWasCreatedEmpty = true;
+    bool        m_wasCreatedEmpty = true;
 
-    bool        m_bPersistent = false;
+    bool        m_persistent = false;
 
     // Inert: destroyed and invalid. If this is true, release the ptr you have.
     bool             inert();
@@ -88,11 +87,11 @@ class CWorkspace {
     void init(PHLWORKSPACE self);
     // Previous workspace ID and name is stored during a workspace change, allowing travel
     // to the previous workspace.
-    SWorkspaceIDName     m_sPrevWorkspace;
+    SWorkspaceIDName     m_prevWorkspace;
 
-    SP<HOOK_CALLBACK_FN> m_pFocusedWindowHook;
-    bool                 m_bInert = true;
-    WP<CWorkspace>       m_pSelf;
+    SP<HOOK_CALLBACK_FN> m_focusedWindowHook;
+    bool                 m_inert = true;
+    WP<CWorkspace>       m_self;
 };
 
 inline bool valid(const PHLWORKSPACE& ref) {

src/devices/IHID.hpp

@@ -34,7 +34,8 @@ class IHID {
 
     struct {
         CSignal destroy;
-    } events;
+    } m_events;
 
-    std::string deviceName, hlName;
+    std::string m_deviceName;
+    std::string m_hlName;
 };

src/devices/IKeyboard.cpp

@@ -28,38 +28,38 @@ eHIDType IKeyboard::getType() {
 }
 
 IKeyboard::~IKeyboard() {
-    events.destroy.emit();
+    m_events.destroy.emit();
 
     clearManuallyAllocd();
 }
 
 void IKeyboard::clearManuallyAllocd() {
-    if (xkbStaticState)
-        xkb_state_unref(xkbStaticState);
+    if (m_xkbStaticState)
+        xkb_state_unref(m_xkbStaticState);
 
-    if (xkbState)
-        xkb_state_unref(xkbState);
+    if (m_xkbState)
+        xkb_state_unref(m_xkbState);
 
-    if (xkbKeymap)
-        xkb_keymap_unref(xkbKeymap);
+    if (m_xkbKeymap)
+        xkb_keymap_unref(m_xkbKeymap);
 
-    if (xkbSymState)
-        xkb_state_unref(xkbSymState);
+    if (m_xkbSymState)
+        xkb_state_unref(m_xkbSymState);
 
-    xkbSymState    = nullptr;
-    xkbKeymap      = nullptr;
-    xkbState       = nullptr;
-    xkbStaticState = nullptr;
-    xkbKeymapFD.reset();
+    m_xkbSymState    = nullptr;
+    m_xkbKeymap      = nullptr;
+    m_xkbState       = nullptr;
+    m_xkbStaticState = nullptr;
+    m_xkbKeymapFD.reset();
 }
 
 void IKeyboard::setKeymap(const SStringRuleNames& rules) {
-    if (keymapOverridden) {
+    if (m_keymapOverridden) {
         Debug::log(LOG, "Ignoring setKeymap: keymap is overridden");
         return;
     }
 
-    currentRules            = rules;
+    m_currentRules          = rules;
     xkb_rule_names XKBRULES = {
         .rules   = rules.rules.c_str(),
         .model   = rules.model.c_str(),
@@ -80,21 +80,21 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
     Debug::log(LOG, "Attempting to create a keymap for layout {} with variant {} (rules: {}, model: {}, options: {})", rules.layout, rules.variant, rules.rules, rules.model,
                rules.options);
 
-    if (!xkbFilePath.empty()) {
-        auto path = absolutePath(xkbFilePath, g_pConfigManager->configCurrentPath);
+    if (!m_xkbFilePath.empty()) {
+        auto path = absolutePath(m_xkbFilePath, g_pConfigManager->m_configCurrentPath);
 
         if (FILE* const KEYMAPFILE = fopen(path.c_str(), "r"); !KEYMAPFILE)
             Debug::log(ERR, "Cannot open input:kb_file= file for reading");
         else {
-            xkbKeymap = xkb_keymap_new_from_file(CONTEXT, KEYMAPFILE, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            m_xkbKeymap = xkb_keymap_new_from_file(CONTEXT, KEYMAPFILE, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
             fclose(KEYMAPFILE);
         }
     }
 
-    if (!xkbKeymap)
-        xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
+    if (!m_xkbKeymap)
+        m_xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-    if (!xkbKeymap) {
+    if (!m_xkbKeymap) {
         g_pConfigManager->addParseError("Invalid keyboard layout passed. ( rules: " + rules.rules + ", model: " + rules.model + ", variant: " + rules.variant +
                                         ", options: " + rules.options + ", layout: " + rules.layout + " )");
 
@@ -102,38 +102,38 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
                    rules.options);
         memset(&XKBRULES, 0, sizeof(XKBRULES));
 
-        currentRules.rules   = "";
-        currentRules.model   = "";
-        currentRules.variant = "";
-        currentRules.options = "";
-        currentRules.layout  = "us";
+        m_currentRules.rules   = "";
+        m_currentRules.model   = "";
+        m_currentRules.variant = "";
+        m_currentRules.options = "";
+        m_currentRules.layout  = "us";
 
-        xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
+        m_xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
     }
 
-    updateXKBTranslationState(xkbKeymap);
+    updateXKBTranslationState(m_xkbKeymap);
 
-    const auto NUMLOCKON = g_pConfigManager->getDeviceInt(hlName, "numlock_by_default", "input:numlock_by_default");
+    const auto NUMLOCKON = g_pConfigManager->getDeviceInt(m_hlName, "numlock_by_default", "input:numlock_by_default");
 
     if (NUMLOCKON == 1) {
         // lock numlock
-        const auto IDX = xkb_map_mod_get_index(xkbKeymap, XKB_MOD_NAME_NUM);
+        const auto IDX = xkb_map_mod_get_index(m_xkbKeymap, XKB_MOD_NAME_NUM);
 
         if (IDX != XKB_MOD_INVALID)
-            modifiersState.locked |= (uint32_t)1 << IDX;
+            m_modifiersState.locked |= (uint32_t)1 << IDX;
 
         // 0 to avoid mods getting stuck if depressed during reload
-        updateModifiers(0, 0, modifiersState.locked, modifiersState.group);
+        updateModifiers(0, 0, m_modifiersState.locked, m_modifiersState.group);
     }
 
-    for (size_t i = 0; i < std::min(LEDNAMES.size(), ledIndexes.size()); ++i) {
-        ledIndexes[i] = xkb_map_led_get_index(xkbKeymap, LEDNAMES[i]);
-        Debug::log(LOG, "xkb: LED index {} (name {}) got index {}", i, LEDNAMES[i], ledIndexes[i]);
+    for (size_t i = 0; i < std::min(LEDNAMES.size(), m_ledIndexes.size()); ++i) {
+        m_ledIndexes[i] = xkb_map_led_get_index(m_xkbKeymap, LEDNAMES[i]);
+        Debug::log(LOG, "xkb: LED index {} (name {}) got index {}", i, LEDNAMES[i], m_ledIndexes[i]);
     }
 
-    for (size_t i = 0; i < std::min(MODNAMES.size(), modIndexes.size()); ++i) {
-        modIndexes[i] = xkb_map_mod_get_index(xkbKeymap, MODNAMES[i]);
-        Debug::log(LOG, "xkb: Mod index {} (name {}) got index {}", i, MODNAMES[i], modIndexes[i]);
+    for (size_t i = 0; i < std::min(MODNAMES.size(), m_modIndexes.size()); ++i) {
+        m_modIndexes[i] = xkb_map_mod_get_index(m_xkbKeymap, MODNAMES[i]);
+        Debug::log(LOG, "xkb: Mod index {} (name {}) got index {}", i, MODNAMES[i], m_modIndexes[i]);
     }
 
     updateKeymapFD();
@@ -144,59 +144,59 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
 }
 
 void IKeyboard::updateKeymapFD() {
-    Debug::log(LOG, "Updating keymap fd for keyboard {}", deviceName);
+    Debug::log(LOG, "Updating keymap fd for keyboard {}", m_deviceName);
 
-    if (xkbKeymapFD.isValid())
-        xkbKeymapFD.reset();
+    if (m_xkbKeymapFD.isValid())
+        m_xkbKeymapFD.reset();
 
-    auto cKeymapStr = xkb_keymap_get_as_string(xkbKeymap, XKB_KEYMAP_FORMAT_TEXT_V1);
-    xkbKeymapString = cKeymapStr;
+    auto cKeymapStr   = xkb_keymap_get_as_string(m_xkbKeymap, XKB_KEYMAP_FORMAT_TEXT_V1);
+    m_xkbKeymapString = cKeymapStr;
     free(cKeymapStr);
 
     CFileDescriptor rw, ro;
-    if (!allocateSHMFilePair(xkbKeymapString.length() + 1, rw, ro))
+    if (!allocateSHMFilePair(m_xkbKeymapString.length() + 1, rw, ro))
         Debug::log(ERR, "IKeyboard: failed to allocate shm pair for the keymap");
     else {
-        auto keymapFDDest = mmap(nullptr, xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw.get(), 0);
+        auto keymapFDDest = mmap(nullptr, m_xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw.get(), 0);
         rw.reset();
         if (keymapFDDest == MAP_FAILED) {
             Debug::log(ERR, "IKeyboard: failed to mmap a shm pair for the keymap");
             ro.reset();
         } else {
-            memcpy(keymapFDDest, xkbKeymapString.c_str(), xkbKeymapString.length());
-            munmap(keymapFDDest, xkbKeymapString.length() + 1);
-            xkbKeymapFD = std::move(ro);
+            memcpy(keymapFDDest, m_xkbKeymapString.c_str(), m_xkbKeymapString.length());
+            munmap(keymapFDDest, m_xkbKeymapString.length() + 1);
+            m_xkbKeymapFD = std::move(ro);
         }
     }
 
-    Debug::log(LOG, "Updated keymap fd to {}", xkbKeymapFD.get());
+    Debug::log(LOG, "Updated keymap fd to {}", m_xkbKeymapFD.get());
 }
 
 void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
 
-    if (xkbStaticState)
-        xkb_state_unref(xkbStaticState);
+    if (m_xkbStaticState)
+        xkb_state_unref(m_xkbStaticState);
 
-    if (xkbState)
-        xkb_state_unref(xkbState);
+    if (m_xkbState)
+        xkb_state_unref(m_xkbState);
 
-    if (xkbSymState)
-        xkb_state_unref(xkbSymState);
+    if (m_xkbSymState)
+        xkb_state_unref(m_xkbSymState);
 
-    xkbState       = nullptr;
-    xkbStaticState = nullptr;
-    xkbSymState    = nullptr;
+    m_xkbState       = nullptr;
+    m_xkbStaticState = nullptr;
+    m_xkbSymState    = nullptr;
 
     if (keymap) {
         Debug::log(LOG, "Updating keyboard {:x}'s translation state from a provided keymap", (uintptr_t)this);
-        xkbStaticState = xkb_state_new(keymap);
-        xkbState       = xkb_state_new(keymap);
-        xkbSymState    = xkb_state_new(keymap);
+        m_xkbStaticState = xkb_state_new(keymap);
+        m_xkbState       = xkb_state_new(keymap);
+        m_xkbSymState    = xkb_state_new(keymap);
         return;
     }
 
-    const auto KEYMAP     = xkbKeymap;
-    const auto STATE      = xkbState;
+    const auto KEYMAP     = m_xkbKeymap;
+    const auto STATE      = m_xkbState;
     const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
 
     const auto PCONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
@@ -205,9 +205,9 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
         if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE) == 1) {
             Debug::log(LOG, "Updating keyboard {:x}'s translation state from an active index {}", (uintptr_t)this, i);
 
-            CVarList       keyboardLayouts(currentRules.layout, 0, ',');
-            CVarList       keyboardModels(currentRules.model, 0, ',');
-            CVarList       keyboardVariants(currentRules.variant, 0, ',');
+            CVarList       keyboardLayouts(m_currentRules.layout, 0, ',');
+            CVarList       keyboardModels(m_currentRules.model, 0, ',');
+            CVarList       keyboardVariants(m_currentRules.variant, 0, ',');
 
             xkb_rule_names rules = {.rules = "", .model = "", .layout = "", .variant = "", .options = ""};
 
@@ -235,9 +235,9 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
                 KEYMAP       = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
             }
 
-            xkbState       = xkb_state_new(KEYMAP);
-            xkbStaticState = xkb_state_new(KEYMAP);
-            xkbSymState    = xkb_state_new(KEYMAP);
+            m_xkbState       = xkb_state_new(KEYMAP);
+            m_xkbStaticState = xkb_state_new(KEYMAP);
+            m_xkbSymState    = xkb_state_new(KEYMAP);
 
             xkb_keymap_unref(KEYMAP);
             xkb_context_unref(PCONTEXT);
@@ -249,26 +249,26 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
     Debug::log(LOG, "Updating keyboard {:x}'s translation state from an unknown index", (uintptr_t)this);
 
     xkb_rule_names rules = {
-        .rules   = currentRules.rules.c_str(),
-        .model   = currentRules.model.c_str(),
-        .layout  = currentRules.layout.c_str(),
-        .variant = currentRules.variant.c_str(),
-        .options = currentRules.options.c_str(),
+        .rules   = m_currentRules.rules.c_str(),
+        .model   = m_currentRules.model.c_str(),
+        .layout  = m_currentRules.layout.c_str(),
+        .variant = m_currentRules.variant.c_str(),
+        .options = m_currentRules.options.c_str(),
     };
 
     const auto NEWKEYMAP = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-    xkbState       = xkb_state_new(NEWKEYMAP);
-    xkbStaticState = xkb_state_new(NEWKEYMAP);
-    xkbSymState    = xkb_state_new(NEWKEYMAP);
+    m_xkbState       = xkb_state_new(NEWKEYMAP);
+    m_xkbStaticState = xkb_state_new(NEWKEYMAP);
+    m_xkbSymState    = xkb_state_new(NEWKEYMAP);
 
     xkb_keymap_unref(NEWKEYMAP);
     xkb_context_unref(PCONTEXT);
 }
 
 std::string IKeyboard::getActiveLayout() {
-    const auto KEYMAP     = xkbKeymap;
-    const auto STATE      = xkbState;
+    const auto KEYMAP     = m_xkbKeymap;
+    const auto STATE      = m_xkbState;
     const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
 
     for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
@@ -285,12 +285,12 @@ std::string IKeyboard::getActiveLayout() {
 }
 
 std::optional<uint32_t> IKeyboard::getLEDs() {
-    if (xkbState == nullptr)
+    if (m_xkbState == nullptr)
         return {};
 
     uint32_t leds = 0;
-    for (uint32_t i = 0; i < std::min((size_t)LED_COUNT, ledIndexes.size()); ++i) {
-        if (xkb_state_led_index_is_active(xkbState, ledIndexes[i]))
+    for (uint32_t i = 0; i < std::min((size_t)LED_COUNT, m_ledIndexes.size()); ++i) {
+        if (xkb_state_led_index_is_active(m_xkbState, m_ledIndexes[i]))
             leds |= (1 << i);
     }
 
@@ -307,10 +307,10 @@ void IKeyboard::updateLEDs() {
 }
 
 void IKeyboard::updateLEDs(uint32_t leds) {
-    if (!xkbState)
+    if (!m_xkbState)
         return;
 
-    if (isVirtual() && g_pInputManager->shouldIgnoreVirtualKeyboard(self.lock()))
+    if (isVirtual() && g_pInputManager->shouldIgnoreVirtualKeyboard(m_self.lock()))
         return;
 
     if (!aq())
@@ -320,13 +320,13 @@ void IKeyboard::updateLEDs(uint32_t leds) {
 }
 
 uint32_t IKeyboard::getModifiers() {
-    uint32_t modMask = modifiersState.depressed | modifiersState.latched;
+    uint32_t modMask = m_modifiersState.depressed | m_modifiersState.latched;
     uint32_t mods    = 0;
-    for (size_t i = 0; i < modIndexes.size(); ++i) {
-        if (modIndexes[i] == XKB_MOD_INVALID)
+    for (size_t i = 0; i < m_modIndexes.size(); ++i) {
+        if (m_modIndexes[i] == XKB_MOD_INVALID)
             continue;
 
-        if (!(modMask & (1 << modIndexes[i])))
+        if (!(modMask & (1 << m_modIndexes[i])))
             continue;
 
         mods |= (1 << i);
@@ -336,50 +336,50 @@ uint32_t IKeyboard::getModifiers() {
 }
 
 void IKeyboard::updateModifiers(uint32_t depressed, uint32_t latched, uint32_t locked, uint32_t group) {
-    if (!xkbState)
+    if (!m_xkbState)
         return;
 
-    xkb_state_update_mask(xkbState, depressed, latched, locked, 0, 0, group);
+    xkb_state_update_mask(m_xkbState, depressed, latched, locked, 0, 0, group);
 
-    if (xkbSymState)
-        xkb_state_update_mask(xkbSymState, 0, 0, 0, 0, 0, group);
+    if (m_xkbSymState)
+        xkb_state_update_mask(m_xkbSymState, 0, 0, 0, 0, 0, group);
 
     if (!updateModifiersState())
         return;
 
-    keyboardEvents.modifiers.emit(SModifiersEvent{
-        .depressed = modifiersState.depressed,
-        .latched   = modifiersState.latched,
-        .locked    = modifiersState.locked,
-        .group     = modifiersState.group,
+    m_keyboardEvents.modifiers.emit(SModifiersEvent{
+        .depressed = m_modifiersState.depressed,
+        .latched   = m_modifiersState.latched,
+        .locked    = m_modifiersState.locked,
+        .group     = m_modifiersState.group,
     });
 
     updateLEDs();
 }
 
 bool IKeyboard::updateModifiersState() {
-    if (!xkbState)
+    if (!m_xkbState)
         return false;
 
-    auto depressed = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_DEPRESSED);
-    auto latched   = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LATCHED);
-    auto locked    = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LOCKED);
-    auto group     = xkb_state_serialize_layout(xkbState, XKB_STATE_LAYOUT_EFFECTIVE);
+    auto depressed = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_DEPRESSED);
+    auto latched   = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_LATCHED);
+    auto locked    = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_LOCKED);
+    auto group     = xkb_state_serialize_layout(m_xkbState, XKB_STATE_LAYOUT_EFFECTIVE);
 
-    if (depressed == modifiersState.depressed && latched == modifiersState.latched && locked == modifiersState.locked && group == modifiersState.group)
+    if (depressed == m_modifiersState.depressed && latched == m_modifiersState.latched && locked == m_modifiersState.locked && group == m_modifiersState.group)
         return false;
 
-    modifiersState.depressed = depressed;
-    modifiersState.latched   = latched;
-    modifiersState.locked    = locked;
-    modifiersState.group     = group;
+    m_modifiersState.depressed = depressed;
+    m_modifiersState.latched   = latched;
+    m_modifiersState.locked    = locked;
+    m_modifiersState.group     = group;
 
     return true;
 }
 
 void IKeyboard::updateXkbStateWithKey(uint32_t xkbKey, bool pressed) {
 
-    const auto contains = std::find(pressedXKB.begin(), pressedXKB.end(), xkbKey) != pressedXKB.end();
+    const auto contains = std::find(m_pressedXKB.begin(), m_pressedXKB.end(), xkbKey) != m_pressedXKB.end();
 
     if (contains && pressed)
         return;
@@ -387,21 +387,21 @@ void IKeyboard::updateXkbStateWithKey(uint32_t xkbKey, bool pressed) {
         return;
 
     if (contains)
-        std::erase(pressedXKB, xkbKey);
+        std::erase(m_pressedXKB, xkbKey);
     else
-        pressedXKB.emplace_back(xkbKey);
+        m_pressedXKB.emplace_back(xkbKey);
 
-    xkb_state_update_key(xkbState, xkbKey, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
+    xkb_state_update_key(m_xkbState, xkbKey, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
 
     if (updateModifiersState()) {
-        if (xkbSymState)
-            xkb_state_update_mask(xkbSymState, 0, 0, 0, 0, 0, modifiersState.group);
+        if (m_xkbSymState)
+            xkb_state_update_mask(m_xkbSymState, 0, 0, 0, 0, 0, m_modifiersState.group);
 
-        keyboardEvents.modifiers.emit(SModifiersEvent{
-            .depressed = modifiersState.depressed,
-            .latched   = modifiersState.latched,
-            .locked    = modifiersState.locked,
-            .group     = modifiersState.group,
+        m_keyboardEvents.modifiers.emit(SModifiersEvent{
+            .depressed = m_modifiersState.depressed,
+            .latched   = m_modifiersState.latched,
+            .locked    = m_modifiersState.locked,
+            .group     = m_modifiersState.group,
         });
     }
 }

src/devices/IKeyboard.hpp

@@ -52,7 +52,7 @@ class IKeyboard : public IHID {
         CSignal modifiers;
         CSignal keymap;
         CSignal repeatInfo;
-    } keyboardEvents;
+    } m_keyboardEvents;
 
     struct SStringRuleNames {
         std::string layout  = "";
@@ -74,41 +74,46 @@ class IKeyboard : public IHID {
     void                    updateXkbStateWithKey(uint32_t xkbKey, bool pressed);
     void                    updateKeymapFD();
 
-    bool                    active  = false;
-    bool                    enabled = true;
+    bool                    m_active     = false;
+    bool                    m_enabled    = true;
+    bool                    m_allowBinds = true;
 
     // if the keymap is overridden by the implementation,
     // don't try to set keyboard rules anymore, to avoid overwriting the requested one.
     // e.g. Virtual keyboards with custom maps.
-    bool               keymapOverridden = false;
+    bool               m_keymapOverridden = false;
 
-    xkb_layout_index_t activeLayout = 0;
-    xkb_state *        xkbState = nullptr, *xkbStaticState /* Static state: never gets modifiers or layout changes sent, used for keybinds. */ = nullptr,
-              *xkbSymState = nullptr /* Same as static but gets layouts */;
-    xkb_keymap* xkbKeymap  = nullptr;
+    xkb_layout_index_t m_activeLayout = 0;
+    xkb_state*         m_xkbState     = nullptr;
+
+    // never gets modifiers or layout changes sent, used for keybinds
+    xkb_state*  m_xkbStaticState = nullptr;
+    xkb_state*  m_xkbSymState    = nullptr; // same as static but gets layouts
+
+    xkb_keymap* m_xkbKeymap = nullptr;
 
     struct {
         uint32_t depressed = 0, latched = 0, locked = 0, group = 0;
-    } modifiersState;
+    } m_modifiersState;
 
-    std::array<xkb_led_index_t, 3> ledIndexes = {XKB_MOD_INVALID};
-    std::array<xkb_mod_index_t, 8> modIndexes = {XKB_MOD_INVALID};
-    uint32_t                       leds       = 0;
+    std::array<xkb_led_index_t, 3> m_ledIndexes = {XKB_MOD_INVALID};
+    std::array<xkb_mod_index_t, 8> m_modIndexes = {XKB_MOD_INVALID};
+    uint32_t                       m_leds       = 0;
 
-    std::string                    xkbFilePath     = "";
-    std::string                    xkbKeymapString = "";
-    Hyprutils::OS::CFileDescriptor xkbKeymapFD;
+    std::string                    m_xkbFilePath     = "";
+    std::string                    m_xkbKeymapString = "";
+    Hyprutils::OS::CFileDescriptor m_xkbKeymapFD;
 
-    SStringRuleNames               currentRules;
-    int                            repeatRate        = 0;
-    int                            repeatDelay       = 0;
-    int                            numlockOn         = -1;
-    bool                           resolveBindsBySym = false;
+    SStringRuleNames               m_currentRules;
+    int                            m_repeatRate        = 0;
+    int                            m_repeatDelay       = 0;
+    int                            m_numlockOn         = -1;
+    bool                           m_resolveBindsBySym = false;
 
-    WP<IKeyboard>                  self;
+    WP<IKeyboard>                  m_self;
 
   private:
     void                  clearManuallyAllocd();
 
-    std::vector<uint32_t> pressedXKB;
+    std::vector<uint32_t> m_pressedXKB;
 };

src/devices/IPointer.hpp

@@ -106,13 +106,13 @@ class IPointer : public IHID {
 
         CSignal holdBegin;
         CSignal holdEnd;
-    } pointerEvents;
+    } m_pointerEvents;
 
-    bool         connected   = false; // means connected to the cursor
-    std::string  boundOutput = "";
-    bool         flipX       = false; // decide to invert horizontal movement
-    bool         flipY       = false; // decide to invert vertical movement
-    bool         isTouchpad  = false;
+    bool         m_connected   = false; // means connected to the cursor
+    std::string  m_boundOutput = "";
+    bool         m_flipX       = false; // decide to invert horizontal movement
+    bool         m_flipY       = false; // decide to invert vertical movement
+    bool         m_isTouchpad  = false;
 
-    WP<IPointer> self;
+    WP<IPointer> m_self;
 };

src/devices/ITouch.hpp

@@ -42,9 +42,9 @@ class ITouch : public IHID {
         CSignal motion;
         CSignal cancel;
         CSignal frame;
-    } touchEvents;
+    } m_touchEvents;
 
-    std::string boundOutput = "";
+    std::string m_boundOutput = "";
 
-    WP<ITouch>  self;
+    WP<ITouch>  m_self;
 };

src/devices/Keyboard.cpp

@@ -6,7 +6,7 @@
 SP<CKeyboard> CKeyboard::create(SP<Aquamarine::IKeyboard> keeb) {
     SP<CKeyboard> pKeeb = SP<CKeyboard>(new CKeyboard(keeb));
 
-    pKeeb->self = pKeeb;
+    pKeeb->m_self = pKeeb;
 
     return pKeeb;
 }
@@ -16,22 +16,22 @@ bool CKeyboard::isVirtual() {
 }
 
 SP<Aquamarine::IKeyboard> CKeyboard::aq() {
-    return keyboard.lock();
+    return m_keyboard.lock();
 }
 
-CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : keyboard(keeb) {
+CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : m_keyboard(keeb) {
     if (!keeb)
         return;
 
-    listeners.destroy = keeb->events.destroy.registerListener([this](std::any d) {
-        keyboard.reset();
-        events.destroy.emit();
+    m_listeners.destroy = keeb->events.destroy.registerListener([this](std::any d) {
+        m_keyboard.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.key = keeb->events.key.registerListener([this](std::any d) {
+    m_listeners.key = keeb->events.key.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IKeyboard::SKeyEvent>(d);
 
-        keyboardEvents.key.emit(SKeyEvent{
+        m_keyboardEvents.key.emit(SKeyEvent{
             .timeMs  = E.timeMs,
             .keycode = E.key,
             .state   = E.pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED,
@@ -40,16 +40,16 @@ CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : keyboard(keeb) {
         updateXkbStateWithKey(E.key + 8, E.pressed);
     });
 
-    listeners.modifiers = keeb->events.modifiers.registerListener([this](std::any d) {
+    m_listeners.modifiers = keeb->events.modifiers.registerListener([this](std::any d) {
         updateModifiersState();
 
-        keyboardEvents.modifiers.emit(SModifiersEvent{
-            .depressed = modifiersState.depressed,
-            .latched   = modifiersState.latched,
-            .locked    = modifiersState.locked,
-            .group     = modifiersState.group,
+        m_keyboardEvents.modifiers.emit(SModifiersEvent{
+            .depressed = m_modifiersState.depressed,
+            .latched   = m_modifiersState.latched,
+            .locked    = m_modifiersState.locked,
+            .group     = m_modifiersState.group,
         });
     });
 
-    deviceName = keeb->getName();
+    m_deviceName = keeb->getName();
 }

src/devices/Keyboard.hpp

@@ -12,11 +12,11 @@ class CKeyboard : public IKeyboard {
   private:
     CKeyboard(SP<Aquamarine::IKeyboard> keeb);
 
-    WP<Aquamarine::IKeyboard> keyboard;
+    WP<Aquamarine::IKeyboard> m_keyboard;
 
     struct {
         CHyprSignalListener destroy;
         CHyprSignalListener key;
         CHyprSignalListener modifiers;
-    } listeners;
+    } m_listeners;
 };

src/devices/Mouse.cpp

@@ -5,51 +5,51 @@
 SP<CMouse> CMouse::create(SP<Aquamarine::IPointer> mouse) {
     SP<CMouse> pMouse = SP<CMouse>(new CMouse(mouse));
 
-    pMouse->self = pMouse;
+    pMouse->m_self = pMouse;
 
     return pMouse;
 }
 
-CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
-    if (!mouse)
+CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
+    if (!m_mouse)
         return;
 
-    if (auto handle = mouse->getLibinputHandle()) {
+    if (auto handle = m_mouse->getLibinputHandle()) {
         double w = 0, h = 0;
-        isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
+        m_isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
     }
 
-    listeners.destroy = mouse->events.destroy.registerListener([this](std::any d) {
-        mouse.reset();
-        events.destroy.emit();
+    m_listeners.destroy = m_mouse->events.destroy.registerListener([this](std::any d) {
+        m_mouse.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.motion = mouse->events.move.registerListener([this](std::any d) {
+    m_listeners.motion = m_mouse->events.move.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SMoveEvent>(d);
 
-        pointerEvents.motion.emit(SMotionEvent{
+        m_pointerEvents.motion.emit(SMotionEvent{
             .timeMs  = E.timeMs,
             .delta   = E.delta,
             .unaccel = E.unaccel,
             .mouse   = true,
-            .device  = self.lock(),
+            .device  = m_self.lock(),
         });
     });
 
-    listeners.motionAbsolute = mouse->events.warp.registerListener([this](std::any d) {
+    m_listeners.motionAbsolute = m_mouse->events.warp.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SWarpEvent>(d);
 
-        pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
+        m_pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
             .timeMs   = E.timeMs,
             .absolute = E.absolute,
-            .device   = self.lock(),
+            .device   = m_self.lock(),
         });
     });
 
-    listeners.button = mouse->events.button.registerListener([this](std::any d) {
+    m_listeners.button = m_mouse->events.button.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SButtonEvent>(d);
 
-        pointerEvents.button.emit(SButtonEvent{
+        m_pointerEvents.button.emit(SButtonEvent{
             .timeMs = E.timeMs,
             .button = E.button,
             .state  = E.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED,
@@ -57,10 +57,10 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
         });
     });
 
-    listeners.axis = mouse->events.axis.registerListener([this](std::any d) {
+    m_listeners.axis = m_mouse->events.axis.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SAxisEvent>(d);
 
-        pointerEvents.axis.emit(SAxisEvent{
+        m_pointerEvents.axis.emit(SAxisEvent{
             .timeMs            = E.timeMs,
             .source            = (wl_pointer_axis_source)E.source,
             .axis              = (wl_pointer_axis)E.axis,
@@ -71,58 +71,58 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
         });
     });
 
-    listeners.frame = mouse->events.frame.registerListener([this](std::any d) { pointerEvents.frame.emit(); });
+    m_listeners.frame = m_mouse->events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); });
 
-    listeners.swipeBegin = mouse->events.swipeBegin.registerListener([this](std::any d) {
+    m_listeners.swipeBegin = m_mouse->events.swipeBegin.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SSwipeBeginEvent>(d);
 
-        pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
+        m_pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
         });
     });
 
-    listeners.swipeEnd = mouse->events.swipeEnd.registerListener([this](std::any d) {
+    m_listeners.swipeEnd = m_mouse->events.swipeEnd.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SSwipeEndEvent>(d);
 
-        pointerEvents.swipeEnd.emit(SSwipeEndEvent{
+        m_pointerEvents.swipeEnd.emit(SSwipeEndEvent{
             .timeMs    = E.timeMs,
             .cancelled = E.cancelled,
         });
     });
 
-    listeners.swipeUpdate = mouse->events.swipeUpdate.registerListener([this](std::any d) {
+    m_listeners.swipeUpdate = m_mouse->events.swipeUpdate.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SSwipeUpdateEvent>(d);
 
-        pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
+        m_pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
             .delta   = E.delta,
         });
     });
 
-    listeners.pinchBegin = mouse->events.pinchBegin.registerListener([this](std::any d) {
+    m_listeners.pinchBegin = m_mouse->events.pinchBegin.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SPinchBeginEvent>(d);
 
-        pointerEvents.pinchBegin.emit(SPinchBeginEvent{
+        m_pointerEvents.pinchBegin.emit(SPinchBeginEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
         });
     });
 
-    listeners.pinchEnd = mouse->events.pinchEnd.registerListener([this](std::any d) {
+    m_listeners.pinchEnd = m_mouse->events.pinchEnd.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SPinchEndEvent>(d);
 
-        pointerEvents.pinchEnd.emit(SPinchEndEvent{
+        m_pointerEvents.pinchEnd.emit(SPinchEndEvent{
             .timeMs    = E.timeMs,
             .cancelled = E.cancelled,
         });
     });
 
-    listeners.pinchUpdate = mouse->events.pinchUpdate.registerListener([this](std::any d) {
+    m_listeners.pinchUpdate = m_mouse->events.pinchUpdate.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SPinchUpdateEvent>(d);
 
-        pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
+        m_pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
             .timeMs   = E.timeMs,
             .fingers  = E.fingers,
             .delta    = E.delta,
@@ -131,25 +131,25 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
         });
     });
 
-    listeners.holdBegin = mouse->events.holdBegin.registerListener([this](std::any d) {
+    m_listeners.holdBegin = m_mouse->events.holdBegin.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SHoldBeginEvent>(d);
 
-        pointerEvents.holdBegin.emit(SHoldBeginEvent{
+        m_pointerEvents.holdBegin.emit(SHoldBeginEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
         });
     });
 
-    listeners.holdEnd = mouse->events.holdEnd.registerListener([this](std::any d) {
+    m_listeners.holdEnd = m_mouse->events.holdEnd.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SHoldEndEvent>(d);
 
-        pointerEvents.holdEnd.emit(SHoldEndEvent{
+        m_pointerEvents.holdEnd.emit(SHoldEndEvent{
             .timeMs    = E.timeMs,
             .cancelled = E.cancelled,
         });
     });
 
-    deviceName = mouse->getName();
+    m_deviceName = m_mouse->getName();
 }
 
 bool CMouse::isVirtual() {
@@ -157,5 +157,5 @@ bool CMouse::isVirtual() {
 }
 
 SP<Aquamarine::IPointer> CMouse::aq() {
-    return mouse.lock();
+    return m_mouse.lock();
 }

src/devices/Mouse.hpp

@@ -12,7 +12,7 @@ class CMouse : public IPointer {
   private:
     CMouse(SP<Aquamarine::IPointer> mouse);
 
-    WP<Aquamarine::IPointer> mouse;
+    WP<Aquamarine::IPointer> m_mouse;
 
     struct {
         CHyprSignalListener destroy;
@@ -33,5 +33,5 @@ class CMouse : public IPointer {
 
         CHyprSignalListener holdBegin;
         CHyprSignalListener holdEnd;
-    } listeners;
+    } m_listeners;
 };

src/devices/Tablet.cpp

@@ -7,7 +7,7 @@
 SP<CTablet> CTablet::create(SP<Aquamarine::ITablet> tablet) {
     SP<CTablet> pTab = SP<CTablet>(new CTablet(tablet));
 
-    pTab->self = pTab;
+    pTab->m_self = pTab;
 
     PROTO::tablet->registerDevice(pTab);
 
@@ -17,7 +17,7 @@ SP<CTablet> CTablet::create(SP<Aquamarine::ITablet> tablet) {
 SP<CTabletTool> CTabletTool::create(SP<Aquamarine::ITabletTool> tablet) {
     SP<CTabletTool> pTab = SP<CTabletTool>(new CTabletTool(tablet));
 
-    pTab->self = pTab;
+    pTab->m_self = pTab;
 
     PROTO::tablet->registerDevice(pTab);
 
@@ -27,7 +27,7 @@ SP<CTabletTool> CTabletTool::create(SP<Aquamarine::ITabletTool> tablet) {
 SP<CTabletPad> CTabletPad::create(SP<Aquamarine::ITabletPad> tablet) {
     SP<CTabletPad> pTab = SP<CTabletPad>(new CTabletPad(tablet));
 
-    pTab->self = pTab;
+    pTab->m_self = pTab;
 
     PROTO::tablet->registerDevice(pTab);
 
@@ -62,24 +62,24 @@ uint32_t CTablet::getCapabilities() {
 }
 
 SP<Aquamarine::ITablet> CTablet::aq() {
-    return tablet.lock();
+    return m_tablet.lock();
 }
 
-CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : tablet(tablet_) {
-    if (!tablet)
+CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : m_tablet(tablet_) {
+    if (!m_tablet)
         return;
 
-    listeners.destroy = tablet->events.destroy.registerListener([this](std::any d) {
-        tablet.reset();
-        events.destroy.emit();
+    m_listeners.destroy = m_tablet->events.destroy.registerListener([this](std::any d) {
+        m_tablet.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.axis = tablet->events.axis.registerListener([this](std::any d) {
+    m_listeners.axis = m_tablet->events.axis.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::SAxisEvent>(d);
 
-        tabletEvents.axis.emit(SAxisEvent{
+        m_tabletEvents.axis.emit(SAxisEvent{
             .tool        = E.tool,
-            .tablet      = self.lock(),
+            .tablet      = m_self.lock(),
             .timeMs      = E.timeMs,
             .updatedAxes = aqUpdateToHl(E.updatedAxes),
             .axis        = E.absolute,
@@ -93,43 +93,43 @@ CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : tablet(tablet_) {
         });
     });
 
-    listeners.proximity = tablet->events.proximity.registerListener([this](std::any d) {
+    m_listeners.proximity = m_tablet->events.proximity.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::SProximityEvent>(d);
 
-        tabletEvents.proximity.emit(SProximityEvent{
+        m_tabletEvents.proximity.emit(SProximityEvent{
             .tool      = E.tool,
-            .tablet    = self.lock(),
+            .tablet    = m_self.lock(),
             .timeMs    = E.timeMs,
             .proximity = E.absolute,
             .in        = E.in,
         });
     });
 
-    listeners.tip = tablet->events.tip.registerListener([this](std::any d) {
+    m_listeners.tip = m_tablet->events.tip.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::STipEvent>(d);
 
-        tabletEvents.tip.emit(STipEvent{
+        m_tabletEvents.tip.emit(STipEvent{
             .tool   = E.tool,
-            .tablet = self.lock(),
+            .tablet = m_self.lock(),
             .timeMs = E.timeMs,
             .tip    = E.absolute,
             .in     = E.down,
         });
     });
 
-    listeners.button = tablet->events.button.registerListener([this](std::any d) {
+    m_listeners.button = m_tablet->events.button.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::SButtonEvent>(d);
 
-        tabletEvents.button.emit(SButtonEvent{
+        m_tabletEvents.button.emit(SButtonEvent{
             .tool   = E.tool,
-            .tablet = self.lock(),
+            .tablet = m_self.lock(),
             .timeMs = E.timeMs,
             .button = E.button,
             .down   = E.down,
         });
     });
 
-    deviceName = tablet->getName();
+    m_deviceName = m_tablet->getName();
 }
 
 CTablet::~CTablet() {
@@ -145,26 +145,26 @@ uint32_t CTabletPad::getCapabilities() {
 }
 
 SP<Aquamarine::ITabletPad> CTabletPad::aq() {
-    return pad.lock();
+    return m_pad.lock();
 }
 
 eHIDType CTabletPad::getType() {
     return HID_TYPE_TABLET_PAD;
 }
 
-CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
-    if (!pad)
+CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : m_pad(pad_) {
+    if (!m_pad)
         return;
 
-    listeners.destroy = pad->events.destroy.registerListener([this](std::any d) {
-        pad.reset();
-        events.destroy.emit();
+    m_listeners.destroy = m_pad->events.destroy.registerListener([this](std::any d) {
+        m_pad.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.button = pad->events.button.registerListener([this](std::any d) {
+    m_listeners.button = m_pad->events.button.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITabletPad::SButtonEvent>(d);
 
-        padEvents.button.emit(SButtonEvent{
+        m_padEvents.button.emit(SButtonEvent{
             .timeMs = E.timeMs,
             .button = E.button,
             .down   = E.down,
@@ -173,10 +173,10 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
         });
     });
 
-    listeners.ring = pad->events.ring.registerListener([this](std::any d) {
+    m_listeners.ring = m_pad->events.ring.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITabletPad::SRingEvent>(d);
 
-        padEvents.ring.emit(SRingEvent{
+        m_padEvents.ring.emit(SRingEvent{
             .timeMs   = E.timeMs,
             .finger   = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER,
             .ring     = E.ring,
@@ -185,10 +185,10 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
         });
     });
 
-    listeners.strip = pad->events.strip.registerListener([this](std::any d) {
+    m_listeners.strip = m_pad->events.strip.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITabletPad::SStripEvent>(d);
 
-        padEvents.strip.emit(SStripEvent{
+        m_padEvents.strip.emit(SStripEvent{
             .timeMs   = E.timeMs,
             .finger   = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER,
             .strip    = E.strip,
@@ -197,11 +197,11 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
         });
     });
 
-    listeners.attach = pad->events.attach.registerListener([](std::any d) {
+    m_listeners.attach = m_pad->events.attach.registerListener([](std::any d) {
         ; // TODO: this doesn't do anything in aq atm
     });
 
-    deviceName = pad->getName();
+    m_deviceName = m_pad->getName();
 }
 
 CTabletPad::~CTabletPad() {
@@ -213,36 +213,36 @@ uint32_t CTabletTool::getCapabilities() {
 }
 
 SP<Aquamarine::ITabletTool> CTabletTool::aq() {
-    return tool.lock();
+    return m_tool.lock();
 }
 
 eHIDType CTabletTool::getType() {
     return HID_TYPE_TABLET_TOOL;
 }
 
-CTabletTool::CTabletTool(SP<Aquamarine::ITabletTool> tool_) : tool(tool_) {
-    if (!tool)
+CTabletTool::CTabletTool(SP<Aquamarine::ITabletTool> tool_) : m_tool(tool_) {
+    if (!m_tool)
         return;
 
-    listeners.destroyTool = tool->events.destroy.registerListener([this](std::any d) {
-        tool.reset();
-        events.destroy.emit();
+    m_listeners.destroyTool = m_tool->events.destroy.registerListener([this](std::any d) {
+        m_tool.reset();
+        m_events.destroy.emit();
     });
 
-    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_TILT)
-        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_TILT;
-    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_PRESSURE)
-        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_PRESSURE;
-    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_DISTANCE)
-        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_DISTANCE;
-    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_ROTATION)
-        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_ROTATION;
-    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_SLIDER)
-        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_SLIDER;
-    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_WHEEL)
-        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_WHEEL;
+    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_TILT)
+        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_TILT;
+    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_PRESSURE)
+        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_PRESSURE;
+    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_DISTANCE)
+        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_DISTANCE;
+    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_ROTATION)
+        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_ROTATION;
+    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_SLIDER)
+        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_SLIDER;
+    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_WHEEL)
+        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_WHEEL;
 
-    deviceName = std::format("{:x}-{:x}", tool->serial, tool->id);
+    m_deviceName = std::format("{:x}-{:x}", m_tool->serial, m_tool->id);
 }
 
 CTabletTool::~CTabletTool() {
@@ -250,25 +250,25 @@ CTabletTool::~CTabletTool() {
 }
 
 SP<CWLSurfaceResource> CTabletTool::getSurface() {
-    return pSurface.lock();
+    return m_surface.lock();
 }
 
 void CTabletTool::setSurface(SP<CWLSurfaceResource> surf) {
-    if (surf == pSurface)
+    if (surf == m_surface)
         return;
 
-    if (pSurface) {
-        listeners.destroySurface.reset();
-        pSurface.reset();
+    if (m_surface) {
+        m_listeners.destroySurface.reset();
+        m_surface.reset();
     }
 
-    pSurface = surf;
+    m_surface = surf;
 
     if (surf) {
-        listeners.destroySurface = surf->events.destroy.registerListener([this](std::any d) {
-            PROTO::tablet->proximityOut(self.lock());
-            pSurface.reset();
-            listeners.destroySurface.reset();
+        m_listeners.destroySurface = surf->m_events.destroy.registerListener([this](std::any d) {
+            PROTO::tablet->proximityOut(m_self.lock());
+            m_surface.reset();
+            m_listeners.destroySurface.reset();
         });
     }
 }

src/devices/Tablet.hpp

@@ -86,20 +86,20 @@ class CTablet : public IHID {
         CSignal proximity;
         CSignal tip;
         CSignal button;
-    } tabletEvents;
+    } m_tabletEvents;
 
-    WP<CTablet> self;
+    WP<CTablet> m_self;
 
-    bool        relativeInput = false;
-    bool        absolutePos   = false;
-    std::string boundOutput   = "";
-    CBox        activeArea;
-    CBox        boundBox;
+    bool        m_relativeInput = false;
+    bool        m_absolutePos   = false;
+    std::string m_boundOutput   = "";
+    CBox        m_activeArea;
+    CBox        m_boundBox;
 
   private:
     CTablet(SP<Aquamarine::ITablet> tablet);
 
-    WP<Aquamarine::ITablet> tablet;
+    WP<Aquamarine::ITablet> m_tablet;
 
     struct {
         CHyprSignalListener destroy;
@@ -107,7 +107,7 @@ class CTablet : public IHID {
         CHyprSignalListener proximity;
         CHyprSignalListener tip;
         CHyprSignalListener button;
-    } listeners;
+    } m_listeners;
 };
 
 class CTabletPad : public IHID {
@@ -148,15 +148,15 @@ class CTabletPad : public IHID {
         CSignal ring;
         CSignal strip;
         CSignal attach;
-    } padEvents;
+    } m_padEvents;
 
-    WP<CTabletPad>  self;
-    WP<CTabletTool> parent;
+    WP<CTabletPad>  m_self;
+    WP<CTabletTool> m_parent;
 
   private:
     CTabletPad(SP<Aquamarine::ITabletPad> pad);
 
-    WP<Aquamarine::ITabletPad> pad;
+    WP<Aquamarine::ITabletPad> m_pad;
 
     struct {
         CHyprSignalListener destroy;
@@ -164,7 +164,7 @@ class CTabletPad : public IHID {
         CHyprSignalListener strip;
         CHyprSignalListener button;
         CHyprSignalListener attach;
-    } listeners;
+    } m_listeners;
 };
 
 class CTabletTool : public IHID {
@@ -198,23 +198,23 @@ class CTabletTool : public IHID {
     SP<CWLSurfaceResource>      getSurface();
     void                        setSurface(SP<CWLSurfaceResource>);
 
-    WP<CTabletTool>             self;
-    Vector2D                    tilt;
-    bool                        active           = false; // true if in proximity
-    uint32_t                    toolCapabilities = 0;
+    WP<CTabletTool>             m_self;
+    Vector2D                    m_tilt;
+    bool                        m_active           = false; // true if in proximity
+    uint32_t                    m_toolCapabilities = 0;
 
-    bool                        isDown = false;
-    std::vector<uint32_t>       buttonsDown;
-    Vector2D                    absolutePos; // last known absolute position.
+    bool                        m_isDown = false;
+    std::vector<uint32_t>       m_buttonsDown;
+    Vector2D                    m_absolutePos; // last known absolute position.
 
   private:
     CTabletTool(SP<Aquamarine::ITabletTool> tool);
 
-    WP<CWLSurfaceResource>      pSurface;
-    WP<Aquamarine::ITabletTool> tool;
+    WP<CWLSurfaceResource>      m_surface;
+    WP<Aquamarine::ITabletTool> m_tool;
 
     struct {
         CHyprSignalListener destroySurface;
         CHyprSignalListener destroyTool;
-    } listeners;
+    } m_listeners;
 };

src/devices/TouchDevice.cpp

@@ -5,62 +5,62 @@
 SP<CTouchDevice> CTouchDevice::create(SP<Aquamarine::ITouch> touch) {
     SP<CTouchDevice> pTouch = SP<CTouchDevice>(new CTouchDevice(touch));
 
-    pTouch->self = pTouch;
+    pTouch->m_self = pTouch;
 
     return pTouch;
 }
 
-CTouchDevice::CTouchDevice(SP<Aquamarine::ITouch> touch_) : touch(touch_) {
-    if (!touch)
+CTouchDevice::CTouchDevice(SP<Aquamarine::ITouch> touch_) : m_touch(touch_) {
+    if (!m_touch)
         return;
 
-    listeners.destroy = touch->events.destroy.registerListener([this](std::any d) {
-        events.destroy.emit();
-        touch.reset();
+    m_listeners.destroy = m_touch->events.destroy.registerListener([this](std::any d) {
+        m_events.destroy.emit();
+        m_touch.reset();
     });
 
-    listeners.down = touch->events.down.registerListener([this](std::any d) {
+    m_listeners.down = m_touch->events.down.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SDownEvent>(d);
 
-        touchEvents.down.emit(SDownEvent{
+        m_touchEvents.down.emit(SDownEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
             .pos     = E.pos,
-            .device  = self.lock(),
+            .device  = m_self.lock(),
         });
     });
 
-    listeners.up = touch->events.up.registerListener([this](std::any d) {
+    m_listeners.up = m_touch->events.up.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SUpEvent>(d);
 
-        touchEvents.up.emit(SUpEvent{
+        m_touchEvents.up.emit(SUpEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
         });
     });
 
-    listeners.motion = touch->events.move.registerListener([this](std::any d) {
+    m_listeners.motion = m_touch->events.move.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SMotionEvent>(d);
 
-        touchEvents.motion.emit(SMotionEvent{
+        m_touchEvents.motion.emit(SMotionEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
             .pos     = E.pos,
         });
     });
 
-    listeners.cancel = touch->events.cancel.registerListener([this](std::any d) {
+    m_listeners.cancel = m_touch->events.cancel.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SCancelEvent>(d);
 
-        touchEvents.cancel.emit(SCancelEvent{
+        m_touchEvents.cancel.emit(SCancelEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
         });
     });
 
-    listeners.frame = touch->events.frame.registerListener([this](std::any d) { touchEvents.frame.emit(); });
+    m_listeners.frame = m_touch->events.frame.registerListener([this](std::any d) { m_touchEvents.frame.emit(); });
 
-    deviceName = touch->getName();
+    m_deviceName = m_touch->getName();
 }
 
 bool CTouchDevice::isVirtual() {
@@ -68,5 +68,5 @@ bool CTouchDevice::isVirtual() {
 }
 
 SP<Aquamarine::ITouch> CTouchDevice::aq() {
-    return touch.lock();
+    return m_touch.lock();
 }

src/devices/TouchDevice.hpp

@@ -12,7 +12,7 @@ class CTouchDevice : public ITouch {
   private:
     CTouchDevice(SP<Aquamarine::ITouch> touch);
 
-    WP<Aquamarine::ITouch> touch;
+    WP<Aquamarine::ITouch> m_touch;
 
     struct {
         CHyprSignalListener destroy;
@@ -21,5 +21,5 @@ class CTouchDevice : public ITouch {
         CHyprSignalListener motion;
         CHyprSignalListener cancel;
         CHyprSignalListener frame;
-    } listeners;
+    } m_listeners;
 };

src/devices/VirtualKeyboard.cpp

@@ -5,43 +5,43 @@
 SP<CVirtualKeyboard> CVirtualKeyboard::create(SP<CVirtualKeyboardV1Resource> keeb) {
     SP<CVirtualKeyboard> pKeeb = SP<CVirtualKeyboard>(new CVirtualKeyboard(keeb));
 
-    pKeeb->self = pKeeb;
+    pKeeb->m_self = pKeeb;
 
     return pKeeb;
 }
 
-CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : keyboard(keeb_) {
+CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : m_keyboard(keeb_) {
     if (!keeb_)
         return;
 
-    listeners.destroy = keeb_->events.destroy.registerListener([this](std::any d) {
-        keyboard.reset();
-        events.destroy.emit();
+    m_listeners.destroy = keeb_->m_events.destroy.registerListener([this](std::any d) {
+        m_keyboard.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.key       = keeb_->events.key.registerListener([this](std::any d) { keyboardEvents.key.emit(d); });
-    listeners.modifiers = keeb_->events.modifiers.registerListener([this](std::any d) {
+    m_listeners.key       = keeb_->m_events.key.registerListener([this](std::any d) { m_keyboardEvents.key.emit(d); });
+    m_listeners.modifiers = keeb_->m_events.modifiers.registerListener([this](std::any d) {
         auto E = std::any_cast<SModifiersEvent>(d);
         updateModifiers(E.depressed, E.latched, E.locked, E.group);
-        keyboardEvents.modifiers.emit(SModifiersEvent{
-            .depressed = modifiersState.depressed,
-            .latched   = modifiersState.latched,
-            .locked    = modifiersState.locked,
-            .group     = modifiersState.group,
+        m_keyboardEvents.modifiers.emit(SModifiersEvent{
+            .depressed = m_modifiersState.depressed,
+            .latched   = m_modifiersState.latched,
+            .locked    = m_modifiersState.locked,
+            .group     = m_modifiersState.group,
         });
     });
-    listeners.keymap    = keeb_->events.keymap.registerListener([this](std::any d) {
+    m_listeners.keymap    = keeb_->m_events.keymap.registerListener([this](std::any d) {
         auto E = std::any_cast<SKeymapEvent>(d);
-        if (xkbKeymap)
-            xkb_keymap_unref(xkbKeymap);
-        xkbKeymap        = xkb_keymap_ref(E.keymap);
-        keymapOverridden = true;
-        updateXKBTranslationState(xkbKeymap);
+        if (m_xkbKeymap)
+            xkb_keymap_unref(m_xkbKeymap);
+        m_xkbKeymap        = xkb_keymap_ref(E.keymap);
+        m_keymapOverridden = true;
+        updateXKBTranslationState(m_xkbKeymap);
         updateKeymapFD();
-        keyboardEvents.keymap.emit(d);
+        m_keyboardEvents.keymap.emit(d);
     });
 
-    deviceName = keeb_->name;
+    m_deviceName = keeb_->m_name;
 }
 
 bool CVirtualKeyboard::isVirtual() {
@@ -53,7 +53,7 @@ SP<Aquamarine::IKeyboard> CVirtualKeyboard::aq() {
 }
 
 wl_client* CVirtualKeyboard::getClient() {
-    if (keyboard.expired())
+    if (m_keyboard.expired())
         return nullptr;
-    return keyboard->client();
+    return m_keyboard->client();
 }

src/devices/VirtualKeyboard.hpp

@@ -16,12 +16,12 @@ class CVirtualKeyboard : public IKeyboard {
   private:
     CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb);
 
-    WP<CVirtualKeyboardV1Resource> keyboard;
+    WP<CVirtualKeyboardV1Resource> m_keyboard;
 
     struct {
         CHyprSignalListener destroy;
         CHyprSignalListener key;
         CHyprSignalListener modifiers;
         CHyprSignalListener keymap;
-    } listeners;
+    } m_listeners;
 };

src/devices/VirtualPointer.cpp

@@ -5,46 +5,46 @@
 SP<CVirtualPointer> CVirtualPointer::create(SP<CVirtualPointerV1Resource> resource) {
     SP<CVirtualPointer> pPointer = SP<CVirtualPointer>(new CVirtualPointer(resource));
 
-    pPointer->self = pPointer;
+    pPointer->m_self = pPointer;
 
     return pPointer;
 }
 
-CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : pointer(resource) {
+CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : m_pointer(resource) {
     if UNLIKELY (!resource->good())
         return;
 
-    listeners.destroy = pointer->events.destroy.registerListener([this](std::any d) {
-        pointer.reset();
-        events.destroy.emit();
+    m_listeners.destroy = m_pointer->m_events.destroy.registerListener([this](std::any d) {
+        m_pointer.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.motion         = pointer->events.move.registerListener([this](std::any d) {
+    m_listeners.motion         = m_pointer->m_events.move.registerListener([this](std::any d) {
         auto E   = std::any_cast<SMotionEvent>(d);
-        E.device = self.lock();
-        pointerEvents.motion.emit(E);
+        E.device = m_self.lock();
+        m_pointerEvents.motion.emit(E);
     });
-    listeners.motionAbsolute = pointer->events.warp.registerListener([this](std::any d) {
+    m_listeners.motionAbsolute = m_pointer->m_events.warp.registerListener([this](std::any d) {
         // we need to unpack the event and add our device here because it's required to calculate the position correctly
         auto E   = std::any_cast<SMotionAbsoluteEvent>(d);
-        E.device = self.lock();
-        pointerEvents.motionAbsolute.emit(E);
+        E.device = m_self.lock();
+        m_pointerEvents.motionAbsolute.emit(E);
     });
-    listeners.button         = pointer->events.button.registerListener([this](std::any d) { pointerEvents.button.emit(d); });
-    listeners.axis           = pointer->events.axis.registerListener([this](std::any d) { pointerEvents.axis.emit(d); });
-    listeners.frame          = pointer->events.frame.registerListener([this](std::any d) { pointerEvents.frame.emit(); });
-    listeners.swipeBegin     = pointer->events.swipeBegin.registerListener([this](std::any d) { pointerEvents.swipeBegin.emit(d); });
-    listeners.swipeEnd       = pointer->events.swipeEnd.registerListener([this](std::any d) { pointerEvents.swipeEnd.emit(d); });
-    listeners.swipeUpdate    = pointer->events.swipeUpdate.registerListener([this](std::any d) { pointerEvents.swipeUpdate.emit(d); });
-    listeners.pinchBegin     = pointer->events.pinchBegin.registerListener([this](std::any d) { pointerEvents.pinchBegin.emit(d); });
-    listeners.pinchEnd       = pointer->events.pinchEnd.registerListener([this](std::any d) { pointerEvents.pinchEnd.emit(d); });
-    listeners.pinchUpdate    = pointer->events.pinchUpdate.registerListener([this](std::any d) { pointerEvents.pinchUpdate.emit(d); });
-    listeners.holdBegin      = pointer->events.holdBegin.registerListener([this](std::any d) { pointerEvents.holdBegin.emit(d); });
-    listeners.holdEnd        = pointer->events.holdEnd.registerListener([this](std::any d) { pointerEvents.holdEnd.emit(d); });
+    m_listeners.button         = m_pointer->m_events.button.registerListener([this](std::any d) { m_pointerEvents.button.emit(d); });
+    m_listeners.axis           = m_pointer->m_events.axis.registerListener([this](std::any d) { m_pointerEvents.axis.emit(d); });
+    m_listeners.frame          = m_pointer->m_events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); });
+    m_listeners.swipeBegin     = m_pointer->m_events.swipeBegin.registerListener([this](std::any d) { m_pointerEvents.swipeBegin.emit(d); });
+    m_listeners.swipeEnd       = m_pointer->m_events.swipeEnd.registerListener([this](std::any d) { m_pointerEvents.swipeEnd.emit(d); });
+    m_listeners.swipeUpdate    = m_pointer->m_events.swipeUpdate.registerListener([this](std::any d) { m_pointerEvents.swipeUpdate.emit(d); });
+    m_listeners.pinchBegin     = m_pointer->m_events.pinchBegin.registerListener([this](std::any d) { m_pointerEvents.pinchBegin.emit(d); });
+    m_listeners.pinchEnd       = m_pointer->m_events.pinchEnd.registerListener([this](std::any d) { m_pointerEvents.pinchEnd.emit(d); });
+    m_listeners.pinchUpdate    = m_pointer->m_events.pinchUpdate.registerListener([this](std::any d) { m_pointerEvents.pinchUpdate.emit(d); });
+    m_listeners.holdBegin      = m_pointer->m_events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); });
+    m_listeners.holdEnd        = m_pointer->m_events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); });
 
-    boundOutput = resource->boundOutput ? resource->boundOutput->szName : "";
+    m_boundOutput = resource->m_boundOutput ? resource->m_boundOutput->m_name : "";
 
-    deviceName = pointer->name;
+    m_deviceName = m_pointer->m_name;
 }
 
 bool CVirtualPointer::isVirtual() {

src/devices/VirtualPointer.hpp

@@ -14,7 +14,7 @@ class CVirtualPointer : public IPointer {
   private:
     CVirtualPointer(SP<CVirtualPointerV1Resource>);
 
-    WP<CVirtualPointerV1Resource> pointer;
+    WP<CVirtualPointerV1Resource> m_pointer;
 
     struct {
         CHyprSignalListener destroy;
@@ -35,5 +35,5 @@ class CVirtualPointer : public IPointer {
 
         CHyprSignalListener holdBegin;
         CHyprSignalListener holdEnd;
-    } listeners;
+    } m_listeners;
 };

src/helpers/AsyncDialogBox.cpp

@@ -0,0 +1,134 @@
+#include "AsyncDialogBox.hpp"
+#include "./fs/FsUtils.hpp"
+#include <csignal>
+#include <algorithm>
+#include <unistd.h>
+#include "../managers/eventLoop/EventLoopManager.hpp"
+
+using namespace Hyprutils::OS;
+
+static std::vector<pid_t> asyncDialogBoxes;
+
+//
+SP<CAsyncDialogBox> CAsyncDialogBox::create(const std::string& title, const std::string& description, std::vector<std::string> buttons) {
+    if (!NFsUtils::executableExistsInPath("hyprland-dialog")) {
+        Debug::log(ERR, "CAsyncDialogBox: cannot create, no hyprland-dialog");
+        return nullptr;
+    }
+
+    auto dialog = SP<CAsyncDialogBox>(new CAsyncDialogBox(title, description, buttons));
+
+    dialog->m_selfWeakReference = dialog;
+
+    return dialog;
+}
+
+bool CAsyncDialogBox::isAsyncDialogBox(pid_t pid) {
+    return std::ranges::contains(asyncDialogBoxes, pid);
+}
+
+CAsyncDialogBox::CAsyncDialogBox(const std::string& title, const std::string& description, std::vector<std::string> buttons) :
+    m_title(title), m_description(description), m_buttons(buttons) {
+    ;
+}
+
+static int onFdWrite(int fd, uint32_t mask, void* data) {
+    auto box = (CAsyncDialogBox*)data;
+
+    box->onWrite(fd, mask);
+
+    return 0;
+}
+
+void CAsyncDialogBox::onWrite(int fd, uint32_t mask) {
+    if (mask & WL_EVENT_READABLE) {
+        std::array<char, 1024> buf;
+        int                    ret = 0;
+
+        // make the FD nonblock for a moment
+        // TODO: can we avoid this without risking a blocking read()?
+        int fdFlags = fcntl(fd, F_GETFL, 0);
+        if (fcntl(fd, F_SETFL, fdFlags | O_NONBLOCK) < 0) {
+            Debug::log(ERR, "CAsyncDialogBox::onWrite: fcntl 1 failed!");
+            return;
+        }
+
+        while ((ret = read(m_pipeReadFd.get(), buf.data(), 1023)) > 0) {
+            m_stdout += std::string_view{(char*)buf.data(), (size_t)ret};
+        }
+
+        // restore the flags (otherwise libwayland wont give us a hangup)
+        if (fcntl(fd, F_SETFL, fdFlags) < 0) {
+            Debug::log(ERR, "CAsyncDialogBox::onWrite: fcntl 2 failed!");
+            return;
+        }
+    }
+
+    if (mask & (WL_EVENT_HANGUP | WL_EVENT_ERROR)) {
+        Debug::log(LOG, "CAsyncDialogBox: dialog {:x} hung up, closed.");
+
+        m_promiseResolver->resolve(m_stdout);
+        std::erase(asyncDialogBoxes, m_dialogPid);
+
+        wl_event_source_remove(m_readEventSource);
+        m_selfReference.reset();
+        return;
+    }
+}
+
+SP<CPromise<std::string>> CAsyncDialogBox::open() {
+    std::string buttonsString = "";
+    for (auto& b : m_buttons) {
+        buttonsString += b + ";";
+    }
+    if (!buttonsString.empty())
+        buttonsString.pop_back();
+
+    CProcess proc("hyprland-dialog", std::vector<std::string>{"--title", m_title, "--text", m_description, "--buttons", buttonsString});
+
+    int      outPipe[2];
+    if (pipe(outPipe)) {
+        Debug::log(ERR, "CAsyncDialogBox::open: failed to pipe()");
+        return nullptr;
+    }
+
+    m_pipeReadFd = CFileDescriptor(outPipe[0]);
+
+    proc.setStdoutFD(outPipe[1]);
+
+    m_readEventSource = wl_event_loop_add_fd(g_pEventLoopManager->m_wayland.loop, m_pipeReadFd.get(), WL_EVENT_READABLE, ::onFdWrite, this);
+
+    if (!m_readEventSource) {
+        Debug::log(ERR, "CAsyncDialogBox::open: failed to add read fd to loop");
+        return nullptr;
+    }
+
+    m_selfReference = m_selfWeakReference.lock();
+
+    if (!proc.runAsync()) {
+        Debug::log(ERR, "CAsyncDialogBox::open: failed to run async");
+        wl_event_source_remove(m_readEventSource);
+        return nullptr;
+    }
+
+    m_dialogPid = proc.pid();
+    asyncDialogBoxes.emplace_back(m_dialogPid);
+
+    // close the write fd, only the dialog owns it now
+    close(outPipe[1]);
+
+    auto promise = CPromise<std::string>::make([this](SP<CPromiseResolver<std::string>> r) { m_promiseResolver = r; });
+
+    return promise;
+}
+
+void CAsyncDialogBox::kill() {
+    if (m_dialogPid <= 0)
+        return;
+
+    ::kill(m_dialogPid, SIGKILL);
+}
+
+bool CAsyncDialogBox::isRunning() const {
+    return m_readEventSource;
+}

src/helpers/AsyncDialogBox.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "../macros.hpp"
+#include "./memory/Memory.hpp"
+#include "./defer/Promise.hpp"
+
+#include <vector>
+#include <functional>
+
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/os/FileDescriptor.hpp>
+
+struct wl_event_source;
+
+class CAsyncDialogBox {
+  public:
+    static SP<CAsyncDialogBox> create(const std::string& title, const std::string& description, std::vector<std::string> buttons);
+    static bool                isAsyncDialogBox(pid_t pid);
+
+    CAsyncDialogBox(const CAsyncDialogBox&)                     = delete;
+    CAsyncDialogBox(CAsyncDialogBox&&)                          = delete;
+    CAsyncDialogBox&          operator=(const CAsyncDialogBox&) = delete;
+    CAsyncDialogBox&          operator=(CAsyncDialogBox&&)      = delete;
+
+    SP<CPromise<std::string>> open();
+    void                      kill();
+    bool                      isRunning() const;
+
+    void                      onWrite(int fd, uint32_t mask);
+
+  private:
+    CAsyncDialogBox(const std::string& title, const std::string& description, std::vector<std::string> buttons);
+
+    pid_t                             m_dialogPid       = 0;
+    wl_event_source*                  m_readEventSource = nullptr;
+    Hyprutils::OS::CFileDescriptor    m_pipeReadFd;
+    std::string                       m_stdout = "";
+
+    const std::string                 m_title;
+    const std::string                 m_description;
+    const std::vector<std::string>    m_buttons;
+
+    SP<CPromiseResolver<std::string>> m_promiseResolver;
+
+    // WARNING: cyclic reference. This will be removed once the event source is removed to avoid dangling pointers
+    SP<CAsyncDialogBox> m_selfReference;
+    WP<CAsyncDialogBox> m_selfWeakReference;
+};

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 {

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

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();
 }

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;
 };

src/helpers/MiscFunctions.cpp

@@ -122,7 +122,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             const auto NAME = in.substr(8);
             const auto WS   = g_pCompositor->getWorkspaceByName("special:" + NAME);
 
-            return {WS ? WS->m_iID : g_pCompositor->getNewSpecialID(), "special:" + NAME};
+            return {WS ? WS->m_id : g_pCompositor->getNewSpecialID(), "special:" + NAME};
         }
 
         result.id = SPECIAL_WORKSPACE_START;
@@ -133,13 +133,13 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (!WORKSPACE) {
             result.id = g_pCompositor->getNextAvailableNamedWorkspace();
         } else {
-            result.id = WORKSPACE->m_iID;
+            result.id = WORKSPACE->m_id;
         }
         result.name = WORKSPACENAME;
     } else if (in.starts_with("empty")) {
         const bool same_mon = in.substr(5).contains("m");
         const bool next     = in.substr(5).contains("n");
-        if ((same_mon || next) && !g_pCompositor->m_pLastMonitor) {
+        if ((same_mon || next) && !g_pCompositor->m_lastMonitor) {
             Debug::log(ERR, "Empty monitor workspace on monitor null!");
             return {WORKSPACE_INVALID};
         }
@@ -148,12 +148,12 @@ 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_pLastMonitor->ID))
+                if (PMONITOR && (PMONITOR->m_id != g_pCompositor->m_lastMonitor->m_id))
                     invalidWSes.insert(rule.workspaceId);
             }
         }
 
-        WORKSPACEID id = next ? g_pCompositor->m_pLastMonitor->activeWorkspaceID() : 0;
+        WORKSPACEID id = next ? g_pCompositor->m_lastMonitor->activeWorkspaceID() : 0;
         while (++id < LONG_MAX) {
             const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(id);
             if (!invalidWSes.contains(id) && (!PWORKSPACE || PWORKSPACE->getWindows() == 0)) {
@@ -162,24 +162,47 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             }
         }
     } else if (in.starts_with("prev")) {
-        if (!g_pCompositor->m_pLastMonitor)
+        if (!g_pCompositor->m_lastMonitor)
             return {WORKSPACE_INVALID};
 
-        const auto PWORKSPACE = g_pCompositor->m_pLastMonitor->activeWorkspace;
+        const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
         if (!valid(PWORKSPACE))
             return {WORKSPACE_INVALID};
 
-        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PWORKSPACE->getPrevWorkspaceIDName().id);
+        const auto PREVWORKSPACEIDNAME = PWORKSPACE->getPrevWorkspaceIDName();
 
-        if (!PLASTWORKSPACE)
+        if (PREVWORKSPACEIDNAME.id == -1)
             return {WORKSPACE_INVALID};
 
-        return {PLASTWORKSPACE->m_iID, PLASTWORKSPACE->m_szName};
+        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PREVWORKSPACEIDNAME.id);
+
+        if (!PLASTWORKSPACE) {
+            Debug::log(LOG, "previous workspace {} doesn't exist yet", PREVWORKSPACEIDNAME.id);
+            return {PREVWORKSPACEIDNAME.id, PREVWORKSPACEIDNAME.name};
+        }
+
+        return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name};
+    } else if (in == "next") {
+        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->m_activeWorkspace;
+
+        WORKSPACEID nextId = PCURRENTWORKSPACE->m_id + 1;
+
+        if (nextId <= 0)
+            return {WORKSPACE_INVALID};
+
+        result.id   = nextId;
+        result.name = std::to_string(nextId);
+        return result;
     } else {
         if (in[0] == 'r' && (in[1] == '-' || in[1] == '+' || in[1] == '~') && isNumber(in.substr(2))) {
             bool absolute = in[1] == '~';
-            if (!g_pCompositor->m_pLastMonitor) {
+            if (!g_pCompositor->m_lastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
                 return {WORKSPACE_INVALID};
             }
@@ -196,15 +219,15 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             std::set<WORKSPACEID> invalidWSes;
 
             // Collect all the workspaces we can't jump to.
-            for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor)) {
+            for (auto const& ws : g_pCompositor->m_workspaces) {
+                if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor)) {
                     // Can't jump to this workspace
-                    invalidWSes.insert(ws->m_iID);
+                    invalidWSes.insert(ws->m_id);
                 }
             }
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (!PMONITOR || PMONITOR->ID == g_pCompositor->m_pLastMonitor->ID) {
+                if (!PMONITOR || PMONITOR->m_id == g_pCompositor->m_lastMonitor->m_id) {
                     // Can't be invalid
                     continue;
                 }
@@ -214,11 +237,11 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
             // Prepare all named workspaces in case when we need them
             std::vector<WORKSPACEID> namedWSes;
-            for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor) || ws->m_iID >= 0)
+            for (auto const& ws : g_pCompositor->m_workspaces) {
+                if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor) || ws->m_id >= 0)
                     continue;
 
-                namedWSes.push_back(ws->m_iID);
+                namedWSes.push_back(ws->m_id);
             }
             std::sort(namedWSes.begin(), namedWSes.end());
 
@@ -242,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_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 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];
@@ -333,7 +356,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
             const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(result.id);
             if (PWORKSPACE)
-                result.name = g_pCompositor->getWorkspaceByID(result.id)->m_szName;
+                result.name = g_pCompositor->getWorkspaceByID(result.id)->m_name;
             else
                 result.name = std::to_string(result.id);
 
@@ -341,7 +364,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             bool onAllMonitors = in[0] == 'e';
             bool absolute      = in[1] == '~';
 
-            if (!g_pCompositor->m_pLastMonitor) {
+            if (!g_pCompositor->m_lastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
                 return {WORKSPACE_INVALID};
             }
@@ -358,11 +381,11 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             int                      remains = (int)result.id;
 
             std::vector<WORKSPACEID> validWSes;
-            for (auto const& ws : g_pCompositor->m_vWorkspaces) {
-                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor && !onAllMonitors))
+            for (auto const& ws : g_pCompositor->m_workspaces) {
+                if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor && !onAllMonitors))
                     continue;
 
-                validWSes.push_back(ws->m_iID);
+                validWSes.push_back(ws->m_id);
             }
 
             std::sort(validWSes.begin(), validWSes.end());
@@ -384,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_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 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;
@@ -404,11 +427,11 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             }
 
             result.id   = validWSes[currentItem];
-            result.name = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_szName;
+            result.name = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_name;
         } else {
             if (in[0] == '+' || in[0] == '-') {
-                if (g_pCompositor->m_pLastMonitor) {
-                    const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspaceID());
+                if (g_pCompositor->m_lastMonitor) {
+                    const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in, g_pCompositor->m_lastMonitor->activeWorkspaceID());
                     if (!PLUSMINUSRESULT.has_value())
                         return {WORKSPACE_INVALID};
 
@@ -423,7 +446,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
                 // maybe name
                 const auto PWORKSPACE = g_pCompositor->getWorkspaceByName(in);
                 if (PWORKSPACE)
-                    result.id = PWORKSPACE->m_iID;
+                    result.id = PWORKSPACE->m_id;
             }
 
             result.name = std::to_string(result.id);
@@ -817,3 +840,38 @@ float stringToPercentage(const std::string& VALUE, const float REL) {
     else
         return std::stof(VALUE);
 }
+
+// Checks if Nvidia driver major version is at least given version.
+// Useful for explicit_sync_kms and ctm_animation as they only work
+// past certain driver versions.
+bool isNvidiaDriverVersionAtLeast(int threshold) {
+    static int  driverMajor = 0;
+    static bool once        = true;
+
+    if (once) {
+        once = false;
+
+        std::error_code ec;
+        if (std::filesystem::exists("/sys/module/nvidia_drm/version", ec) && !ec) {
+            std::ifstream ifs("/sys/module/nvidia_drm/version");
+            if (ifs.good()) {
+                try {
+                    std::string driverInfo((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
+
+                    size_t      firstDot = driverInfo.find('.');
+                    if (firstDot != std::string::npos)
+                        driverMajor = std::stoi(driverInfo.substr(0, firstDot));
+
+                    Debug::log(LOG, "Parsed NVIDIA major version: {}", driverMajor);
+
+                } catch (std::exception& e) {
+                    driverMajor = 0; // Default to 0 if parsing fails
+                }
+
+                ifs.close();
+            }
+        }
+    }
+
+    return driverMajor >= threshold;
+}

src/helpers/MiscFunctions.hpp

@@ -39,6 +39,7 @@ bool                                envEnabled(const std::string& env);
 Hyprutils::OS::CFileDescriptor      allocateSHMFile(size_t len);
 bool                                allocateSHMFilePair(size_t size, Hyprutils::OS::CFileDescriptor& rw_fd_ptr, Hyprutils::OS::CFileDescriptor& ro_fd_ptr);
 float                               stringToPercentage(const std::string& VALUE, const float REL);
+bool                                isNvidiaDriverVersionAtLeast(int threshold);
 
 template <typename... Args>
 [[deprecated("use std::format instead")]] std::string getFormat(std::format_string<Args...> fmt, Args&&... args) {