flake.lock: update

version: bump to 0.47.2
desktop: move popups to UPs and fix missing subsurface resource
2025-07-29 11:11:55 -07:00 · 2025-02-23 14:19:45 +02:00 · 2025-02-02 00:47:17 +00:00 · 2025-02-02 00:47:17 +00:00 · 2025-02-02 00:47:17 +00:00 · 2025-02-02 00:47:17 +00:00
303 changed files with 10659 additions and 5338 deletions
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -5,10 +5,10 @@ body:
  - type: checkboxes
    attributes:
      label: Already reported ? *
-      description: Before opening a new bug report, please take a moment to search through the current open and closed issues to check if it already exists.
+      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.
      options:
-      - label: I have searched the existing open and closed issues.
-        required: true
+        - label: I have searched the existing open and closed issues.
+          required: true

  - type: dropdown
    id: type
@@ -19,27 +19,28 @@ body:
        **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:
-        - "Yes"
-        - "No"
+        - "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
    attributes:
-      label: System Info and Version
+      label: System Info and Hyprland Version
      description: |
-        Paste the output of `hyprctl systeminfo -c` here. If you can't
+        Paste the output of `hyprctl systeminfo` here. If you can't
        launch Hyprland, paste the output of `Hyprland --systeminfo`.
-        If `Hyprland --systeminfo` errors out (added in 0.44.0), find
-        and paste the Hyprland version manually.
      value: "<details>
        <summary>System/Version info</summary>


-        ```sh
-        
-        <Paste the output of the command here>
+        ```
+
+        <Paste the output of the command here, without removing any formatting around this>

        ```

@@ -61,15 +62,56 @@ body:
    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: Crash reports, logs, images, videos
+      label: Additional info & File uploads
      description: |
-        Anything that can help. Please always ATTACH and not paste them.
-        Logs can be found in $XDG_RUNTIME_DIR/hypr
-        Crash reports are stored in ~/.cache/hyprland or $XDG_CACHE_HOME/hyprland
-
+        Tip: You can attach files by clicking this area to highlight it and then dragging files in.
--- a/.github/actions/setup_base/action.yml
+++ b/.github/actions/setup_base/action.yml
@@ -63,6 +63,15 @@ 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: |
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -107,6 +107,7 @@ jobs:
        run: make release

  clang-format:
+    permissions: read-all
    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
    name: "Code Style (Arch)"
    runs-on: ubuntu-latest
@@ -126,3 +127,27 @@ jobs:

      - name: clang-format check
        run: ninja -C build clang-format-check
+
+      - name: clang-format apply
+        if: ${{ failure() && github.event_name == 'pull_request' }}
+        run: ninja -C build clang-format
+
+      - name: Create patch
+        if: ${{ failure() && github.event_name == 'pull_request' }}
+        run: |
+          echo 'Please fix the formatting issues by running [`clang-format`](https://wiki.hyprland.org/Contributing-and-Debugging/PR-Guidelines/#code-style), or directly apply this patch:' > clang-format.patch
+          echo '<details>' >> clang-format.patch
+          echo '<summary>clang-format.patch</summary>' >> clang-format.patch
+          echo >> clang-format.patch
+          echo '```diff' >> clang-format.patch
+          git diff >> clang-format.patch
+          echo '```' >> clang-format.patch
+          echo >> clang-format.patch
+          echo '</details>' >> clang-format.patch
+
+      - name: Comment patch
+        if: ${{ failure() && github.event_name == 'pull_request' }}
+        uses: mshick/add-pr-comment@v2
+        with:
+          message-path: |
+            clang-format.patch
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -104,7 +104,7 @@ find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.4.5)
 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.2.3)
+pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.5.0)
 pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)

 add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}")
@@ -197,6 +197,12 @@ if(NOT HAS_TIMERFD AND epoll_FOUND)
  target_link_libraries(Hyprland PkgConfig::epoll)
 endif()

+check_include_file("sys/inotify.h" HAS_INOTIFY)
+pkg_check_modules(inotify IMPORTED_TARGET libinotify)
+if(NOT HAS_INOTIFY AND inotify_FOUND)
+  target_link_libraries(Hyprland PkgConfig::inotify)
+endif()
+
 if(LEGACY_RENDERER)
  message(STATUS "Using the legacy GLES2 renderer!")
  add_compile_definitions(LEGACY_RENDERER)
@@ -248,7 +254,15 @@ target_precompile_headers(Hyprland PRIVATE

 message(STATUS "Setting link libraries")

-target_link_libraries(Hyprland rt PkgConfig::aquamarine_dep PkgConfig::hyprlang_dep PkgConfig::hyprutils_dep PkgConfig::hyprcursor_dep PkgConfig::hyprgraphics_dep PkgConfig::deps)
+target_link_libraries(
+  Hyprland
+  rt
+  PkgConfig::aquamarine_dep
+  PkgConfig::hyprlang_dep
+  PkgConfig::hyprutils_dep
+  PkgConfig::hyprcursor_dep
+  PkgConfig::hyprgraphics_dep
+  PkgConfig::deps)
 if(udis_dep_FOUND)
  target_link_libraries(Hyprland PkgConfig::udis_dep)
 else()
@@ -290,7 +304,7 @@ endfunction()

 target_link_libraries(Hyprland OpenGL::EGL OpenGL::GL Threads::Threads)

-pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.4.0)
+pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.0)
 if(hyprland_protocols_dep_FOUND)
  pkg_get_variable(HYPRLAND_PROTOCOLS hyprland-protocols pkgdatadir)
  message(STATUS "hyprland-protocols dependency set to ${HYPRLAND_PROTOCOLS}")
@@ -316,8 +330,12 @@ protocolnew("protocols" "kde-server-decoration" true)
 protocolnew("protocols" "wlr-data-control-unstable-v1" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-focus-grab-v1" true)
 protocolnew("protocols" "wlr-layer-shell-unstable-v1" true)
+protocolnew("protocols" "xx-color-management-v4" true)
+protocolnew("protocols" "frog-color-management-v1" true)
 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("staging/tearing-control" "tearing-control-v1" false)
 protocolnew("staging/fractional-scale" "fractional-scale-v1" false)
@@ -355,7 +373,13 @@ protocolwayland()

 # tools
 add_subdirectory(hyprctl)
-add_subdirectory(hyprpm)
+
+if(NO_HYPRPM)
+  message(STATUS "hyprpm is disabled")
+else()
+  add_subdirectory(hyprpm)
+  message(STATUS "hyprpm is enabled (NO_HYPRPM not defined)")
+endif()

 # binary and symlink
 install(TARGETS Hyprland)
@@ -366,7 +390,6 @@ install(
        ${CMAKE_INSTALL_FULL_BINDIR}/Hyprland \
        \"\$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/hyprland\" \
        )")
-
 # session file
 install(FILES ${CMAKE_SOURCE_DIR}/example/hyprland.desktop
        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/wayland-sessions)
--- a/2
+++ b/2
@@ -1 +1 @@
-0.46.2
+0.47.2
--- a/example/hyprland.conf
+++ b/example/hyprland.conf
@@ -81,6 +81,7 @@ general {
 # https://wiki.hyprland.org/Configuring/Variables/#decoration
 decoration {
    rounding = 10
+    rounding_power = 2

    # Change transparency of focused and unfocused windows
    active_opacity = 1.0
--- a/example/launch.json
+++ b/example/launch.json
@@ -22,5 +22,6 @@
                }
            ]
        },
+        
    ]
 }
--- a/flake.lock
+++ b/flake.lock
@@ -16,11 +16,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1734364797,
-        "narHash": "sha256-2h1c+P0v3l0Z/ypUSsAPhU/yiSRgFwjVFODWp0S3d/w=",
+        "lastModified": 1737636397,
+        "narHash": "sha256-F5MbBj3QVorycVSFE9qjuOTLtIQBqt2VWbXa0uwzm98=",
        "owner": "hyprwm",
        "repo": "aquamarine",
-        "rev": "8e77618b403a82fde2105a8e3cd7cabe7ef00952",
+        "rev": "7fe006981fae53e931f513026fc754e322f13145",
        "type": "github"
      },
      "original": {
@@ -79,11 +79,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1734364709,
-        "narHash": "sha256-+2bZJL2u5hva7rSp65OfKJBK+k03T6GB/NCvpoS1OOo=",
+        "lastModified": 1737634937,
+        "narHash": "sha256-Ffw4ujFpi++6pPHe+gCBOfDgAoNlzVPZN6MReC1beu8=",
        "owner": "hyprwm",
        "repo": "hyprcursor",
-        "rev": "f388aacd22be4a6e4d634fbaf6f75eb0713d239a",
+        "rev": "9c5dd1f7c825ee47f72727ad0a4e16ca46a2688e",
        "type": "github"
      },
      "original": {
@@ -105,11 +105,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1733684019,
-        "narHash": "sha256-2kYREgmSmbLsmDpLEq96hxVAU3qz8aCvVhF65yCFZHY=",
+        "lastModified": 1737634889,
+        "narHash": "sha256-9JZE3KxcXOqZH9zs3UeadngDiK/yIACTiAR8HSA/TNI=",
        "owner": "hyprwm",
        "repo": "hyprgraphics",
-        "rev": "fb2c0268645a77403af3b8a4ce8fa7ba5917f15d",
+        "rev": "0d77b4895ad5f1bb3b0ee43103a5246c58b65591",
        "type": "github"
      },
      "original": {
@@ -128,11 +128,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1728345020,
-        "narHash": "sha256-xGbkc7U/Roe0/Cv3iKlzijIaFBNguasI31ynL2IlEoM=",
+        "lastModified": 1737556638,
+        "narHash": "sha256-laKgI3mr2qz6tas/q3tuGPxMdsGhBi/w+HO+hO2f1AY=",
        "owner": "hyprwm",
        "repo": "hyprland-protocols",
-        "rev": "a7c183800e74f337753de186522b9017a07a8cee",
+        "rev": "4c75dd5c015c8a0e5a34c6d02a018a650f57feb5",
        "type": "github"
      },
      "original": {
@@ -141,8 +141,35 @@
        "type": "github"
      }
    },
+    "hyprland-qt-support": {
+      "inputs": {
+        "hyprlang": "hyprlang",
+        "nixpkgs": [
+          "hyprland-qtutils",
+          "nixpkgs"
+        ],
+        "systems": [
+          "hyprland-qtutils",
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737634706,
+        "narHash": "sha256-nGCibkfsXz7ARx5R+SnisRtMq21IQIhazp6viBU8I/A=",
+        "owner": "hyprwm",
+        "repo": "hyprland-qt-support",
+        "rev": "8810df502cdee755993cb803eba7b23f189db795",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprland-qt-support",
+        "type": "github"
+      }
+    },
    "hyprland-qtutils": {
      "inputs": {
+        "hyprland-qt-support": "hyprland-qt-support",
        "hyprutils": [
          "hyprutils"
        ],
@@ -154,11 +181,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1733940128,
-        "narHash": "sha256-hmfXWj2GA9cj1QUkPFYtAAeohhs615zL4E3APy3FnvQ=",
+        "lastModified": 1737811848,
+        "narHash": "sha256-WZ7LeiKHk5Y94MU5gHIWn0r8asWxYOvie4LqfCjVIZU=",
        "owner": "hyprwm",
        "repo": "hyprland-qtutils",
-        "rev": "3833097e50473a152dd614d4b468886840b4ea78",
+        "rev": "9c0831ff98856c0f312fcb8b57553fbe3dd34d5b",
        "type": "github"
      },
      "original": {
@@ -168,6 +195,34 @@
      }
    },
    "hyprlang": {
+      "inputs": {
+        "hyprutils": "hyprutils",
+        "nixpkgs": [
+          "hyprland-qtutils",
+          "hyprland-qt-support",
+          "nixpkgs"
+        ],
+        "systems": [
+          "hyprland-qtutils",
+          "hyprland-qt-support",
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737634606,
+        "narHash": "sha256-W7W87Cv6wqZ9PHegI6rH1+ve3zJPiyevMFf0/HwdbCQ=",
+        "owner": "hyprwm",
+        "repo": "hyprlang",
+        "rev": "f41271d35cc0f370d300413d756c2677f386af9d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprlang",
+        "type": "github"
+      }
+    },
+    "hyprlang_2": {
      "inputs": {
        "hyprutils": [
          "hyprutils"
@@ -180,11 +235,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1734364628,
-        "narHash": "sha256-ii8fzJfI953n/EmIxVvq64ZAwhvwuuPHWfGd61/mJG8=",
+        "lastModified": 1737634606,
+        "narHash": "sha256-W7W87Cv6wqZ9PHegI6rH1+ve3zJPiyevMFf0/HwdbCQ=",
        "owner": "hyprwm",
        "repo": "hyprlang",
-        "rev": "16e59c1eb13d9fb6de066f54e7555eb5e8a4aba5",
+        "rev": "f41271d35cc0f370d300413d756c2677f386af9d",
        "type": "github"
      },
      "original": {
@@ -194,6 +249,35 @@
      }
    },
    "hyprutils": {
+      "inputs": {
+        "nixpkgs": [
+          "hyprland-qtutils",
+          "hyprland-qt-support",
+          "hyprlang",
+          "nixpkgs"
+        ],
+        "systems": [
+          "hyprland-qtutils",
+          "hyprland-qt-support",
+          "hyprlang",
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737632363,
+        "narHash": "sha256-X9I8POSlHxBVjD0fiX1O2j7U9Zi1+4rIkrsyHP0uHXY=",
+        "owner": "hyprwm",
+        "repo": "hyprutils",
+        "rev": "006620eb29d54ea9086538891404c78563d1bae1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprutils",
+        "type": "github"
+      }
+    },
+    "hyprutils_2": {
      "inputs": {
        "nixpkgs": [
          "nixpkgs"
@@ -203,11 +287,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1733502241,
-        "narHash": "sha256-KAUNC4Dgq8WQjYov5auBw/usaHixhacvb7cRDd0AG/k=",
+        "lastModified": 1739891528,
+        "narHash": "sha256-h8HOCZ/rw2Buzku+GKF77VXxrGjCSOQkLhptiEKMYg0=",
        "owner": "hyprwm",
        "repo": "hyprutils",
-        "rev": "104117aed6dd68561be38b50f218190aa47f2cd8",
+        "rev": "61a5382f4b1ab578064d470b1b3d3f0df396b8ba",
        "type": "github"
      },
      "original": {
@@ -226,11 +310,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1726874836,
-        "narHash": "sha256-VKR0sf0PSNCB0wPHVKSAn41mCNVCnegWmgkrneKDhHM=",
+        "lastModified": 1735493474,
+        "narHash": "sha256-fktzv4NaqKm94VAkAoVqO/nqQlw+X0/tJJNAeCSfzK4=",
        "owner": "hyprwm",
        "repo": "hyprwayland-scanner",
-        "rev": "500c81a9e1a76760371049a8d99e008ea77aa59e",
+        "rev": "de913476b59ee88685fdc018e77b8f6637a2ae0b",
        "type": "github"
      },
      "original": {
@@ -241,11 +325,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1734119587,
-        "narHash": "sha256-AKU6qqskl0yf2+JdRdD0cfxX4b9x3KKV5RqA6wijmPM=",
+        "lastModified": 1737632463,
+        "narHash": "sha256-38J9QfeGSej341ouwzqf77WIHAScihAKCt8PQJ+NH28=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "3566ab7246670a43abd2ffa913cc62dad9cdf7d5",
+        "rev": "0aa475546ed21629c4f5bbf90e38c846a99ec9e9",
        "type": "github"
      },
      "original": {
@@ -255,37 +339,20 @@
        "type": "github"
      }
    },
-    "nixpkgs-stable": {
-      "locked": {
-        "lastModified": 1730741070,
-        "narHash": "sha256-edm8WG19kWozJ/GqyYx2VjW99EdhjKwbY3ZwdlPAAlo=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "d063c1dd113c91ab27959ba540c0d9753409edf3",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-24.05",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
    "pre-commit-hooks": {
      "inputs": {
        "flake-compat": "flake-compat",
        "gitignore": "gitignore",
        "nixpkgs": [
          "nixpkgs"
-        ],
-        "nixpkgs-stable": "nixpkgs-stable"
+        ]
      },
      "locked": {
-        "lastModified": 1734279981,
-        "narHash": "sha256-NdaCraHPp8iYMWzdXAt5Nv6sA3MUzlCiGiR586TCwo0=",
+        "lastModified": 1737465171,
+        "narHash": "sha256-R10v2hoJRLq8jcL4syVFag7nIGE7m13qO48wRIukWNg=",
        "owner": "cachix",
        "repo": "git-hooks.nix",
-        "rev": "aa9f40c906904ebd83da78e7f328cd8aeaeae785",
+        "rev": "9364dc02281ce2d37a1f55b6e51f7c0f65a75f17",
        "type": "github"
      },
      "original": {
@@ -301,8 +368,8 @@
        "hyprgraphics": "hyprgraphics",
        "hyprland-protocols": "hyprland-protocols",
        "hyprland-qtutils": "hyprland-qtutils",
-        "hyprlang": "hyprlang",
-        "hyprutils": "hyprutils",
+        "hyprlang": "hyprlang_2",
+        "hyprutils": "hyprutils_2",
        "hyprwayland-scanner": "hyprwayland-scanner",
        "nixpkgs": "nixpkgs",
        "pre-commit-hooks": "pre-commit-hooks",
@@ -347,11 +414,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1734124279,
-        "narHash": "sha256-YNpFfiQjYt2o6LGcMN9NkjVvprC8ELrIpLHlbZbclRM=",
+        "lastModified": 1737634991,
+        "narHash": "sha256-dBAnb7Kbnier30cA7AgxVSxxARmxKZ1vHZT33THSIr8=",
        "owner": "hyprwm",
        "repo": "xdg-desktop-portal-hyprland",
-        "rev": "0c6861f819f6d31f6195c9864709b2556f00b5cf",
+        "rev": "e09dfe2726c8008f983e45a0aa1a3b7416aaeb8a",
        "type": "github"
      },
      "original": {
--- a/hyprpm/CMakeLists.txt
+++ b/hyprpm/CMakeLists.txt
@@ -11,9 +11,23 @@ set(CMAKE_CXX_STANDARD 23)

 pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.2.4)

+find_package(glaze QUIET)
+if (NOT glaze_FOUND)
+    set(GLAZE_VERSION v4.2.3)
+    message(STATUS "glaze dependency not found, retrieving ${GLAZE_VERSION} with FetchContent")
+    include(FetchContent)
+    FetchContent_Declare(
+        glaze
+        GIT_REPOSITORY https://github.com/stephenberry/glaze.git
+        GIT_TAG ${GLAZE_VERSION}
+        GIT_SHALLOW TRUE
+    )
+    FetchContent_MakeAvailable(glaze)
+endif()
+
 add_executable(hyprpm ${SRCFILES})

-target_link_libraries(hyprpm PUBLIC PkgConfig::hyprpm_deps)
+target_link_libraries(hyprpm PUBLIC PkgConfig::hyprpm_deps glaze::glaze)

 # binary
 install(TARGETS hyprpm)
--- a/hyprpm/hyprpm.usage
+++ b/hyprpm/hyprpm.usage
@@ -14,7 +14,7 @@ hyprpm [<FLAGS>]... <ARGUMENT>
        |   (list)                      "List all installed plugins"
        |   (enable <PLUGINS>)          "Load a plugin"
        |   (disable <PLUGINS>)         "Unload a plugin"
-        |   (reload)                    "Reload all plugins"
+        |   (reload)                    "Reload plugins to match the enabled/disabled state. Use -f to force reload."
        ;

 <PLUGINS> ::= {{{ hyprpm list | awk '/Plugin/{print $4}' }}};
--- a/hyprpm/src/core/DataState.cpp
+++ b/hyprpm/src/core/DataState.cpp
@@ -1,11 +1,10 @@
 #include "DataState.hpp"
 #include <toml++/toml.hpp>
 #include <print>
-#include <filesystem>
 #include <fstream>
 #include "PluginManager.hpp"

-std::string DataState::getDataStatePath() {
+std::filesystem::path DataState::getDataStatePath() {
    const auto HOME = getenv("HOME");
    if (!HOME) {
        std::println(stderr, "DataState: no $HOME");
@@ -16,12 +15,29 @@ std::string DataState::getDataStatePath() {
    const auto XDG_DATA_HOME = getenv("XDG_DATA_HOME");

    if (XDG_DATA_HOME)
-        return std::string{XDG_DATA_HOME} + "/hyprpm";
-    return std::string{HOME} + "/.local/share/hyprpm";
+        return std::filesystem::path{XDG_DATA_HOME} / "hyprpm";
+    return std::filesystem::path{HOME} / ".local/share/hyprpm";
 }

 std::string DataState::getHeadersPath() {
-    return getDataStatePath() + "/headersRoot";
+    return getDataStatePath() / "headersRoot";
+}
+
+std::vector<std::filesystem::path> DataState::getPluginStates() {
+    ensureStateStoreExists();
+
+    std::vector<std::filesystem::path> states;
+    for (const auto& entry : std::filesystem::directory_iterator(getDataStatePath())) {
+        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
+            continue;
+
+        const auto stateFile = entry.path() / "state.toml";
+        if (!std::filesystem::exists(stateFile))
+            continue;
+
+        states.emplace_back(stateFile);
+    }
+    return states;
 }

 void DataState::ensureStateStoreExists() {
@@ -37,7 +53,7 @@ void DataState::ensureStateStoreExists() {
 void DataState::addNewPluginRepo(const SPluginRepository& repo) {
    ensureStateStoreExists();

-    const auto PATH = getDataStatePath() + "/" + repo.name;
+    const auto PATH = getDataStatePath() / repo.name;

    std::filesystem::create_directories(PATH);
    // clang-format off
@@ -50,19 +66,21 @@ 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 + "/" + p.name + ".so");
+            std::filesystem::copy_file(p.filename, PATH / filename);

        DATA.emplace(p.name, toml::table{
-            {"filename", p.name + ".so"},
+            {"filename", filename},
            {"enabled", p.enabled},
            {"failed", p.failed}
        });
    }
    // clang-format on

-    std::ofstream ofs(PATH + "/state.toml", std::ios::trunc);
+    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
    ofs << DATA;
    ofs.close();
 }
@@ -72,17 +90,10 @@ bool DataState::pluginRepoExists(const std::string& urlOrName) {

    const auto PATH = getDataStatePath();

-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto       STATE = toml::parse_file(entry.path().string() + "/state.toml");
-
-        const auto NAME = STATE["repository"]["name"].value_or("");
-        const auto URL  = STATE["repository"]["url"].value_or("");
+    for (const auto& stateFile : getPluginStates()) {
+        const auto STATE = toml::parse_file(stateFile.c_str());
+        const auto NAME  = STATE["repository"]["name"].value_or("");
+        const auto URL   = STATE["repository"]["url"].value_or("");

        if (URL == urlOrName || NAME == urlOrName)
            return true;
@@ -96,29 +107,22 @@ void DataState::removePluginRepo(const std::string& urlOrName) {

    const auto PATH = getDataStatePath();

-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto       STATE = toml::parse_file(entry.path().string() + "/state.toml");
-
-        const auto NAME = STATE["repository"]["name"].value_or("");
-        const auto URL  = STATE["repository"]["url"].value_or("");
+    for (const auto& stateFile : getPluginStates()) {
+        const auto STATE = toml::parse_file(stateFile.c_str());
+        const auto NAME  = STATE["repository"]["name"].value_or("");
+        const auto URL   = STATE["repository"]["url"].value_or("");

        if (URL == urlOrName || NAME == urlOrName) {

            // unload the plugins!!
-            for (const auto& file : std::filesystem::directory_iterator(entry.path())) {
+            for (const auto& file : std::filesystem::directory_iterator(stateFile.parent_path())) {
                if (!file.path().string().ends_with(".so"))
                    continue;

                g_pPluginManager->loadUnloadPlugin(std::filesystem::absolute(file.path()), false);
            }

-            std::filesystem::remove_all(entry.path());
+            std::filesystem::remove_all(stateFile.parent_path());
            return;
        }
    }
@@ -139,7 +143,7 @@ void DataState::updateGlobalState(const SGlobalState& state) {
    };
    // clang-format on

-    std::ofstream ofs(PATH + "/state.toml", std::ios::trunc);
+    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
    ofs << DATA;
    ofs.close();
 }
@@ -147,12 +151,12 @@ void DataState::updateGlobalState(const SGlobalState& state) {
 SGlobalState DataState::getGlobalState() {
    ensureStateStoreExists();

-    const auto PATH = getDataStatePath();
+    const auto stateFile = getDataStatePath() / "state.toml";

-    if (!std::filesystem::exists(PATH + "/state.toml"))
+    if (!std::filesystem::exists(stateFile))
        return SGlobalState{};

-    auto         DATA = toml::parse_file(PATH + "/state.toml");
+    auto         DATA = toml::parse_file(stateFile.c_str());

    SGlobalState state;
    state.headersHashCompiled = DATA["state"]["hash"].value_or("");
@@ -167,15 +171,8 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
    const auto                     PATH = getDataStatePath();

    std::vector<SPluginRepository> repos;
-
-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto              STATE = toml::parse_file(entry.path().string() + "/state.toml");
+    for (const auto& stateFile : getPluginStates()) {
+        const auto        STATE = toml::parse_file(stateFile.c_str());

        const auto        NAME = STATE["repository"]["name"].value_or("");
        const auto        URL  = STATE["repository"]["url"].value_or("");
@@ -210,15 +207,8 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {

    const auto PATH = getDataStatePath();

-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto STATE = toml::parse_file(entry.path().string() + "/state.toml");
-
+    for (const auto& stateFile : getPluginStates()) {
+        const auto STATE = toml::parse_file(stateFile.c_str());
        for (const auto& [key, val] : STATE) {
            if (key == "repository")
                continue;
@@ -231,10 +221,11 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
            if (FAILED)
                return false;

-            (*STATE[key].as_table()).insert_or_assign("enabled", enabled);
+            auto modifiedState = STATE;
+            (*modifiedState[key].as_table()).insert_or_assign("enabled", enabled);

-            std::ofstream state(entry.path().string() + "/state.toml", std::ios::trunc);
-            state << STATE;
+            std::ofstream state(stateFile, std::ios::trunc);
+            state << modifiedState;
            state.close();

            return true;
--- a/hyprpm/src/core/DataState.hpp
+++ b/hyprpm/src/core/DataState.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include <filesystem>
 #include <string>
 #include <vector>
 #include "Plugin.hpp"
@@ -9,14 +10,15 @@ struct SGlobalState {
 };

 namespace DataState {
-    std::string                    getDataStatePath();
-    std::string                    getHeadersPath();
-    void                           ensureStateStoreExists();
-    void                           addNewPluginRepo(const SPluginRepository& repo);
-    void                           removePluginRepo(const std::string& urlOrName);
-    bool                           pluginRepoExists(const std::string& urlOrName);
-    void                           updateGlobalState(const SGlobalState& state);
-    SGlobalState                   getGlobalState();
-    bool                           setPluginEnabled(const std::string& name, bool enabled);
-    std::vector<SPluginRepository> getAllRepositories();
+    std::filesystem::path              getDataStatePath();
+    std::string                        getHeadersPath();
+    std::vector<std::filesystem::path> getPluginStates();
+    void                               ensureStateStoreExists();
+    void                               addNewPluginRepo(const SPluginRepository& repo);
+    void                               removePluginRepo(const std::string& urlOrName);
+    bool                               pluginRepoExists(const std::string& urlOrName);
+    void                               updateGlobalState(const SGlobalState& state);
+    SGlobalState                       getGlobalState();
+    bool                               setPluginEnabled(const std::string& name, bool enabled);
+    std::vector<SPluginRepository>     getAllRepositories();
 };
--- a/hyprpm/src/core/PluginManager.cpp
+++ b/hyprpm/src/core/PluginManager.cpp
@@ -7,10 +7,8 @@

 #include <cstdio>
 #include <iostream>
-#include <array>
 #include <filesystem>
 #include <print>
-#include <thread>
 #include <fstream>
 #include <algorithm>
 #include <format>
@@ -21,6 +19,7 @@
 #include <unistd.h>

 #include <toml++/toml.hpp>
+#include <glaze/glaze.hpp>

 #include <hyprutils/string/String.hpp>
 #include <hyprutils/os/Process.hpp>
@@ -83,13 +82,13 @@ SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
    hlbranch             = hlbranch.substr(0, hlbranch.find(" at commit "));

    std::string hldate = HLVERCALL.substr(HLVERCALL.find("Date: ") + 6);
-    hldate             = hldate.substr(0, hldate.find("\n"));
+    hldate             = hldate.substr(0, hldate.find('\n'));

    std::string hlcommits;

    if (HLVERCALL.contains("commits:")) {
        hlcommits = HLVERCALL.substr(HLVERCALL.find("commits:") + 9);
-        hlcommits = hlcommits.substr(0, hlcommits.find(" "));
+        hlcommits = hlcommits.substr(0, hlcommits.find(' '));
    }

    int commits = 0;
@@ -378,7 +377,7 @@ eHeadersErrors CPluginManager::headersValid() {

    // find headers commit
    const std::string& cmd     = std::format("PKG_CONFIG_PATH=\"{}/share/pkgconfig\" pkgconf --cflags --keep-system-cflags hyprland", DataState::getHeadersPath());
-    auto               headers = execAndGet(cmd.c_str());
+    auto               headers = execAndGet(cmd);

    if (!headers.contains("-I/"))
        return HEADERS_MISSING;
@@ -781,7 +780,7 @@ bool CPluginManager::disablePlugin(const std::string& name) {
    return ret;
 }

-ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
+ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload) {
    if (headersValid() != HEADERS_OK) {
        std::println(stderr, "\n{}", failureString("headers are not up-to-date, please run hyprpm update."));
        return LOADSTATE_HEADERS_OUTDATED;
@@ -790,35 +789,28 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
    const auto HOME = getenv("HOME");
    const auto HIS  = getenv("HYPRLAND_INSTANCE_SIGNATURE");
    if (!HOME || !HIS) {
-        std::println(stderr, "PluginManager: no $HOME or HIS");
+        std::println(stderr, "PluginManager: no $HOME or $HYPRLAND_INSTANCE_SIGNATURE");
        return LOADSTATE_FAIL;
    }
-    const auto               HYPRPMPATH = DataState::getDataStatePath() + "/";
+    const auto HYPRPMPATH = DataState::getDataStatePath();

-    auto                     pluginLines = execAndGet("hyprctl plugins list | grep Plugin");
+    const auto json = glz::read_json<glz::json_t::array_t>(execAndGet("hyprctl plugins list -j"));
+    if (!json) {
+        std::println(stderr, "PluginManager: couldn't parse hyprctl output");
+        return LOADSTATE_FAIL;
+    }

    std::vector<std::string> loadedPlugins;
+    for (const auto& plugin : json.value()) {
+        if (!plugin.is_object() || !plugin.contains("name")) {
+            std::println(stderr, "PluginManager: couldn't parse plugin object");
+            return LOADSTATE_FAIL;
+        }
+        loadedPlugins.emplace_back(plugin["name"].get<std::string>());
+    }

    std::println("{}", successString("Ensuring plugin load state"));

-    // iterate line by line
-    while (!pluginLines.empty()) {
-        auto plLine = pluginLines.substr(0, pluginLines.find('\n'));
-
-        if (pluginLines.find('\n') != std::string::npos)
-            pluginLines = pluginLines.substr(pluginLines.find('\n') + 1);
-        else
-            pluginLines = "";
-
-        if (plLine.back() != ':')
-            continue;
-
-        plLine = plLine.substr(7);
-        plLine = plLine.substr(0, plLine.find(" by "));
-
-        loadedPlugins.push_back(plLine);
-    }
-
    // get state
    const auto REPOS = DataState::getAllRepositories();

@@ -849,11 +841,11 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
    // (and Hyprland needs to restart)
    bool hyprlandVersionMismatch = false;

-    // unload disabled plugins
+    // unload disabled plugins (or all if forceReload is true)
    for (auto const& p : loadedPlugins) {
-        if (!enabled(p)) {
+        if (forceReload || !enabled(p)) {
            // unload
-            if (!loadUnloadPlugin(HYPRPMPATH + repoForName(p) + "/" + p + ".so", false)) {
+            if (!loadUnloadPlugin(HYPRPMPATH / repoForName(p) / (p + ".so"), false)) {
                std::println("{}", infoString("{} will be unloaded after restarting Hyprland", p));
                hyprlandVersionMismatch = true;
            } else
@@ -867,10 +859,10 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
            if (!p.enabled)
                continue;

-            if (std::find_if(loadedPlugins.begin(), loadedPlugins.end(), [&](const auto& other) { return other == p.name; }) != loadedPlugins.end())
+            if (!forceReload && std::find_if(loadedPlugins.begin(), loadedPlugins.end(), [&](const auto& other) { return other == p.name; }) != loadedPlugins.end())
                continue;

-            if (!loadUnloadPlugin(HYPRPMPATH + repoForName(p.name) + "/" + p.filename, true)) {
+            if (!loadUnloadPlugin(HYPRPMPATH / repoForName(p.name) / p.filename, true)) {
                std::println("{}", infoString("{} will be loaded after restarting Hyprland", p.name));
                hyprlandVersionMismatch = true;
            } else
--- a/hyprpm/src/core/PluginManager.hpp
+++ b/hyprpm/src/core/PluginManager.hpp
@@ -51,7 +51,7 @@ class CPluginManager {

    bool                   enablePlugin(const std::string& name);
    bool                   disablePlugin(const std::string& name);
-    ePluginLoadStateReturn ensurePluginsLoadState();
+    ePluginLoadStateReturn ensurePluginsLoadState(bool forceReload = false);

    bool                   loadUnloadPlugin(const std::string& path, bool load);
    SHyprlandVersion       getHyprlandVersion(bool running = true);
--- a/hyprpm/src/main.cpp
+++ b/hyprpm/src/main.cpp
@@ -154,7 +154,7 @@ int                        main(int argc, char** argv, char** envp) {
        if (ret != LOADSTATE_OK)
            return 1;
    } else if (command[0] == "reload") {
-        auto ret = g_pPluginManager->ensurePluginsLoadState();
+        auto ret = g_pPluginManager->ensurePluginsLoadState(force);

        if (ret != LOADSTATE_OK && notify) {
            switch (ret) {
--- a/hyprpm/src/meson.build
+++ b/hyprpm/src/meson.build
@@ -8,6 +8,7 @@ executable(
    dependency('hyprutils', version: '>= 0.1.1'),
    dependency('threads'),
    dependency('tomlplusplus'),
+    dependency('glaze', method: 'cmake'),
  ],
  install: true,
 )
--- a/meson.build
+++ b/meson.build
@@ -58,6 +58,7 @@ endif

 backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
 epoll_dep = dependency('epoll-shim', required: false) # timerfd on BSDs
+inotify_dep = dependency('libinotify', required: false) # inotify on BSDs

 re2 = dependency('re2', required: true)

@@ -101,11 +102,14 @@ endif
 subdir('protocols')
 subdir('src')
 subdir('hyprctl')
-subdir('hyprpm/src')
 subdir('assets')
 subdir('example')
 subdir('docs')

+if get_option('hyprpm').enabled()
+  subdir('hyprpm/src')
+endif
+
 # Generate hyprland.pc
 pkg_install_dir = join_paths(get_option('datadir'), 'pkgconfig')

--- a/meson_options.txt
+++ b/meson_options.txt
@@ -2,4 +2,5 @@ option('xwayland', type: 'feature', value: 'auto', description: 'Enable support
 option('systemd', type: 'feature', value: 'auto', description: 'Enable systemd integration')
 option('uwsm', type: 'feature', value: 'enabled', description: 'Enable uwsm integration (only if systemd is enabled)')
 option('legacy_renderer', type: 'feature', value: 'disabled', description: 'Enable legacy renderer')
+option('hyprpm', type: 'feature', value: 'enabled', description: 'Enable hyprpm')
 option('tracy_enable', type: 'boolean', value: false , description: 'Enable profiling')
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -5,12 +5,14 @@
  pkg-config,
  pkgconf,
  makeWrapper,
+  cmake,
  meson,
  ninja,
  aquamarine,
  binutils,
  cairo,
  git,
+  glaze,
  hyprcursor,
  hyprgraphics,
  hyprland-protocols,
@@ -50,12 +52,12 @@
  nvidiaPatches ? false,
  hidpiXWayland ? false,
 }: let
-  inherit (builtins) baseNameOf foldl';
+  inherit (builtins) baseNameOf foldl' readFile;
  inherit (lib.asserts) assertMsg;
  inherit (lib.attrsets) mapAttrsToList;
  inherit (lib.lists) flatten concatLists optional optionals;
  inherit (lib.sources) cleanSourceWith cleanSource;
-  inherit (lib.strings) hasSuffix makeBinPath optionalString mesonBool mesonEnable;
+  inherit (lib.strings) hasSuffix makeBinPath optionalString mesonBool mesonEnable trim;

  adapters = flatten [
    stdenvAdapters.useMoldLinker
@@ -91,7 +93,7 @@ in
      DATE = date;
      DIRTY = optionalString (commit == "") "dirty";
      HASH = commit;
-      TAG = "v${builtins.readFile "${finalAttrs.src}/VERSION"}";
+      TAG = "v${trim (readFile "${finalAttrs.src}/VERSION")}";

      depsBuildBuild = [
        pkg-config
@@ -102,6 +104,7 @@ in
        makeWrapper
        meson
        ninja
+        cmake # needed for glaze
        pkg-config
      ];

@@ -116,6 +119,7 @@ in
          aquamarine
          cairo
          git
+          glaze
          hyprcursor
          hyprgraphics
          hyprland-protocols
@@ -159,6 +163,7 @@ in
          "xwayland" = enableXWayland;
          "legacy_renderer" = legacyRenderer;
          "uwsm" = false;
+          "hyprpm" = false;
        })
        (mapAttrsToList mesonBool {
          "b_pch" = false;
--- a/nix/module.nix
+++ b/nix/module.nix
@@ -7,15 +7,206 @@ inputs: {
  inherit (pkgs.stdenv.hostPlatform) system;
  cfg = config.programs.hyprland;

-  package = inputs.self.packages.${system}.hyprland;
-  portalPackage = inputs.self.packages.${system}.xdg-desktop-portal-hyprland.override {
-    hyprland = cfg.finalPackage;
-  };
+  # basically 1:1 taken from https://github.com/nix-community/home-manager/blob/master/modules/services/window-managers/hyprland.nix
+  toHyprconf = {
+    attrs,
+    indentLevel ? 0,
+    importantPrefixes ? ["$"],
+  }: let
+    inherit
+      (lib)
+      all
+      concatMapStringsSep
+      concatStrings
+      concatStringsSep
+      filterAttrs
+      foldl
+      generators
+      hasPrefix
+      isAttrs
+      isList
+      mapAttrsToList
+      replicate
+      ;
+
+    initialIndent = concatStrings (replicate indentLevel "  ");
+
+    toHyprconf' = indent: attrs: let
+      sections =
+        filterAttrs (n: v: isAttrs v || (isList v && all isAttrs v)) attrs;
+
+      mkSection = n: attrs:
+        if lib.isList attrs
+        then (concatMapStringsSep "\n" (a: mkSection n a) attrs)
+        else ''
+          ${indent}${n} {
+          ${toHyprconf' "  ${indent}" attrs}${indent}}
+        '';
+
+      mkFields = generators.toKeyValue {
+        listsAsDuplicateKeys = true;
+        inherit indent;
+      };
+
+      allFields =
+        filterAttrs (n: v: !(isAttrs v || (isList v && all isAttrs v)))
+        attrs;
+
+      isImportantField = n: _:
+        foldl (acc: prev:
+          if hasPrefix prev n
+          then true
+          else acc)
+        false
+        importantPrefixes;
+
+      importantFields = filterAttrs isImportantField allFields;
+
+      fields =
+        builtins.removeAttrs allFields
+        (mapAttrsToList (n: _: n) importantFields);
+    in
+      mkFields importantFields
+      + concatStringsSep "\n" (mapAttrsToList mkSection sections)
+      + mkFields fields;
+  in
+    toHyprconf' initialIndent attrs;
 in {
-  config = {
+  options = {
    programs.hyprland = {
-      package = lib.mkDefault package;
-      portalPackage = lib.mkDefault portalPackage;
+      plugins = lib.mkOption {
+        type = with lib.types; listOf (either package path);
+        default = [];
+        description = ''
+          List of Hyprland plugins to use. Can either be packages or
+          absolute plugin paths.
+        '';
+      };
+
+      settings = lib.mkOption {
+        type = with lib.types; let
+          valueType =
+            nullOr (oneOf [
+              bool
+              int
+              float
+              str
+              path
+              (attrsOf valueType)
+              (listOf valueType)
+            ])
+            // {
+              description = "Hyprland configuration value";
+            };
+        in
+          valueType;
+        default = {};
+        description = ''
+          Hyprland configuration written in Nix. Entries with the same key
+          should be written as lists. Variables' and colors' names should be
+          quoted. See <https://wiki.hyprland.org> for more examples.
+
+          ::: {.note}
+          Use the [](#programs.hyprland.plugins) option to
+          declare plugins.
+          :::
+
+        '';
+        example = lib.literalExpression ''
+          {
+            decoration = {
+              shadow_offset = "0 5";
+              "col.shadow" = "rgba(00000099)";
+            };
+
+            "$mod" = "SUPER";
+
+            bindm = [
+              # mouse movements
+              "$mod, mouse:272, movewindow"
+              "$mod, mouse:273, resizewindow"
+              "$mod ALT, mouse:272, resizewindow"
+            ];
+          }
+        '';
+      };
+
+      extraConfig = lib.mkOption {
+        type = lib.types.lines;
+        default = "";
+        example = ''
+          # window resize
+          bind = $mod, S, submap, resize
+
+          submap = resize
+          binde = , right, resizeactive, 10 0
+          binde = , left, resizeactive, -10 0
+          binde = , up, resizeactive, 0 -10
+          binde = , down, resizeactive, 0 10
+          bind = , escape, submap, reset
+          submap = reset
+        '';
+        description = ''
+          Extra configuration lines to add to `/etc/xdg/hypr/hyprland.conf`.
+        '';
+      };
+
+      sourceFirst =
+        lib.mkEnableOption ''
+          putting source entries at the top of the configuration
+        ''
+        // {
+          default = true;
+        };
+
+      importantPrefixes = lib.mkOption {
+        type = with lib.types; listOf str;
+        default = ["$" "bezier" "name"] ++ lib.optionals cfg.sourceFirst ["source"];
+        example = ["$" "bezier"];
+        description = ''
+          List of prefix of attributes to source at the top of the config.
+        '';
+      };
    };
  };
+  config = lib.mkMerge [
+    {
+      programs.hyprland = {
+        package = lib.mkDefault inputs.self.packages.${system}.hyprland;
+        portalPackage = lib.mkDefault (inputs.self.packages.${system}.xdg-desktop-portal-hyprland.override {
+          hyprland = cfg.finalPackage;
+        });
+      };
+    }
+    (lib.mkIf cfg.enable {
+      environment.etc."xdg/hypr/hyprland.conf" = let
+        shouldGenerate = cfg.extraConfig != "" || cfg.settings != {} || cfg.plugins != [];
+
+        pluginsToHyprconf = plugins:
+          toHyprconf {
+            attrs = {
+              plugin = let
+                mkEntry = entry:
+                  if lib.types.package.check entry
+                  then "${entry}/lib/lib${entry.pname}.so"
+                  else entry;
+              in
+                map mkEntry cfg.plugins;
+            };
+            inherit (cfg) importantPrefixes;
+          };
+      in
+        lib.mkIf shouldGenerate {
+          text =
+            lib.optionalString (cfg.plugins != [])
+            (pluginsToHyprconf cfg.plugins)
+            + lib.optionalString (cfg.settings != {})
+            (toHyprconf {
+              attrs = cfg.settings;
+              inherit (cfg) importantPrefixes;
+            })
+            + lib.optionalString (cfg.extraConfig != "") cfg.extraConfig;
+        };
+    })
+  ];
 }
--- a/protocols/frog-color-management-v1.xml
+++ b/protocols/frog-color-management-v1.xml
@@ -0,0 +1,366 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="frog_color_management_v1">
+
+	<copyright>
+		Copyright © 2023 Joshua Ashton for Valve Software
+		Copyright © 2023 Xaver Hugl
+
+		Permission is hereby granted, free of charge, to any person obtaining a
+		copy of this software and associated documentation files (the "Software"),
+		to deal in the Software without restriction, including without limitation
+		the rights to use, copy, modify, merge, publish, distribute, sublicense,
+		and/or sell copies of the Software, and to permit persons to whom the
+		Software is furnished to do so, subject to the following conditions:
+
+		The above copyright notice and this permission notice (including the next
+		paragraph) shall be included in all copies or substantial portions of the
+		Software.
+
+		THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+		IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+		FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+		THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+		LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+		FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+		DEALINGS IN THE SOFTWARE.
+	</copyright>
+
+	<description summary="experimental color management protocol">
+		The aim of this color management extension is to get HDR games working quickly,
+		and have an easy way to test implementations in the wild before the upstream
+		protocol is ready to be merged.
+		For that purpose it's intentionally limited and cut down and does not serve
+		all uses cases.
+	</description>
+
+	<interface name="frog_color_management_factory_v1" version="1">
+		<description summary="color management factory">
+			The color management factory singleton creates color managed surface objects.
+		</description>
+
+		<request name="destroy" type="destructor"></request>
+
+		<request name="get_color_managed_surface">
+			<description summary="create color management interface for surface">
+			</description>
+
+			<arg name="surface" type="object" interface="wl_surface"
+				summary="target surface" />
+			<arg name="callback" type="new_id" interface="frog_color_managed_surface"
+				summary="new color managed surface object" />
+		</request>
+	</interface>
+
+	<interface name="frog_color_managed_surface" version="1">
+		<description summary="color managed surface">
+			Interface for changing surface color management and HDR state.
+
+			An implementation must: support every part of the version
+			of the frog_color_managed_surface interface it exposes.
+			Including all known enums associated with a given version.
+		</description>
+
+		<request name="destroy" type="destructor">
+			<description summary="destroy color managed surface">
+				Destroying the color managed surface resets all known color
+				state for the surface back to 'undefined' implementation-specific
+				values.
+			</description>
+		</request>
+
+		<enum name="transfer_function">
+			<description summary="known transfer functions">
+				Extended information on the transfer functions described
+				here can be found in the Khronos Data Format specification:
+				https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html
+			</description>
+			<entry name="undefined" value="0"
+				summary="specifies undefined, implementation-specific handling of the surface's transfer function." />
+			<entry name="srgb" value="1"
+				summary="specifies the sRGB non-linear EOTF. An implementation may: display this as Gamma 2.2 for the purposes of being consistent with content rendering across displays, rendering_intent and user expectations." />
+			<entry name="gamma_22" value="2" summary="specifies gamma 2.2 power curve as the EOTF" />
+			<entry name="st2084_pq" value="3"
+				summary="specifies the SMPTE ST2084 Perceptual Quantizer (PQ) EOTF" />
+			<entry name="scrgb_linear" value="4"
+				summary="specifies the scRGB (extended sRGB) linear EOTF. Note: Primaries outside the gamut triangle specified can be expressed with negative values for this transfer function." />
+		</enum>
+
+		<request name="set_known_transfer_function">
+			<description summary="sets a known transfer function for a surface" />
+			<arg name="transfer_function" type="uint" enum="transfer_function"
+				summary="transfer function for the surface" />
+		</request>
+
+		<enum name="primaries">
+			<description summary="known primaries" />
+			<entry name="undefined" value="0"
+				summary="specifies undefined, implementation-specific handling" />
+			<entry name="rec709" value="1" summary="specifies Rec.709/sRGB primaries with D65 white point" />
+			<entry name="rec2020" value="2"
+				summary="specifies Rec.2020/HDR10 primaries with D65 white point" />
+		</enum>
+
+		<request name="set_known_container_color_volume">
+			<description summary="sets the container color volume (primaries) for a surface" />
+			<arg name="primaries" type="uint" enum="primaries" summary="primaries for the surface" />
+		</request>
+
+		<enum name="render_intent">
+			<description summary="known render intents">
+				Extended information on render intents described
+				here can be found in ICC.1:2022:
+
+				https://www.color.org/specification/ICC.1-2022-05.pdf
+			</description>
+			<entry name="perceptual" value="0" summary="perceptual" />
+		</enum>
+
+		<request name="set_render_intent">
+			<description summary="sets the render intent for a surface">
+				NOTE: On a surface with "perceptual" (default) render intent, handling of the container's
+				color volume
+				is implementation-specific, and may differ between different transfer functions it is paired
+				with:
+				ie. sRGB + 709 rendering may have it's primaries widened to more of the available display's
+				gamut
+				to be be more pleasing for the viewer.
+				Compared to scRGB Linear + 709 being treated faithfully as 709
+				(including utilizing negatives out of the 709 gamut triangle)
+			</description>
+			<arg name="render_intent" type="uint" enum="render_intent"
+				summary="render intent for the surface" />
+		</request>
+
+		<request name="set_hdr_metadata">
+			<description summary="set HDR metadata for a surface">
+				Forwards HDR metadata from the client to the compositor.
+
+				HDR Metadata Infoframe as per CTA 861.G spec.
+
+				Usage of this HDR metadata is implementation specific and
+				outside of the scope of this protocol.
+			</description>
+			<arg name="mastering_display_primary_red_x" type="uint">
+				<description summary="red primary x coordinate">
+					Mastering Red Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_red_y" type="uint">
+				<description summary="red primary y coordinate">
+					Mastering Red Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_green_x" type="uint">
+				<description summary="green primary x coordinate">
+					Mastering Green Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_green_y" type="uint">
+				<description summary="green primary y coordinate">
+					Mastering Green Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_blue_x" type="uint">
+				<description summary="blue primary x coordinate">
+					Mastering Blue Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_blue_y" type="uint">
+				<description summary="blue primary y coordinate">
+					Mastering Blue Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_white_point_x" type="uint">
+				<description summary="white point x coordinate">
+					Mastering White Point X Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_white_point_y" type="uint">
+				<description summary="white point y coordinate">
+					Mastering White Point Y Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="max_display_mastering_luminance" type="uint">
+				<description summary="max display mastering luminance">
+					Max Mastering Display Luminance.
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+			<arg name="min_display_mastering_luminance" type="uint">
+				<description summary="min display mastering luminance">
+					Min Mastering Display Luminance.
+					This value is coded as an unsigned 16-bit value in units of
+					0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF
+					represents 6.5535 cd/m2.
+				</description>
+			</arg>
+			<arg name="max_cll" type="uint">
+				<description summary="max content light level">
+					Max Content Light Level.
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+			<arg name="max_fall" type="uint">
+				<description summary="max frame average light level">
+					Max Frame Average Light Level.
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+		</request>
+
+		<event name="preferred_metadata">
+			<description summary="preferred metadata for a surface">
+				Current preferred metadata for a surface.
+				The application should use this information to tone-map its buffers
+				to this target before committing.
+
+				This metadata does not necessarily correspond to any physical output, but
+				rather what the compositor thinks would be best for a given surface.
+			</description>
+			<arg name="transfer_function" type="uint" enum="transfer_function">
+				<description summary="output's current transfer function">
+					Specifies a known transfer function that corresponds to the
+					output the surface is targeting.
+				</description>
+			</arg>
+			<arg name="output_display_primary_red_x" type="uint">
+				<description summary="red primary x coordinate">
+					Output Red Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_red_y" type="uint">
+				<description summary="red primary y coordinate">
+					Output Red Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_green_x" type="uint">
+				<description summary="green primary x coordinate">
+					Output Green Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_green_y" type="uint">
+				<description summary="green primary y coordinate">
+					Output Green Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_blue_x" type="uint">
+				<description summary="blue primary x coordinate">
+					Output Blue Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_blue_y" type="uint">
+				<description summary="blue primary y coordinate">
+					Output Blue Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_white_point_x" type="uint">
+				<description summary="white point x coordinate">
+					Output White Point X Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_white_point_y" type="uint">
+				<description summary="white point y coordinate">
+					Output White Point Y Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="max_luminance" type="uint">
+				<description summary="maximum luminance">
+					Max Output Luminance
+					The max luminance in nits that the output is capable of rendering in small areas.
+					Content should: not exceed this value to avoid clipping.
+
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+			<arg name="min_luminance" type="uint">
+				<description summary="minimum luminance">
+					Min Output Luminance
+					The min luminance that the output is capable of rendering.
+					Content should: not exceed this value to avoid clipping.
+
+					This value is coded as an unsigned 16-bit value in units of
+					0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF
+					represents 6.5535 cd/m2.
+				</description>
+			</arg>
+			<arg name="max_full_frame_luminance" type="uint">
+				<description summary="maximum full frame luminance">
+					Max Full Frame Luminance
+					The max luminance in nits that the output is capable of rendering for the
+					full frame sustained.
+
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+		</event>
+	</interface>
+</protocol>
--- a/protocols/meson.build
+++ b/protocols/meson.build
@@ -7,7 +7,7 @@ wayland_protos = dependency(

 hyprland_protos = dependency(
 	'hyprland-protocols',
-	version: '>=0.4',
+	version: '>=0.6',
 	fallback: 'hyprland-protocols',
 )

@@ -33,10 +33,14 @@ protocols = [
 	'wayland-drm.xml',
 	'wlr-data-control-unstable-v1.xml',
 	'wlr-screencopy-unstable-v1.xml',
+	'xx-color-management-v4.xml',
+	'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-focus-grab-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-ctm-control-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-surface-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-lock-notify-v1.xml',
 	wayland_protocol_dir / 'staging/tearing-control/tearing-control-v1.xml',
 	wayland_protocol_dir / 'staging/fractional-scale/fractional-scale-v1.xml',
 	wayland_protocol_dir / 'unstable/xdg-output/xdg-output-unstable-v1.xml',
--- a/protocols/xx-color-management-v4.xml
+++ b/protocols/xx-color-management-v4.xml
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -2,14 +2,18 @@

 #include "Compositor.hpp"
 #include "debug/Log.hpp"
+#include "desktop/DesktopTypes.hpp"
 #include "helpers/Splashes.hpp"
 #include "config/ConfigValue.hpp"
+#include "config/ConfigWatcher.hpp"
 #include "managers/CursorManager.hpp"
 #include "managers/TokenManager.hpp"
 #include "managers/PointerManager.hpp"
 #include "managers/SeatManager.hpp"
 #include "managers/VersionKeeperManager.hpp"
+#include "managers/DonationNagManager.hpp"
 #include "managers/eventLoop/EventLoopManager.hpp"
+#include <algorithm>
 #include <aquamarine/output/Output.hpp>
 #include <bit>
 #include <ctime>
@@ -17,20 +21,23 @@
 #include <print>
 #include <cstring>
 #include <filesystem>
+#include <ranges>
+#include <print>
 #include <unordered_set>
 #include "debug/HyprCtl.hpp"
 #include "debug/CrashReporter.hpp"
 #ifdef USES_SYSTEMD
 #include <helpers/SdDaemon.hpp> // for SdNotify
 #endif
-#include <ranges>
 #include "helpers/varlist/VarList.hpp"
+#include "helpers/fs/FsUtils.hpp"
 #include "protocols/FractionalScale.hpp"
 #include "protocols/PointerConstraints.hpp"
 #include "protocols/LayerShell.hpp"
 #include "protocols/XDGShell.hpp"
 #include "protocols/XDGOutput.hpp"
 #include "protocols/SecurityContext.hpp"
+#include "protocols/ColorManagement.hpp"
 #include "protocols/core/Compositor.hpp"
 #include "protocols/core/Subcompositor.hpp"
 #include "desktop/LayerSurface.hpp"
@@ -39,6 +46,24 @@
 #include "helpers/ByteOperations.hpp"
 #include "render/decorations/CHyprGroupBarDecoration.hpp"

+#include "managers/KeybindManager.hpp"
+#include "managers/SessionLockManager.hpp"
+#include "managers/XWaylandManager.hpp"
+
+#include "config/ConfigManager.hpp"
+#include "render/OpenGL.hpp"
+#include "managers/input/InputManager.hpp"
+#include "managers/AnimationManager.hpp"
+#include "managers/EventManager.hpp"
+#include "managers/HookSystemManager.hpp"
+#include "managers/ProtocolManager.hpp"
+#include "managers/LayoutManager.hpp"
+#include "plugins/PluginSystem.hpp"
+#include "helpers/Watchdog.hpp"
+#include "hyprerror/HyprError.hpp"
+#include "debug/HyprNotificationOverlay.hpp"
+#include "debug/HyprDebugOverlay.hpp"
+
 #include <hyprutils/string/String.hpp>
 #include <aquamarine/input/Input.hpp>

@@ -50,7 +75,7 @@
 using namespace Hyprutils::String;
 using namespace Aquamarine;

-int handleCritSignal(int signo, void* data) {
+static int handleCritSignal(int signo, void* data) {
    Debug::log(LOG, "Hyprland received signal {}", signo);

    if (signo == SIGTERM || signo == SIGINT || signo == SIGKILL)
@@ -59,7 +84,7 @@ int handleCritSignal(int signo, void* data) {
    return 0;
 }

-void handleUnrecoverableSignal(int sig) {
+static void handleUnrecoverableSignal(int sig) {

    // remove our handlers
    signal(SIGABRT, SIG_DFL);
@@ -83,7 +108,7 @@ void handleUnrecoverableSignal(int sig) {
    abort();
 }

-void handleUserSignal(int sig) {
+static void handleUserSignal(int sig) {
    if (sig == SIGUSR1) {
        // means we have to unwind a timed out event
        throw std::exception();
@@ -103,7 +128,7 @@ static eLogLevel aqLevelToHl(Aquamarine::eBackendLogLevel level) {
    return NONE;
 }

-void aqLog(Aquamarine::eBackendLogLevel level, std::string msg) {
+static void aqLog(Aquamarine::eBackendLogLevel level, std::string msg) {
    Debug::log(aqLevelToHl(level), "[AQ] {}", msg);
 }

@@ -138,7 +163,10 @@ void CCompositor::restoreNofile() {
        Debug::log(ERR, "Failed restoring NOFILE limits");
 }

-CCompositor::CCompositor() : m_iHyprlandPID(getpid()) {
+CCompositor::CCompositor(bool onlyConfig) : m_bOnlyConfigVerification(onlyConfig), m_iHyprlandPID(getpid()) {
+    if (onlyConfig)
+        return;
+
    m_szHyprTempDataRoot = std::string{getenv("XDG_RUNTIME_DIR")} + "/hypr";

    if (m_szHyprTempDataRoot.starts_with("/hypr")) {
@@ -202,7 +230,7 @@ CCompositor::CCompositor() : m_iHyprlandPID(getpid()) {
 }

 CCompositor::~CCompositor() {
-    if (!m_bIsShuttingDown)
+    if (!m_bIsShuttingDown && !m_bOnlyConfigVerification)
        cleanup();
 }

@@ -238,6 +266,16 @@ static bool filterGlobals(const wl_client* client, const wl_global* global, void
 //
 void CCompositor::initServer(std::string socketName, int socketFd) {

+    if (m_bOnlyConfigVerification) {
+        g_pHookSystem       = makeUnique<CHookSystemManager>();
+        g_pKeybindManager   = makeUnique<CKeybindManager>();
+        g_pAnimationManager = makeUnique<CHyprAnimationManager>();
+        g_pConfigManager    = makeUnique<CConfigManager>();
+
+        std::println("\n\n======== Config parsing result:\n\n{}", g_pConfigManager->verify());
+        return;
+    }
+
    m_sWLDisplay = wl_display_create();

    wl_display_set_global_filter(m_sWLDisplay, ::filterGlobals, nullptr);
@@ -425,7 +463,7 @@ void CCompositor::initAllSignals() {

                    for (auto const& m : m_vMonitors) {
                        scheduleFrameForMonitor(m);
-                        g_pHyprRenderer->applyMonitorRule(m, &m->activeMonitorRule, true);
+                        m->applyMonitorRule(&m->activeMonitorRule, true);
                    }

                    g_pConfigManager->m_bWantsMonitorReload = true;
@@ -434,11 +472,6 @@ void CCompositor::initAllSignals() {
                    Debug::log(LOG, "Session got deactivated!");

                    m_bSessionActive = false;
-
-                    for (auto const& m : m_vMonitors) {
-                        m->noFrameSchedule = true;
-                        m->framesToSkip    = 1;
-                    }
                }
            },
            nullptr);
@@ -534,12 +567,10 @@ void CCompositor::cleanup() {
    g_pProtocolManager.reset();
    g_pHyprRenderer.reset();
    g_pHyprOpenGL.reset();
-    g_pThreadManager.reset();
    g_pConfigManager.reset();
    g_pLayoutManager.reset();
    g_pHyprError.reset();
    g_pConfigManager.reset();
-    g_pAnimationManager.reset();
    g_pKeybindManager.reset();
    g_pHookSystem.reset();
    g_pWatchdog.reset();
@@ -548,6 +579,9 @@ void CCompositor::cleanup() {
    g_pSeatManager.reset();
    g_pHyprCtl.reset();
    g_pEventLoopManager.reset();
+    g_pVersionKeeperMgr.reset();
+    g_pDonationNagManager.reset();
+    g_pConfigWatcher.reset();

    if (m_pAqBackend)
        m_pAqBackend.reset();
@@ -565,92 +599,92 @@ void CCompositor::initManagers(eManagersInitStage stage) {
    switch (stage) {
        case STAGE_PRIORITY: {
            Debug::log(LOG, "Creating the EventLoopManager!");
-            g_pEventLoopManager = std::make_unique<CEventLoopManager>(m_sWLDisplay, m_sWLEventLoop);
+            g_pEventLoopManager = makeUnique<CEventLoopManager>(m_sWLDisplay, m_sWLEventLoop);

            Debug::log(LOG, "Creating the HookSystem!");
-            g_pHookSystem = std::make_unique<CHookSystemManager>();
+            g_pHookSystem = makeUnique<CHookSystemManager>();

            Debug::log(LOG, "Creating the KeybindManager!");
-            g_pKeybindManager = std::make_unique<CKeybindManager>();
+            g_pKeybindManager = makeUnique<CKeybindManager>();

            Debug::log(LOG, "Creating the AnimationManager!");
-            g_pAnimationManager = std::make_unique<CAnimationManager>();
+            g_pAnimationManager = makeUnique<CHyprAnimationManager>();

            Debug::log(LOG, "Creating the ConfigManager!");
-            g_pConfigManager = std::make_unique<CConfigManager>();
+            g_pConfigManager = makeUnique<CConfigManager>();

            Debug::log(LOG, "Creating the CHyprError!");
-            g_pHyprError = std::make_unique<CHyprError>();
+            g_pHyprError = makeUnique<CHyprError>();

            Debug::log(LOG, "Creating the LayoutManager!");
-            g_pLayoutManager = std::make_unique<CLayoutManager>();
+            g_pLayoutManager = makeUnique<CLayoutManager>();

            Debug::log(LOG, "Creating the TokenManager!");
-            g_pTokenManager = std::make_unique<CTokenManager>();
+            g_pTokenManager = makeUnique<CTokenManager>();

            g_pConfigManager->init();
-            g_pWatchdog = std::make_unique<CWatchdog>(); // requires config
+            g_pWatchdog = makeUnique<CWatchdog>(); // requires config
            // wait for watchdog to initialize to not hit data races in reading config values.
            while (!g_pWatchdog->m_bWatchdogInitialized) {
                std::this_thread::yield();
            }

            Debug::log(LOG, "Creating the PointerManager!");
-            g_pPointerManager = std::make_unique<CPointerManager>();
+            g_pPointerManager = makeUnique<CPointerManager>();

            Debug::log(LOG, "Creating the EventManager!");
-            g_pEventManager = std::make_unique<CEventManager>();
+            g_pEventManager = makeUnique<CEventManager>();
        } break;
        case STAGE_BASICINIT: {
            Debug::log(LOG, "Creating the CHyprOpenGLImpl!");
-            g_pHyprOpenGL = std::make_unique<CHyprOpenGLImpl>();
+            g_pHyprOpenGL = makeUnique<CHyprOpenGLImpl>();

            Debug::log(LOG, "Creating the ProtocolManager!");
-            g_pProtocolManager = std::make_unique<CProtocolManager>();
+            g_pProtocolManager = makeUnique<CProtocolManager>();

            Debug::log(LOG, "Creating the SeatManager!");
-            g_pSeatManager = std::make_unique<CSeatManager>();
+            g_pSeatManager = makeUnique<CSeatManager>();
        } break;
        case STAGE_LATE: {
-            Debug::log(LOG, "Creating the ThreadManager!");
-            g_pThreadManager = std::make_unique<CThreadManager>();
-
            Debug::log(LOG, "Creating CHyprCtl");
-            g_pHyprCtl = std::make_unique<CHyprCtl>();
+            g_pHyprCtl = makeUnique<CHyprCtl>();

            Debug::log(LOG, "Creating the InputManager!");
-            g_pInputManager = std::make_unique<CInputManager>();
+            g_pInputManager = makeUnique<CInputManager>();

            Debug::log(LOG, "Creating the HyprRenderer!");
-            g_pHyprRenderer = std::make_unique<CHyprRenderer>();
+            g_pHyprRenderer = makeUnique<CHyprRenderer>();

            Debug::log(LOG, "Creating the XWaylandManager!");
-            g_pXWaylandManager = std::make_unique<CHyprXWaylandManager>();
+            g_pXWaylandManager = makeUnique<CHyprXWaylandManager>();

            Debug::log(LOG, "Creating the SessionLockManager!");
-            g_pSessionLockManager = std::make_unique<CSessionLockManager>();
+            g_pSessionLockManager = makeUnique<CSessionLockManager>();

            Debug::log(LOG, "Creating the HyprDebugOverlay!");
-            g_pDebugOverlay = std::make_unique<CHyprDebugOverlay>();
+            g_pDebugOverlay = makeUnique<CHyprDebugOverlay>();

            Debug::log(LOG, "Creating the HyprNotificationOverlay!");
-            g_pHyprNotificationOverlay = std::make_unique<CHyprNotificationOverlay>();
+            g_pHyprNotificationOverlay = makeUnique<CHyprNotificationOverlay>();

            Debug::log(LOG, "Creating the PluginSystem!");
-            g_pPluginSystem = std::make_unique<CPluginSystem>();
+            g_pPluginSystem = makeUnique<CPluginSystem>();
            g_pConfigManager->handlePluginLoads();

            Debug::log(LOG, "Creating the DecorationPositioner!");
-            g_pDecorationPositioner = std::make_unique<CDecorationPositioner>();
+            g_pDecorationPositioner = makeUnique<CDecorationPositioner>();

            Debug::log(LOG, "Creating the CursorManager!");
-            g_pCursorManager = std::make_unique<CCursorManager>();
+            g_pCursorManager = makeUnique<CCursorManager>();

            Debug::log(LOG, "Creating the VersionKeeper!");
-            g_pVersionKeeperMgr = std::make_unique<CVersionKeeperManager>();
+            g_pVersionKeeperMgr = makeUnique<CVersionKeeperManager>();
+
+            Debug::log(LOG, "Creating the DonationNag!");
+            g_pDonationNagManager = makeUnique<CDonationNagManager>();

            Debug::log(LOG, "Starting XWayland");
-            g_pXWayland = std::make_unique<CXWayland>(g_pCompositor->m_bEnableXwayland);
+            g_pXWayland = makeUnique<CXWayland>(g_pCompositor->m_bWantsXwayland);
        } break;
        default: UNREACHABLE();
    }
@@ -969,11 +1003,11 @@ SP<CWLSurfaceResource> CCompositor::vectorWindowToSurface(const Vector2D& pos, P

    if (PPOPUP) {
        const auto OFF = PPOPUP->coordsRelativeToParent();
-        sl             = pos - pWindow->m_vRealPosition.goal() - OFF;
+        sl             = pos - pWindow->m_vRealPosition->goal() - OFF;
        return PPOPUP->m_pWLSurface->resource();
    }

-    auto [surf, local] = pWindow->m_pWLSurface->resource()->at(pos - pWindow->m_vRealPosition.goal(), true);
+    auto [surf, local] = pWindow->m_pWLSurface->resource()->at(pos - pWindow->m_vRealPosition->goal(), true);
    if (surf) {
        sl = local;
        return surf;
@@ -987,7 +1021,7 @@ Vector2D CCompositor::vectorToSurfaceLocal(const Vector2D& vec, PHLWINDOW pWindo
        return {};

    if (pWindow->m_bIsX11)
-        return vec - pWindow->m_vRealPosition.goal();
+        return vec - pWindow->m_vRealPosition->goal();

    const auto PPOPUP = pWindow->m_pPopupHead->at(vec);
    if (PPOPUP)
@@ -1006,9 +1040,9 @@ Vector2D CCompositor::vectorToSurfaceLocal(const Vector2D& vec, PHLWINDOW pWindo
    CBox geom = pWindow->m_pXDGSurface->current.geometry;

    if (std::get<1>(iterData) == Vector2D{-1337, -1337})
-        return vec - pWindow->m_vRealPosition.goal();
+        return vec - pWindow->m_vRealPosition->goal();

-    return vec - pWindow->m_vRealPosition.goal() - std::get<1>(iterData) + Vector2D{geom.x, geom.y};
+    return vec - pWindow->m_vRealPosition->goal() - std::get<1>(iterData) + Vector2D{geom.x, geom.y};
 }

 PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
@@ -1134,6 +1168,7 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
    g_pXWaylandManager->activateWindow(pWindow, true); // sets the m_pLastWindow

    pWindow->updateDynamicRules();
+    pWindow->onFocusAnimUpdate();

    updateWindowAnimatedDecorationValues(pWindow);

@@ -1216,7 +1251,7 @@ void CCompositor::focusSurface(SP<CWLSurfaceResource> pSurface, PHLWINDOW pWindo
 SP<CWLSurfaceResource> CCompositor::vectorToLayerPopupSurface(const Vector2D& pos, PHLMONITOR monitor, Vector2D* sCoords, PHLLS* ppLayerSurfaceFound) {
    for (auto const& lsl : monitor->m_aLayerSurfaceLayers | std::views::reverse) {
        for (auto const& ls : lsl | std::views::reverse) {
-            if (ls->fadingOut || !ls->layerSurface || (ls->layerSurface && !ls->layerSurface->mapped) || ls->alpha.value() == 0.f)
+            if (ls->fadingOut || !ls->layerSurface || (ls->layerSurface && !ls->layerSurface->mapped) || ls->alpha->value() == 0.f)
                continue;

            auto SURFACEAT = ls->popupHead->at(pos, true);
@@ -1234,7 +1269,7 @@ SP<CWLSurfaceResource> CCompositor::vectorToLayerPopupSurface(const Vector2D& po

 SP<CWLSurfaceResource> CCompositor::vectorToLayerSurface(const Vector2D& pos, std::vector<PHLLSREF>* layerSurfaces, Vector2D* sCoords, PHLLS* ppLayerSurfaceFound) {
    for (auto const& ls : *layerSurfaces | std::views::reverse) {
-        if (ls->fadingOut || !ls->layerSurface || (ls->layerSurface && !ls->layerSurface->surface->mapped) || ls->alpha.value() == 0.f)
+        if (ls->fadingOut || !ls->layerSurface || (ls->layerSurface && !ls->layerSurface->surface->mapped) || ls->alpha->value() == 0.f)
            continue;

        auto [surf, local] = ls->layerSurface->surface->at(pos - ls->geometry.pos(), true);
@@ -1383,7 +1418,7 @@ void CCompositor::cleanupFadingOut(const MONITORID& monid) {
        if (w->monitorID() != monid && w->m_pMonitor)
            continue;

-        if (!w->m_bFadingOut || w->m_fAlpha.value() == 0.f) {
+        if (!w->m_bFadingOut || w->m_fAlpha->value() == 0.f) {

            w->m_bFadingOut = false;

@@ -1465,7 +1500,21 @@ void CCompositor::addToFadingOutSafe(PHLWINDOW pWindow) {
 }

 PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
+    if (!isDirection(dir))
+        return nullptr;

+    const auto PMONITOR = pWindow->m_pMonitor.lock();
+
+    if (!PMONITOR)
+        return nullptr; // ??
+
+    const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{PMONITOR->vecPosition, PMONITOR->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
+    const auto PWORKSPACE    = pWindow->m_pWorkspace;
+
+    return getWindowInDirection(WINDOWIDEALBB, PWORKSPACE, dir, pWindow, pWindow->m_bIsFloating);
+}
+
+PHLWINDOW CCompositor::getWindowInDirection(const CBox& box, PHLWORKSPACE pWorkspace, char dir, PHLWINDOW ignoreWindow, bool useVectorAngles) {
    if (!isDirection(dir))
        return nullptr;

@@ -1473,34 +1522,24 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
    static auto PMETHOD          = CConfigValue<Hyprlang::INT>("binds:focus_preferred_method");
    static auto PMONITORFALLBACK = CConfigValue<Hyprlang::INT>("binds:window_direction_monitor_fallback");

-    const auto  PMONITOR = pWindow->m_pMonitor.lock();
+    const auto  POSA  = box.pos();
+    const auto  SIZEA = box.size();

-    if (!PMONITOR)
-        return nullptr; // ??
+    auto        leaderValue  = -1;
+    PHLWINDOW   leaderWindow = nullptr;

-    const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{PMONITOR->vecPosition, PMONITOR->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
-
-    const auto POSA  = Vector2D(WINDOWIDEALBB.x, WINDOWIDEALBB.y);
-    const auto SIZEA = Vector2D(WINDOWIDEALBB.width, WINDOWIDEALBB.height);
-
-    const auto PWORKSPACE   = pWindow->m_pWorkspace;
-    auto       leaderValue  = -1;
-    PHLWINDOW  leaderWindow = nullptr;
-
-    if (!pWindow->m_bIsFloating) {
-
-        // for tiled windows, we calc edges
+    if (!useVectorAngles) {
        for (auto const& w : m_vWindows) {
-            if (w == pWindow || !w->m_pWorkspace || !w->m_bIsMapped || w->isHidden() || (!w->isFullscreen() && w->m_bIsFloating) || !w->m_pWorkspace->isVisible())
+            if (w == ignoreWindow || !w->m_pWorkspace || !w->m_bIsMapped || w->isHidden() || (!w->isFullscreen() && w->m_bIsFloating) || !w->m_pWorkspace->isVisible())
                continue;

-            if (pWindow->m_pMonitor == w->m_pMonitor && pWindow->m_pWorkspace != w->m_pWorkspace)
+            if (pWorkspace->m_pMonitor == w->m_pMonitor && pWorkspace != w->m_pWorkspace)
                continue;

-            if (PWORKSPACE->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen)
+            if (pWorkspace->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen)
                continue;

-            if (!*PMONITORFALLBACK && pWindow->m_pMonitor != w->m_pMonitor)
+            if (!*PMONITORFALLBACK && pWorkspace->m_pMonitor != w->m_pMonitor)
                continue;

            const auto BWINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
@@ -1562,9 +1601,6 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
            }
        }
    } else {
-        // for floating windows, we calculate best distance and angle.
-        // if there is a window with angle better than THRESHOLD, only distance counts
-
        if (dir == 'u')
            dir = 't';
        if (dir == 'd')
@@ -1583,20 +1619,20 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
        constexpr float THRESHOLD    = 0.3 * M_PI;

        for (auto const& w : m_vWindows) {
-            if (w == pWindow || !w->m_bIsMapped || !w->m_pWorkspace || w->isHidden() || (!w->isFullscreen() && !w->m_bIsFloating) || !w->m_pWorkspace->isVisible())
+            if (w == ignoreWindow || !w->m_bIsMapped || !w->m_pWorkspace || w->isHidden() || (!w->isFullscreen() && !w->m_bIsFloating) || !w->m_pWorkspace->isVisible())
                continue;

-            if (pWindow->m_pMonitor == w->m_pMonitor && pWindow->m_pWorkspace != w->m_pWorkspace)
+            if (pWorkspace->m_pMonitor == w->m_pMonitor && pWorkspace != w->m_pWorkspace)
                continue;

-            if (PWORKSPACE->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen)
+            if (pWorkspace->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen)
                continue;

-            if (!*PMONITORFALLBACK && pWindow->m_pMonitor != w->m_pMonitor)
+            if (!*PMONITORFALLBACK && pWorkspace->m_pMonitor != w->m_pMonitor)
                continue;

-            const auto DIST  = w->middle().distance(pWindow->middle());
-            const auto ANGLE = vectorAngles(Vector2D{w->middle() - pWindow->middle()}, VECTORS.at(dir));
+            const auto DIST  = w->middle().distance(box.middle());
+            const auto ANGLE = vectorAngles(Vector2D{w->middle() - box.middle()}, VECTORS.at(dir));

            if (ANGLE > M_PI_2)
                continue; // if the angle is over 90 degrees, ignore. Wrong direction entirely.
@@ -1608,8 +1644,8 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
            }
        }

-        if (!leaderWindow && PWORKSPACE->m_bHasFullscreenWindow)
-            leaderWindow = PWORKSPACE->getFullscreenWindow();
+        if (!leaderWindow && pWorkspace->m_bHasFullscreenWindow)
+            leaderWindow = pWorkspace->getFullscreenWindow();
    }

    if (leaderValue != -1)
@@ -1618,62 +1654,37 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
    return nullptr;
 }

-PHLWINDOW CCompositor::getNextWindowOnWorkspace(PHLWINDOW pWindow, bool focusableOnly, std::optional<bool> floating) {
-    bool gotToWindow = false;
-    for (auto const& w : m_vWindows) {
-        if (w != pWindow && !gotToWindow)
-            continue;
-
-        if (w == pWindow) {
-            gotToWindow = true;
-            continue;
-        }
-
-        if (floating.has_value() && w->m_bIsFloating != floating.value())
-            continue;
-
-        if (w->m_pWorkspace == pWindow->m_pWorkspace && w->m_bIsMapped && !w->isHidden() && (!focusableOnly || !w->m_sWindowData.noFocus.valueOrDefault()))
-            return w;
-    }
-
-    for (auto const& w : m_vWindows) {
-        if (floating.has_value() && w->m_bIsFloating != floating.value())
-            continue;
-
-        if (w != pWindow && w->m_pWorkspace == pWindow->m_pWorkspace && w->m_bIsMapped && !w->isHidden() && (!focusableOnly || !w->m_sWindowData.noFocus.valueOrDefault()))
-            return w;
-    }
-
-    return nullptr;
+PHLWINDOW CCompositor::getNextWindowOnWorkspace(PHLWINDOW pWindow, bool focusableOnly, std::optional<bool> floating, bool visible) {
+    auto       it       = std::ranges::find(m_vWindows, pWindow);
+    const auto FINDER   = [&](const PHLWINDOW& w) { return isWindowAvailableForCycle(pWindow, w, focusableOnly, floating, visible); };
+    const auto IN_RIGHT = std::find_if(it, m_vWindows.end(), FINDER);
+    if (IN_RIGHT != m_vWindows.end())
+        return *IN_RIGHT;
+    const auto IN_LEFT = std::find_if(m_vWindows.begin(), it, FINDER);
+    return *IN_LEFT;
 }

-PHLWINDOW CCompositor::getPrevWindowOnWorkspace(PHLWINDOW pWindow, bool focusableOnly, std::optional<bool> floating) {
-    bool gotToWindow = false;
-    for (auto const& w : m_vWindows | std::views::reverse) {
-        if (w != pWindow && !gotToWindow)
-            continue;
+PHLWINDOW CCompositor::getPrevWindowOnWorkspace(PHLWINDOW pWindow, bool focusableOnly, std::optional<bool> floating, bool visible) {
+    auto       it      = std::ranges::find(std::ranges::reverse_view(m_vWindows), pWindow);
+    const auto FINDER  = [&](const PHLWINDOW& w) { return isWindowAvailableForCycle(pWindow, w, focusableOnly, floating, visible); };
+    const auto IN_LEFT = std::find_if(it, m_vWindows.rend(), FINDER);
+    if (IN_LEFT != m_vWindows.rend())
+        return *IN_LEFT;
+    const auto IN_RIGHT = std::find_if(m_vWindows.rbegin(), it, FINDER);
+    return *IN_RIGHT;
+}

-        if (w == pWindow) {
-            gotToWindow = true;
-            continue;
-        }
+inline static bool isWorkspaceMatches(PHLWINDOW pWindow, const PHLWINDOW w, bool anyWorkspace) {
+    return anyWorkspace ? w->m_pWorkspace && w->m_pWorkspace->isVisible() : w->m_pWorkspace == pWindow->m_pWorkspace;
+}

-        if (floating.has_value() && w->m_bIsFloating != floating.value())
-            continue;
+inline static bool isFloatingMatches(PHLWINDOW w, std::optional<bool> floating) {
+    return !floating.has_value() || w->m_bIsFloating == floating.value();
+};

-        if (w->m_pWorkspace == pWindow->m_pWorkspace && w->m_bIsMapped && !w->isHidden() && (!focusableOnly || !w->m_sWindowData.noFocus.valueOrDefault()))
-            return w;
-    }
-
-    for (auto const& w : m_vWindows | std::views::reverse) {
-        if (floating.has_value() && w->m_bIsFloating != floating.value())
-            continue;
-
-        if (w != pWindow && w->m_pWorkspace == pWindow->m_pWorkspace && w->m_bIsMapped && !w->isHidden() && (!focusableOnly || !w->m_sWindowData.noFocus.valueOrDefault()))
-            return w;
-    }
-
-    return nullptr;
+bool CCompositor::isWindowAvailableForCycle(PHLWINDOW pWindow, const PHLWINDOW w, bool focusableOnly, std::optional<bool> floating, bool anyWorkspace) {
+    return isFloatingMatches(w, floating) && w != pWindow && isWorkspaceMatches(pWindow, w, anyWorkspace) && w->m_bIsMapped && !w->isHidden() &&
+        (!focusableOnly || !w->m_sWindowData.noFocus.valueOrDefault());
 }

 WORKSPACEID CCompositor::getNextAvailableNamedWorkspace() {
@@ -1708,12 +1719,8 @@ PHLWORKSPACE CCompositor::getWorkspaceByString(const std::string& str) {
 }

 bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
-    for (auto const& m : m_vMonitors) {
-        if (VECINRECT(point, m->vecPosition.x, m->vecPosition.y, m->vecSize.x + m->vecPosition.x, m->vecSize.y + m->vecPosition.y))
-            return true;
-    }
-
-    return false;
+    return std::ranges::any_of(
+        m_vMonitors, [&](const PHLMONITOR& m) { return VECINRECT(point, m->vecPosition.x, m->vecPosition.y, m->vecSize.x + m->vecPosition.x, m->vecSize.y + m->vecPosition.y); });
 }

 bool CCompositor::isPointOnReservedArea(const Vector2D& point, const PHLMONITOR pMonitor) {
@@ -1835,8 +1842,8 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {

        pWindow->m_cRealBorderColorPrevious = pWindow->m_cRealBorderColor;
        pWindow->m_cRealBorderColor         = grad;
-        pWindow->m_fBorderFadeAnimationProgress.setValueAndWarp(0.f);
-        pWindow->m_fBorderFadeAnimationProgress = 1.f;
+        pWindow->m_fBorderFadeAnimationProgress->setValueAndWarp(0.f);
+        *pWindow->m_fBorderFadeAnimationProgress = 1.f;
    };

    const bool IS_SHADOWED_BY_MODAL = pWindow->m_pXDGSurface && pWindow->m_pXDGSurface->toplevel && pWindow->m_pXDGSurface->toplevel->anyChildModal();
@@ -1858,19 +1865,15 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {
        }
    }

-    // tick angle if it's not running (aka dead)
-    if (!pWindow->m_fBorderAngleAnimationProgress.isBeingAnimated())
-        pWindow->m_fBorderAngleAnimationProgress.setValueAndWarp(0.f);
-
    // opacity
    const auto PWORKSPACE = pWindow->m_pWorkspace;
    if (pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN)) {
-        pWindow->m_fActiveInactiveAlpha = pWindow->m_sWindowData.alphaFullscreen.valueOrDefault().applyAlpha(*PFULLSCREENALPHA);
+        *pWindow->m_fActiveInactiveAlpha = pWindow->m_sWindowData.alphaFullscreen.valueOrDefault().applyAlpha(*PFULLSCREENALPHA);
    } else {
        if (pWindow == m_pLastWindow)
-            pWindow->m_fActiveInactiveAlpha = pWindow->m_sWindowData.alpha.valueOrDefault().applyAlpha(*PACTIVEALPHA);
+            *pWindow->m_fActiveInactiveAlpha = pWindow->m_sWindowData.alpha.valueOrDefault().applyAlpha(*PACTIVEALPHA);
        else
-            pWindow->m_fActiveInactiveAlpha = pWindow->m_sWindowData.alphaInactive.valueOrDefault().applyAlpha(*PINACTIVEALPHA);
+            *pWindow->m_fActiveInactiveAlpha = pWindow->m_sWindowData.alphaInactive.valueOrDefault().applyAlpha(*PINACTIVEALPHA);
    }

    // dim
@@ -1883,16 +1886,16 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {
    if (IS_SHADOWED_BY_MODAL)
        goalDim += (1.F - goalDim) / 2.F;

-    pWindow->m_fDimPercent = goalDim;
+    *pWindow->m_fDimPercent = goalDim;

    // shadow
    if (!pWindow->isX11OverrideRedirect() && !pWindow->m_bX11DoesntWantBorders) {
        if (pWindow == m_pLastWindow)
-            pWindow->m_cRealShadowColor = CHyprColor(*PSHADOWCOL);
+            *pWindow->m_cRealShadowColor = CHyprColor(*PSHADOWCOL);
        else
-            pWindow->m_cRealShadowColor = CHyprColor(*PSHADOWCOLINACTIVE != INT64_MAX ? *PSHADOWCOLINACTIVE : *PSHADOWCOL);
+            *pWindow->m_cRealShadowColor = CHyprColor(*PSHADOWCOLINACTIVE != INT64_MAX ? *PSHADOWCOLINACTIVE : *PSHADOWCOL);
    } else {
-        pWindow->m_cRealShadowColor.setValueAndWarp(CHyprColor(0, 0, 0, 0)); // no shadow
+        pWindow->m_cRealShadowColor->setValueAndWarp(CHyprColor(0, 0, 0, 0)); // no shadow
    }

    pWindow->updateWindowDecos();
@@ -1936,11 +1939,11 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor

            // additionally, move floating and fs windows manually
            if (w->m_bIsFloating)
-                w->m_vRealPosition = w->m_vRealPosition.goal() - pMonitorA->vecPosition + pMonitorB->vecPosition;
+                *w->m_vRealPosition = w->m_vRealPosition->goal() - pMonitorA->vecPosition + pMonitorB->vecPosition;

            if (w->isFullscreen()) {
-                w->m_vRealPosition = pMonitorB->vecPosition;
-                w->m_vRealSize     = pMonitorB->vecSize;
+                *w->m_vRealPosition = pMonitorB->vecPosition;
+                *w->m_vRealSize     = pMonitorB->vecSize;
            }

            w->updateToplevel();
@@ -1961,11 +1964,11 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor

            // additionally, move floating and fs windows manually
            if (w->m_bIsFloating)
-                w->m_vRealPosition = w->m_vRealPosition.goal() - pMonitorB->vecPosition + pMonitorA->vecPosition;
+                *w->m_vRealPosition = w->m_vRealPosition->goal() - pMonitorB->vecPosition + pMonitorA->vecPosition;

            if (w->isFullscreen()) {
-                w->m_vRealPosition = pMonitorA->vecPosition;
-                w->m_vRealSize     = pMonitorA->vecSize;
+                *w->m_vRealPosition = pMonitorA->vecPosition;
+                *w->m_vRealSize     = pMonitorA->vecSize;
            }

            w->updateToplevel();
@@ -2080,7 +2083,8 @@ PHLMONITOR CCompositor::getMonitorFromString(const std::string& name) {

 void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMonitor, bool noWarpCursor) {

-    // We trust the monitor to be correct.
+    if (!pWorkspace || !pMonitor)
+        return;

    if (pWorkspace->m_pMonitor == pMonitor)
        return;
@@ -2138,14 +2142,14 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
            if (w->m_bIsMapped && !w->isHidden()) {
                if (POLDMON) {
                    if (w->m_bIsFloating)
-                        w->m_vRealPosition = w->m_vRealPosition.goal() - POLDMON->vecPosition + pMonitor->vecPosition;
+                        *w->m_vRealPosition = w->m_vRealPosition->goal() - POLDMON->vecPosition + pMonitor->vecPosition;

                    if (w->isFullscreen()) {
-                        w->m_vRealPosition = pMonitor->vecPosition;
-                        w->m_vRealSize     = pMonitor->vecSize;
+                        *w->m_vRealPosition = pMonitor->vecPosition;
+                        *w->m_vRealSize     = pMonitor->vecSize;
                    }
                } else {
-                    w->m_vRealPosition = Vector2D{(int)w->m_vRealPosition.goal().x % (int)pMonitor->vecSize.x, (int)w->m_vRealPosition.goal().y % (int)pMonitor->vecSize.y};
+                    *w->m_vRealPosition = Vector2D{(int)w->m_vRealPosition->goal().x % (int)pMonitor->vecSize.x, (int)w->m_vRealPosition->goal().y % (int)pMonitor->vecSize.y};
                }
            }

@@ -2219,9 +2223,9 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) {
                continue;

            if (!FULLSCREEN)
-                w->m_fAlpha = 1.f;
+                *w->m_fAlpha = 1.f;
            else if (!w->isFullscreen())
-                w->m_fAlpha = !w->m_bCreatedOverFullscreen ? 0.f : 1.f;
+                *w->m_fAlpha = !w->m_bCreatedOverFullscreen ? 0.f : 1.f;
        }
    }

@@ -2230,16 +2234,11 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) {
    if (pWorkspace->m_iID == PMONITOR->activeWorkspaceID() || pWorkspace->m_iID == PMONITOR->activeSpecialWorkspaceID()) {
        for (auto const& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
            if (!ls->fadingOut)
-                ls->alpha = FULLSCREEN && pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
+                *ls->alpha = FULLSCREEN && pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
        }
    }
 }

-void CCompositor::changeWindowFullscreenModeInternal(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON) {
-    setWindowFullscreenInternal(
-        PWINDOW, (eFullscreenMode)(ON ? (uint8_t)PWINDOW->m_sFullscreenState.internal | (uint8_t)MODE : ((uint8_t)PWINDOW->m_sFullscreenState.internal & (uint8_t)~MODE)));
-}
-
 void CCompositor::changeWindowFullscreenModeClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON) {
    setWindowFullscreenClient(PWINDOW,
                              (eFullscreenMode)(ON ? (uint8_t)PWINDOW->m_sFullscreenState.client | (uint8_t)MODE : ((uint8_t)PWINDOW->m_sFullscreenState.client & (uint8_t)~MODE)));
@@ -2325,7 +2324,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, SFullscreenS

    updateFullscreenFadeOnWorkspace(PWORKSPACE);

-    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal(), true);
+    PWINDOW->sendWindowSize(PWINDOW->m_vRealSize->goal(), true);

    PWORKSPACE->forceReportSizesToWindows();

@@ -2408,6 +2407,9 @@ PHLWINDOW CCompositor::getWindowByRegex(const std::string& regexp_) {
    } else if (regexp.starts_with("initialtitle:")) {
        mode       = MODE_INITIAL_TITLE_REGEX;
        regexCheck = regexp.substr(13);
+    } else if (regexp.starts_with("tag:")) {
+        mode       = MODE_TAG_REGEX;
+        regexCheck = regexp.substr(4);
    } else if (regexp.starts_with("address:")) {
        mode       = MODE_ADDRESS;
        matchCheck = regexp.substr(8);
@@ -2445,6 +2447,18 @@ PHLWINDOW CCompositor::getWindowByRegex(const std::string& regexp_) {
                    continue;
                break;
            }
+            case MODE_TAG_REGEX: {
+                bool tagMatched = false;
+                for (auto const& t : w->m_tags.getTags()) {
+                    if (RE2::FullMatch(t, regexCheck)) {
+                        tagMatched = true;
+                        break;
+                    }
+                }
+                if (!tagMatched)
+                    continue;
+                break;
+            }
            case MODE_ADDRESS: {
                std::string addr = std::format("0x{:x}", (uintptr_t)w.get());
                if (matchCheck != addr)
@@ -2504,13 +2518,13 @@ PHLLS CCompositor::getLayerSurfaceFromSurface(SP<CWLSurfaceResource> pSurface) {
            continue;

        ls->layerSurface->surface->breadthfirst(
-            [](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) {
-                if (surf == ((std::pair<SP<CWLSurfaceResource>, bool>*)data)->first) {
-                    *(bool*)data = true;
+            [&result](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) {
+                if (surf == result.first) {
+                    result.second = true;
                    return;
                }
            },
-            &result);
+            nullptr);

        if (result.second)
            return ls;
@@ -2581,7 +2595,7 @@ PHLWORKSPACE CCompositor::createNewWorkspace(const WORKSPACEID& id, const MONITO

    const auto PWORKSPACE = m_vWorkspaces.emplace_back(CWorkspace::create(id, getMonitorFromID(monID), NAME, SPECIAL, isEmpty));

-    PWORKSPACE->m_fAlpha.setValueAndWarp(0);
+    PWORKSPACE->m_fAlpha->setValueAndWarp(0);

    return PWORKSPACE;
 }
@@ -2597,7 +2611,12 @@ void CCompositor::setActiveMonitor(PHLMONITOR pMonitor) {

    const auto PWORKSPACE = pMonitor->activeWorkspace;

-    g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", pMonitor->szName + "," + (PWORKSPACE ? PWORKSPACE->m_szName : "?")});
+    const auto WORKSPACE_ID   = PWORKSPACE ? std::to_string(PWORKSPACE->m_iID) : std::to_string(WORKSPACE_INVALID);
+    const auto WORKSPACE_NAME = PWORKSPACE ? PWORKSPACE->m_szName : "?";
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", pMonitor->szName + "," + WORKSPACE_NAME});
+    g_pEventManager->postEvent(SHyprIPCEvent{"focusedmonv2", pMonitor->szName + "," + WORKSPACE_ID});
+
    EMIT_HOOK_EVENT("focusedMon", pMonitor);
    m_pLastMonitor = pMonitor->self;
 }
@@ -2632,7 +2651,7 @@ void CCompositor::performUserChecks() {
    }

    if (!*PNOCHECKQTUTILS) {
-        if (!executableExistsInPath("hyprland-dialog")) {
+        if (!NFsUtils::executableExistsInPath("hyprland-dialog")) {
            g_pHyprNotificationOverlay->addNotification(
                "Your system does not have hyprland-qtutils installed. This is a runtime dependency for some dialogs. Consider installing it.", CHyprColor{}, 15000, ICON_WARNING);
        }
@@ -2654,6 +2673,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor

    const bool FULLSCREEN     = pWindow->isFullscreen();
    const auto FULLSCREENMODE = pWindow->m_sFullscreenState.internal;
+    const bool WASVISIBLE     = pWindow->m_pWorkspace && pWindow->m_pWorkspace->isVisible();

    if (FULLSCREEN)
        setWindowFullscreenInternal(pWindow, FSMODE_NONE);
@@ -2661,7 +2681,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
    const PHLWINDOW pFirstWindowOnWorkspace   = pWorkspace->getFirstWindow();
    const int       visibleWindowsOnWorkspace = pWorkspace->getWindows(std::nullopt, true);
    const auto      PWINDOWMONITOR            = pWindow->m_pMonitor.lock();
-    const auto      POSTOMON                  = pWindow->m_vRealPosition.goal() - PWINDOWMONITOR->vecPosition;
+    const auto      POSTOMON                  = pWindow->m_vRealPosition->goal() - PWINDOWMONITOR->vecPosition;
    const auto      PWORKSPACEMONITOR         = pWorkspace->m_pMonitor.lock();

    if (!pWindow->m_bIsFloating)
@@ -2691,14 +2711,14 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
        g_pLayoutManager->getCurrentLayout()->recalculateWindow(pWindow);

        if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
-            pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow));
+            pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));

    } else {
        if (!pWindow->m_bIsFloating)
            g_pLayoutManager->getCurrentLayout()->onWindowCreatedTiling(pWindow);

        if (pWindow->m_bIsFloating)
-            pWindow->m_vRealPosition = POSTOMON + PWORKSPACEMONITOR->vecPosition;
+            *pWindow->m_vRealPosition = POSTOMON + PWORKSPACEMONITOR->vecPosition;
    }

    pWindow->updateToplevel();
@@ -2721,6 +2741,11 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
    if (pWindow->m_pWorkspace)
        pWindow->m_pWorkspace->updateWindows();
    g_pCompositor->updateSuspendedStates();
+
+    if (!WASVISIBLE && pWindow->m_pWorkspace && pWindow->m_pWorkspace->isVisible()) {
+        pWindow->m_fMovingFromWorkspaceAlpha->setValueAndWarp(0.F);
+        *pWindow->m_fMovingFromWorkspaceAlpha = 1.F;
+    }
 }

 PHLWINDOW CCompositor::getForceFocus() {
@@ -2740,11 +2765,9 @@ PHLWINDOW CCompositor::getForceFocus() {
 void CCompositor::arrangeMonitors() {
    static auto* const      PXWLFORCESCALEZERO = (Hyprlang::INT* const*)g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling");

-    std::vector<PHLMONITOR> toArrange;
+    std::vector<PHLMONITOR> toArrange(m_vMonitors.begin(), m_vMonitors.end());
    std::vector<PHLMONITOR> arranged;
-
-    for (auto const& m : m_vMonitors)
-        toArrange.push_back(m);
+    arranged.reserve(toArrange.size());

    Debug::log(LOG, "arrangeMonitors: {} to arrange", toArrange.size());

@@ -2905,17 +2928,6 @@ void CCompositor::updateSuspendedStates() {
    }
 }

-PHLWINDOW CCompositor::windowForCPointer(CWindow* pWindow) {
-    for (auto const& w : m_vWindows) {
-        if (w.get() != pWindow)
-            continue;
-
-        return w;
-    }
-
-    return {};
-}
-
 static void checkDefaultCursorWarp(PHLMONITOR monitor) {
    static auto PCURSORMONITOR    = CConfigValue<std::string>("cursor:default_monitor");
    static bool cursorDefaultDone = false;
@@ -2993,4 +3005,65 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {

    g_pHyprRenderer->damageMonitor(PNEWMONITOR);
    PNEWMONITOR->onMonitorFrame();
+
+    if (PROTO::colorManagement && shouldChangePreferredImageDescription())
+        PROTO::colorManagement->onImagePreferredChanged();
+}
+
+SImageDescription CCompositor::getPreferredImageDescription() {
+    if (!PROTO::colorManagement) {
+        Debug::log(ERR, "FIXME: color management protocol is not enabled, returning empty image description");
+        return SImageDescription{};
+    }
+    Debug::log(WARN, "FIXME: color management protocol is enabled, determine correct preferred image description");
+    // should determine some common settings to avoid unnecessary transformations while keeping maximum displayable precision
+    return SImageDescription{.primaries = NColorPrimaries::BT709};
+}
+
+bool CCompositor::shouldChangePreferredImageDescription() {
+    Debug::log(WARN, "FIXME: color management protocol is enabled and outputs changed, check preferred image description changes");
+    return false;
+}
+
+void CCompositor::ensurePersistentWorkspacesPresent(const std::vector<SWorkspaceRule>& rules) {
+    for (const auto& rule : rules) {
+        if (!rule.isPersistent)
+            continue;
+
+        const auto PMONITOR = getMonitorFromString(rule.monitor);
+
+        if (!PMONITOR) {
+            Debug::log(ERR, "ensurePersistentWorkspacesPresent: couldn't resolve monitor for {}, skipping", rule.monitor);
+            continue;
+        }
+
+        WORKSPACEID id     = rule.workspaceId;
+        std::string wsname = rule.workspaceName;
+        if (id == WORKSPACE_INVALID) {
+            const auto R = getWorkspaceIDNameFromString(rule.workspaceString);
+            id           = R.id;
+            wsname       = R.name;
+        }
+
+        if (id == WORKSPACE_INVALID) {
+            Debug::log(ERR, "ensurePersistentWorkspacesPresent: couldn't resolve id for workspace {}", rule.workspaceString);
+            continue;
+        }
+
+        if (const auto PWORKSPACE = getWorkspaceByID(id); PWORKSPACE) {
+            if (PWORKSPACE->m_pMonitor == PMONITOR) {
+                Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} already on {}", rule.workspaceString, PMONITOR->szName);
+                continue;
+            }
+
+            Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} not on {}, moving", rule.workspaceString, PMONITOR->szName);
+            moveWorkspaceToMonitor(PWORKSPACE, PMONITOR);
+            continue;
+        }
+
+        createNewWorkspace(id, PMONITOR ? PMONITOR : m_pLastMonitor.lock(), wsname, false);
+    }
+
+    // cleanup old
+    sanityCheckWorkspaces();
 }
--- a/src/Compositor.hpp
+++ b/src/Compositor.hpp
@@ -1,38 +1,21 @@
 #pragma once

-#include <memory>
 #include <list>
 #include <sys/resource.h>

 #include "defines.hpp"
-#include "debug/Log.hpp"
-#include "events/Events.hpp"
-#include "config/ConfigManager.hpp"
-#include "managers/ThreadManager.hpp"
 #include "managers/XWaylandManager.hpp"
-#include "managers/input/InputManager.hpp"
-#include "managers/LayoutManager.hpp"
 #include "managers/KeybindManager.hpp"
-#include "managers/AnimationManager.hpp"
-#include "managers/EventManager.hpp"
-#include "managers/ProtocolManager.hpp"
 #include "managers/SessionLockManager.hpp"
-#include "managers/HookSystemManager.hpp"
-#include "debug/HyprDebugOverlay.hpp"
-#include "debug/HyprNotificationOverlay.hpp"
-#include "helpers/Monitor.hpp"
-#include "desktop/Workspace.hpp"
 #include "desktop/Window.hpp"
-#include "render/Renderer.hpp"
-#include "render/OpenGL.hpp"
-#include "hyprerror/HyprError.hpp"
-#include "plugins/PluginSystem.hpp"
-#include "helpers/Watchdog.hpp"
+#include "protocols/types/ColorManagement.hpp"
+#include "helpers/memory/Memory.hpp"

 #include <aquamarine/backend/Backend.hpp>
 #include <aquamarine/output/Output.hpp>

 class CWLSurfaceResource;
+struct SWorkspaceRule;

 enum eManagersInitStage : uint8_t {
    STAGE_PRIORITY = 0,
@@ -42,7 +25,7 @@ enum eManagersInitStage : uint8_t {

 class CCompositor {
  public:
-    CCompositor();
+    CCompositor(bool onlyConfig = false);
    ~CCompositor();

    wl_display*                                m_sWLDisplay;
@@ -89,10 +72,11 @@ class CCompositor {
    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_bEnableXwayland = true;
+    bool                                       m_bIsShuttingDown         = false;
+    bool                                       m_bFinalRequests          = false;
+    bool                                       m_bDesktopEnvSet          = false;
+    bool                                       m_bWantsXwayland          = true;
+    bool                                       m_bOnlyConfigVerification = false;

    // ------------------------------------------------- //

@@ -123,8 +107,9 @@ class CCompositor {
    void                   changeWindowZOrder(PHLWINDOW, bool);
    void                   cleanupFadingOut(const MONITORID& monid);
    PHLWINDOW              getWindowInDirection(PHLWINDOW, char);
-    PHLWINDOW              getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
-    PHLWINDOW              getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
+    PHLWINDOW              getWindowInDirection(const CBox& box, PHLWORKSPACE pWorkspace, char dir, PHLWINDOW ignoreWindow = nullptr, bool useVectorAngles = false);
+    PHLWINDOW              getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {}, bool visible = false);
+    PHLWINDOW              getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {}, bool visible = false);
    WORKSPACEID            getNextAvailableNamedWorkspace();
    bool                   isPointOnAnyMonitor(const Vector2D&);
    bool                   isPointOnReservedArea(const Vector2D& point, const PHLMONITOR monitor = nullptr);
@@ -140,7 +125,6 @@ class CCompositor {
    void                   setWindowFullscreenInternal(const PHLWINDOW PWINDOW, const eFullscreenMode MODE);
    void                   setWindowFullscreenClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE);
    void                   setWindowFullscreenState(const PHLWINDOW PWINDOW, const SFullscreenState state);
-    void                   changeWindowFullscreenModeInternal(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON);
    void                   changeWindowFullscreenModeClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON);
    void                   updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
    PHLWINDOW              getX11Parent(PHLWINDOW);
@@ -167,8 +151,11 @@ class CCompositor {
    void                   setPreferredScaleForSurface(SP<CWLSurfaceResource> pSurface, double scale);
    void                   setPreferredTransformForSurface(SP<CWLSurfaceResource> pSurface, wl_output_transform transform);
    void                   updateSuspendedStates();
-    PHLWINDOW              windowForCPointer(CWindow*);
    void                   onNewMonitor(SP<Aquamarine::IOutput> output);
+    void                   ensurePersistentWorkspacesPresent(const std::vector<SWorkspaceRule>& rules);
+
+    SImageDescription      getPreferredImageDescription();
+    bool                   shouldChangePreferredImageDescription();

    std::string            explicitConfigPath;

@@ -179,10 +166,11 @@ class CCompositor {
    void             setRandomSplash();
    void             initManagers(eManagersInitStage stage);
    void             prepareFallbackOutput();
+    bool             isWindowAvailableForCycle(PHLWINDOW pWindow, PHLWINDOW w, bool focusableOnly, std::optional<bool> floating, bool anyWorkspace = false);

    uint64_t         m_iHyprlandPID    = 0;
    wl_event_source* m_critSigSource   = nullptr;
    rlimit           m_sOriginalNofile = {0};
 };

-inline std::unique_ptr<CCompositor> g_pCompositor;
+inline UP<CCompositor> g_pCompositor;
--- a/src/SharedDefs.hpp
+++ b/src/SharedDefs.hpp
@@ -3,6 +3,8 @@
 #include "helpers/math/Math.hpp"
 #include <functional>
 #include <any>
+#include <string>
+#include <algorithm>
 #include <hyprutils/math/Box.hpp>

 enum eIcons : uint8_t {
@@ -50,6 +52,12 @@ struct SHyprCtlCommand {
    std::function<std::string(eHyprCtlOutputFormat, std::string)> fn;
 };

+struct SDispatchResult {
+    bool        passEvent = false;
+    bool        success   = true;
+    std::string error;
+};
+
 typedef int64_t                                              WINDOWID;
 typedef int64_t                                              MONITORID;
 typedef int64_t                                              WORKSPACEID;
--- a/src/config/ConfigDescriptions.hpp
+++ b/src/config/ConfigDescriptions.hpp
@@ -139,6 +139,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_INT,
        .data        = SConfigOptionDescription::SRangeData{0, 0, 20},
    },
+    SConfigOptionDescription{
+        .value       = "decoration:rounding_power",
+        .description = "rouding power of corners (2 is a circle)",
+        .type        = CONFIG_OPTION_FLOAT,
+        .data        = SConfigOptionDescription::SFloatData{2, 2, 10},
+    },
    SConfigOptionDescription{
        .value       = "decoration:active_opacity",
        .description = "opacity of active windows. [0.0 - 1.0]",
@@ -1289,6 +1295,30 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
+    SConfigOptionDescription{
+        .value       = "render:expand_undersized_textures",
+        .description = "Whether to expand textures that have not yet resized to be larger, or to just stretch them instead.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
+    SConfigOptionDescription{
+        .value       = "render:xp_mode",
+        .description = "Disable back buffer and bottom layer rendering.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
+    SConfigOptionDescription{
+        .value       = "render:ctm_animation",
+        .description = "Whether to enable a fade animation for CTM changes (hyprsunset). 2 means 'auto' (Yes on everything but Nvidia).",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{2, 0, 2},
+    },
+    SConfigOptionDescription{
+        .value       = "render:allow_early_buffer_release",
+        .description = "Allow early buffer release event. Fixes stuttering and missing frames for some apps. May cause graphical glitches and memory leaks in others",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },

    /*
     * cursor:
@@ -1603,10 +1633,16 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
-        .value       = "master:always_center_master",
-        .description = "when using orientation=center, keep the master window centered, even when it is the only window in the workspace.",
+        .value       = "master:slave_count_for_center_master",
+        .description = "when using orientation=center, make the master window centered only when at least this many slave windows are open. (Set 0 to always_center_master)",
+        .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{false},
+        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
        .value       = "master:center_ignores_reserved",
@@ -1628,4 +1664,22 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
+    SConfigOptionDescription{
+        .value       = "experimental:wide_color_gamut",
+        .description = "force wide color gamut for all supported outputs",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "experimental:hdr",
+        .description = "force static hdr for all supported outputs",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "experimental:xx_color_management_v4",
+        .description = "enable color management protocol",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
 };
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
@@ -1,6 +1,7 @@
 #include <re2/re2.h>

 #include "ConfigManager.hpp"
+#include "ConfigWatcher.hpp"
 #include "../managers/KeybindManager.hpp"
 #include "../Compositor.hpp"

@@ -11,7 +12,20 @@
 #include "../protocols/LayerShell.hpp"
 #include "../xwayland/XWayland.hpp"
 #include "../protocols/OutputManagement.hpp"
+#include "../managers/AnimationManager.hpp"
+#include "../desktop/LayerSurface.hpp"
+#include "defaultConfig.hpp"

+#include "../render/Renderer.hpp"
+#include "../hyprerror/HyprError.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/eventLoop/EventLoopManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/EventManager.hpp"
+#include "../debug/HyprNotificationOverlay.hpp"
+#include "../plugins/PluginSystem.hpp"
+
+#include "managers/HookSystemManager.hpp"
 #include <cstddef>
 #include <cstdint>
 #include <hyprutils/path/Path.hpp>
@@ -31,7 +45,9 @@
 #include <unordered_set>
 #include <hyprutils/string/String.hpp>
 #include <filesystem>
+#include <memory>
 using namespace Hyprutils::String;
+using namespace Hyprutils::Animation;

 //NOLINTNEXTLINE
 extern "C" char** environ;
@@ -128,6 +144,18 @@ static void configHandleGapDestroy(void** data) {
        delete reinterpret_cast<CCssGapData*>(*data);
 }

+static Hyprlang::CParseResult handleExec(const char* c, const char* v) {
+    const std::string      VALUE   = v;
+    const std::string      COMMAND = c;
+
+    const auto             RESULT = g_pConfigManager->handleExec(COMMAND, VALUE);
+
+    Hyprlang::CParseResult result;
+    if (RESULT.has_value())
+        result.setError(RESULT.value().c_str());
+    return result;
+}
+
 static Hyprlang::CParseResult handleRawExec(const char* c, const char* v) {
    const std::string      VALUE   = v;
    const std::string      COMMAND = c;
@@ -152,6 +180,18 @@ static Hyprlang::CParseResult handleExecOnce(const char* c, const char* v) {
    return result;
 }

+static Hyprlang::CParseResult handleExecRawOnce(const char* c, const char* v) {
+    const std::string      VALUE   = v;
+    const std::string      COMMAND = c;
+
+    const auto             RESULT = g_pConfigManager->handleExecRawOnce(COMMAND, VALUE);
+
+    Hyprlang::CParseResult result;
+    if (RESULT.has_value())
+        result.setError(RESULT.value().c_str());
+    return result;
+}
+
 static Hyprlang::CParseResult handleExecShutdown(const char* c, const char* v) {
    const std::string      VALUE   = v;
    const std::string      COMMAND = c;
@@ -335,8 +375,8 @@ static Hyprlang::CParseResult handlePlugin(const char* c, const char* v) {
 CConfigManager::CConfigManager() {
    const auto ERR = verifyConfigExists();

-    configPaths.emplace_back(getMainConfigPath());
-    m_pConfig = std::make_unique<Hyprlang::CConfig>(configPaths.begin()->c_str(), Hyprlang::SConfigOptions{.throwAllErrors = true, .allowMissingConfig = true});
+    m_configPaths.emplace_back(getMainConfigPath());
+    m_pConfig = makeUnique<Hyprlang::CConfig>(m_configPaths.begin()->c_str(), Hyprlang::SConfigOptions{.throwAllErrors = true, .allowMissingConfig = true});

    m_pConfig->addConfigValue("general:border_size", Hyprlang::INT{1});
    m_pConfig->addConfigValue("general:no_border_on_floating", Hyprlang::INT{0});
@@ -413,6 +453,7 @@ CConfigManager::CConfigManager() {
    m_pConfig->addConfigValue("debug:log_damage", Hyprlang::INT{0});
    m_pConfig->addConfigValue("debug:overlay", Hyprlang::INT{0});
    m_pConfig->addConfigValue("debug:damage_blink", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("debug:pass", Hyprlang::INT{0});
    m_pConfig->addConfigValue("debug:disable_logs", Hyprlang::INT{1});
    m_pConfig->addConfigValue("debug:disable_time", Hyprlang::INT{1});
    m_pConfig->addConfigValue("debug:enable_stdout_logs", Hyprlang::INT{0});
@@ -426,6 +467,7 @@ CConfigManager::CConfigManager() {
    m_pConfig->addConfigValue("debug:colored_stdout_logs", Hyprlang::INT{1});

    m_pConfig->addConfigValue("decoration:rounding", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("decoration:rounding_power", {2.F});
    m_pConfig->addConfigValue("decoration:blur:enabled", Hyprlang::INT{1});
    m_pConfig->addConfigValue("decoration:blur:size", Hyprlang::INT{8});
    m_pConfig->addConfigValue("decoration:blur:passes", Hyprlang::INT{1});
@@ -476,7 +518,8 @@ CConfigManager::CConfigManager() {
    m_pConfig->addConfigValue("master:special_scale_factor", {1.f});
    m_pConfig->addConfigValue("master:mfact", {0.55f});
    m_pConfig->addConfigValue("master:new_status", {"slave"});
-    m_pConfig->addConfigValue("master:always_center_master", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("master:slave_count_for_center_master", Hyprlang::INT{2});
+    m_pConfig->addConfigValue("master:center_master_slaves_on_right", Hyprlang::INT{1});
    m_pConfig->addConfigValue("master:center_ignores_reserved", Hyprlang::INT{0});
    m_pConfig->addConfigValue("master:new_on_active", {"none"});
    m_pConfig->addConfigValue("master:new_on_top", Hyprlang::INT{0});
@@ -571,9 +614,9 @@ CConfigManager::CConfigManager() {
    m_pConfig->addConfigValue("xwayland:force_zero_scaling", Hyprlang::INT{0});

    m_pConfig->addConfigValue("opengl:nvidia_anti_flicker", Hyprlang::INT{1});
-    m_pConfig->addConfigValue("opengl:force_introspection", Hyprlang::INT{2});
+    m_pConfig->addConfigValue("opengl:force_introspection", Hyprlang::INT{1}); // TODO: remove this. I don't think it does us any good to disable intro.

-    m_pConfig->addConfigValue("cursor:no_hardware_cursors", Hyprlang::INT{2});
+    m_pConfig->addConfigValue("cursor:no_hardware_cursors", Hyprlang::INT{0});
    m_pConfig->addConfigValue("cursor:no_break_fs_vrr", Hyprlang::INT{0});
    m_pConfig->addConfigValue("cursor:min_refresh_rate", Hyprlang::INT{24});
    m_pConfig->addConfigValue("cursor:hotspot_padding", Hyprlang::INT{0});
@@ -588,7 +631,7 @@ CConfigManager::CConfigManager() {
    m_pConfig->addConfigValue("cursor:sync_gsettings_theme", Hyprlang::INT{1});
    m_pConfig->addConfigValue("cursor:hide_on_key_press", Hyprlang::INT{0});
    m_pConfig->addConfigValue("cursor:hide_on_touch", Hyprlang::INT{1});
-    m_pConfig->addConfigValue("cursor:use_cpu_buffer", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("cursor:use_cpu_buffer", Hyprlang::INT{2});
    m_pConfig->addConfigValue("cursor:warp_back_after_non_mouse_input", Hyprlang::INT{0});

    m_pConfig->addConfigValue("autogenerated", Hyprlang::INT{0});
@@ -612,8 +655,16 @@ CConfigManager::CConfigManager() {
    m_pConfig->addConfigValue("render:explicit_sync_kms", Hyprlang::INT{2});
    m_pConfig->addConfigValue("render:direct_scanout", Hyprlang::INT{0});
    m_pConfig->addConfigValue("render:expand_undersized_textures", Hyprlang::INT{1});
+    m_pConfig->addConfigValue("render:xp_mode", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("render:ctm_animation", Hyprlang::INT{2});
+    m_pConfig->addConfigValue("render:allow_early_buffer_release", Hyprlang::INT{1});

    m_pConfig->addConfigValue("ecosystem:no_update_news", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("ecosystem:no_donation_nag", Hyprlang::INT{0});
+
+    m_pConfig->addConfigValue("experimental:wide_color_gamut", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("experimental:hdr", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("experimental:xx_color_management_v4", Hyprlang::INT{0});

    // devices
    m_pConfig->addSpecialCategory("device", {"name"});
@@ -653,8 +704,10 @@ CConfigManager::CConfigManager() {
    m_pConfig->addSpecialConfigValue("device", "active_area_size", Hyprlang::VEC2{0, 0});     // only for tablets

    // keywords
-    m_pConfig->registerHandler(&::handleRawExec, "exec", {false});
+    m_pConfig->registerHandler(&::handleExec, "exec", {false});
+    m_pConfig->registerHandler(&::handleRawExec, "execr", {false});
    m_pConfig->registerHandler(&::handleExecOnce, "exec-once", {false});
+    m_pConfig->registerHandler(&::handleExecRawOnce, "execr-once", {false});
    m_pConfig->registerHandler(&::handleExecShutdown, "exec-shutdown", {false});
    m_pConfig->registerHandler(&::handleMonitor, "monitor", {false});
    m_pConfig->registerHandler(&::handleBind, "bind", {true});
@@ -676,18 +729,20 @@ CConfigManager::CConfigManager() {

    m_pConfig->commence();

-    setDefaultAnimationVars();
    resetHLConfig();

-    Debug::log(INFO,
-               "!!!!HEY YOU, YES YOU!!!!: further logs to stdout / logfile are disabled by default. BEFORE SENDING THIS LOG, ENABLE THEM. Use debug:disable_logs = false to do so: "
-               "https://wiki.hyprland.org/Configuring/Variables/#debug");
+    if (!g_pCompositor->m_bOnlyConfigVerification) {
+        Debug::log(
+            INFO,
+            "!!!!HEY YOU, YES YOU!!!!: further logs to stdout / logfile are disabled by default. BEFORE SENDING THIS LOG, ENABLE THEM. Use debug:disable_logs = false to do so: "
+            "https://wiki.hyprland.org/Configuring/Variables/#debug");
+    }

    Debug::disableLogs = reinterpret_cast<int64_t* const*>(m_pConfig->getConfigValuePtr("debug:disable_logs")->getDataStaticPtr());
    Debug::disableTime = reinterpret_cast<int64_t* const*>(m_pConfig->getConfigValuePtr("debug:disable_time")->getDataStaticPtr());

-    if (ERR.has_value())
-        g_pHyprError->queueCreate(ERR.value(), CHyprColor{1.0, 0.1, 0.1, 1.0});
+    if (g_pEventLoopManager && ERR.has_value())
+        g_pEventLoopManager->doLater([ERR] { g_pHyprError->queueCreate(ERR.value(), CHyprColor{1.0, 0.1, 0.1, 1.0}); });
 }

 std::optional<std::string> CConfigManager::generateConfig(std::string configPath) {
@@ -713,20 +768,24 @@ std::optional<std::string> CConfigManager::generateConfig(std::string configPath
 }

 std::string CConfigManager::getMainConfigPath() {
-    if (!g_pCompositor->explicitConfigPath.empty())
-        return g_pCompositor->explicitConfigPath;
+    static std::string CONFIG_PATH = [this]() -> std::string {
+        if (!g_pCompositor->explicitConfigPath.empty())
+            return g_pCompositor->explicitConfigPath;

-    if (const auto CFG_ENV = getenv("HYPRLAND_CONFIG"); CFG_ENV)
-        return CFG_ENV;
+        if (const auto CFG_ENV = getenv("HYPRLAND_CONFIG"); CFG_ENV)
+            return CFG_ENV;

-    const auto PATHS = Hyprutils::Path::findConfig(ISDEBUG ? "hyprlandd" : "hyprland");
-    if (PATHS.first.has_value()) {
-        return PATHS.first.value();
-    } else if (PATHS.second.has_value()) {
-        const auto CONFIGPATH = Hyprutils::Path::fullConfigPath(PATHS.second.value(), ISDEBUG ? "hyprlandd" : "hyprland");
-        return generateConfig(CONFIGPATH).value();
-    } else
-        throw std::runtime_error("Neither HOME nor XDG_CONFIG_HOME are set in the environment. Could not find config in XDG_CONFIG_DIRS or /etc/xdg.");
+        const auto PATHS = Hyprutils::Path::findConfig(ISDEBUG ? "hyprlandd" : "hyprland");
+        if (PATHS.first.has_value()) {
+            return PATHS.first.value();
+        } else if (PATHS.second.has_value()) {
+            const auto CONFIGPATH = Hyprutils::Path::fullConfigPath(PATHS.second.value(), ISDEBUG ? "hyprlandd" : "hyprland");
+            return generateConfig(CONFIGPATH).value();
+        } else
+            throw std::runtime_error("Neither HOME nor XDG_CONFIG_HOME are set in the environment. Could not find config in XDG_CONFIG_DIRS or /etc/xdg.");
+    }();
+
+    return CONFIG_PATH;
 }

 std::optional<std::string> CConfigManager::verifyConfigExists() {
@@ -742,7 +801,7 @@ std::string CConfigManager::getConfigString() {
    std::string configString;
    std::string currFileContent;

-    for (const auto& path : configPaths) {
+    for (const auto& path : m_configPaths) {
        std::ifstream configFile(path);
        configString += ("\n\nConfig File: " + path + ": ");
        if (!configFile.is_open()) {
@@ -765,78 +824,65 @@ void CConfigManager::reload() {
    EMIT_HOOK_EVENT("preConfigReload", nullptr);
    setDefaultAnimationVars();
    resetHLConfig();
-    configCurrentPath = getMainConfigPath();
-    const auto ERR    = m_pConfig->parse();
+    configCurrentPath                      = getMainConfigPath();
+    const auto ERR                         = m_pConfig->parse();
+    m_bLastConfigVerificationWasSuccessful = !ERR.error;
    postConfigReload(ERR);
 }

+std::string CConfigManager::verify() {
+    setDefaultAnimationVars();
+    resetHLConfig();
+    configCurrentPath                      = getMainConfigPath();
+    const auto ERR                         = m_pConfig->parse();
+    m_bLastConfigVerificationWasSuccessful = !ERR.error;
+    if (ERR.error)
+        return ERR.getError();
+    return "config ok";
+}
+
 void CConfigManager::setDefaultAnimationVars() {
-    if (isFirstLaunch) {
-        INITANIMCFG("global");
-        INITANIMCFG("windows");
-        INITANIMCFG("layers");
-        INITANIMCFG("fade");
-        INITANIMCFG("border");
-        INITANIMCFG("borderangle");
+    m_AnimationTree.createNode("__internal_fadeCTM");
+    m_AnimationTree.createNode("global");

-        // windows
-        INITANIMCFG("windowsIn");
-        INITANIMCFG("windowsOut");
-        INITANIMCFG("windowsMove");
+    // global
+    m_AnimationTree.createNode("windows", "global");
+    m_AnimationTree.createNode("layers", "global");
+    m_AnimationTree.createNode("fade", "global");
+    m_AnimationTree.createNode("border", "global");
+    m_AnimationTree.createNode("borderangle", "global");
+    m_AnimationTree.createNode("workspaces", "global");

-        // layers
-        INITANIMCFG("layersIn");
-        INITANIMCFG("layersOut");
+    // layer
+    m_AnimationTree.createNode("layersIn", "layers");
+    m_AnimationTree.createNode("layersOut", "layers");

-        // fade
-        INITANIMCFG("fadeIn");
-        INITANIMCFG("fadeOut");
-        INITANIMCFG("fadeSwitch");
-        INITANIMCFG("fadeShadow");
-        INITANIMCFG("fadeDim");
+    // windows
+    m_AnimationTree.createNode("windowsIn", "windows");
+    m_AnimationTree.createNode("windowsOut", "windows");
+    m_AnimationTree.createNode("windowsMove", "windows");

-        // border
+    // fade
+    m_AnimationTree.createNode("fadeIn", "fade");
+    m_AnimationTree.createNode("fadeOut", "fade");
+    m_AnimationTree.createNode("fadeSwitch", "fade");
+    m_AnimationTree.createNode("fadeShadow", "fade");
+    m_AnimationTree.createNode("fadeDim", "fade");
+    m_AnimationTree.createNode("fadeLayers", "fade");
+    m_AnimationTree.createNode("fadeLayersIn", "fadeLayers");
+    m_AnimationTree.createNode("fadeLayersOut", "fadeLayers");

-        // workspaces
-        INITANIMCFG("workspaces");
-        INITANIMCFG("workspacesIn");
-        INITANIMCFG("workspacesOut");
-        INITANIMCFG("specialWorkspace");
-        INITANIMCFG("specialWorkspaceIn");
-        INITANIMCFG("specialWorkspaceOut");
-    }
+    // workspaces
+    m_AnimationTree.createNode("workspacesIn", "workspaces");
+    m_AnimationTree.createNode("workspacesOut", "workspaces");
+    m_AnimationTree.createNode("specialWorkspace", "workspaces");
+    m_AnimationTree.createNode("specialWorkspaceIn", "specialWorkspace");
+    m_AnimationTree.createNode("specialWorkspaceOut", "specialWorkspace");

-    // init the values
-    animationConfig["global"] = {false, "default", "", 8.f, 1, &animationConfig["general"], nullptr};
-
-    CREATEANIMCFG("windows", "global");
-    CREATEANIMCFG("layers", "global");
-    CREATEANIMCFG("fade", "global");
-    CREATEANIMCFG("border", "global");
-    CREATEANIMCFG("borderangle", "global");
-    CREATEANIMCFG("workspaces", "global");
-
-    CREATEANIMCFG("layersIn", "layers");
-    CREATEANIMCFG("layersOut", "layers");
-
-    CREATEANIMCFG("windowsIn", "windows");
-    CREATEANIMCFG("windowsOut", "windows");
-    CREATEANIMCFG("windowsMove", "windows");
-
-    CREATEANIMCFG("fadeIn", "fade");
-    CREATEANIMCFG("fadeOut", "fade");
-    CREATEANIMCFG("fadeSwitch", "fade");
-    CREATEANIMCFG("fadeShadow", "fade");
-    CREATEANIMCFG("fadeDim", "fade");
-    CREATEANIMCFG("fadeLayers", "fade");
-    CREATEANIMCFG("fadeLayersIn", "fadeLayers");
-    CREATEANIMCFG("fadeLayersOut", "fadeLayers");
-
-    CREATEANIMCFG("workspacesIn", "workspaces");
-    CREATEANIMCFG("workspacesOut", "workspaces");
-    CREATEANIMCFG("specialWorkspace", "workspaces");
-    CREATEANIMCFG("specialWorkspaceIn", "specialWorkspace");
-    CREATEANIMCFG("specialWorkspaceOut", "specialWorkspace");
+    // init the root nodes
+    m_AnimationTree.setConfigForNode("global", 1, 8.f, "", "default");
+    m_AnimationTree.setConfigForNode("__internal_fadeCTM", 1, 5.f, "", "linear");
+    m_AnimationTree.setConfigForNode("borderangle", 0, 0.f, "", "default");
 }

 std::optional<std::string> CConfigManager::resetHLConfig() {
@@ -844,6 +890,8 @@ std::optional<std::string> CConfigManager::resetHLConfig() {
    m_vWindowRules.clear();
    g_pKeybindManager->clearKeybinds();
    g_pAnimationManager->removeAllBeziers();
+    g_pAnimationManager->addBezierWithName("linear", Vector2D(0.0, 0.0), Vector2D(1.0, 1.0));
+
    m_mAdditionalReservedAreas.clear();
    m_dBlurLSNamespaces.clear();
    m_vWorkspaceRules.clear();
@@ -854,20 +902,27 @@ std::optional<std::string> CConfigManager::resetHLConfig() {
    finalExecRequests.clear();

    // paths
-    configPaths.clear();
+    m_configPaths.clear();
    std::string mainConfigPath = getMainConfigPath();
    Debug::log(LOG, "Using config: {}", mainConfigPath);
-    configPaths.push_back(mainConfigPath);
+    m_configPaths.emplace_back(mainConfigPath);

    const auto RET = verifyConfigExists();

    return RET;
 }

+void CConfigManager::updateWatcher() {
+    static const auto PDISABLEAUTORELOAD = CConfigValue<Hyprlang::INT>("misc:disable_autoreload");
+    g_pConfigWatcher->setWatchList(*PDISABLEAUTORELOAD ? std::vector<std::string>{} : m_configPaths);
+}
+
 void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
    static const auto PENABLEEXPLICIT     = CConfigValue<Hyprlang::INT>("render:explicit_sync");
    static int        prevEnabledExplicit = *PENABLEEXPLICIT;

+    updateWatcher();
+
    for (auto const& w : g_pCompositor->m_vWindows) {
        w->uncacheWindowDecos();
    }
@@ -881,11 +936,12 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
        g_pInputManager->setPointerConfigs();
        g_pInputManager->setTouchDeviceConfigs();
        g_pInputManager->setTabletConfigs();
-    }

-    if (!isFirstLaunch)
        g_pHyprOpenGL->m_bReloadScreenShader = true;

+        g_pHyprOpenGL->ensureBackgroundTexturePresence();
+    }
+
    // parseError will be displayed next frame

    if (result.error)
@@ -897,7 +953,7 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
        g_pHyprError->queueCreate(result.getError(), CHyprColor(1.0, 50.0 / 255.0, 50.0 / 255.0, 1.0));
    else if (std::any_cast<Hyprlang::INT>(m_pConfig->getConfigValue("autogenerated")) == 1)
        g_pHyprError->queueCreate(
-            "Warning: You're using an autogenerated config! (config file: " + getMainConfigPath() +
+            "Warning: You're using an autogenerated config! Edit the config file to get rid of this message. (config file: " + getMainConfigPath() +
                " )\nSUPER+Q -> kitty (if it doesn't launch, make sure it's installed or choose a different terminal in the config)\nSUPER+M -> exit Hyprland",
            CHyprColor(1.0, 1.0, 70.0 / 255.0, 1.0));
    else if (*PENABLEEXPLICIT != prevEnabledExplicit)
@@ -917,26 +973,16 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
    }

 #ifndef NO_XWAYLAND
-    const auto PENABLEXWAYLAND = std::any_cast<Hyprlang::INT>(m_pConfig->getConfigValue("xwayland:enabled"));
+    const auto PENABLEXWAYLAND      = std::any_cast<Hyprlang::INT>(m_pConfig->getConfigValue("xwayland:enabled"));
+    g_pCompositor->m_bWantsXwayland = PENABLEXWAYLAND;
    // enable/disable xwayland usage
-    if (!isFirstLaunch) {
-        bool prevEnabledXwayland = g_pCompositor->m_bEnableXwayland;
-        if (PENABLEXWAYLAND != prevEnabledXwayland) {
-            g_pCompositor->m_bEnableXwayland = PENABLEXWAYLAND;
-            if (PENABLEXWAYLAND) {
-                Debug::log(LOG, "xwayland has been enabled");
-            } else {
-                Debug::log(LOG, "xwayland has been disabled, cleaning up...");
-                for (auto& w : g_pCompositor->m_vWindows) {
-                    if (w->m_pXDGSurface || !w->m_bIsX11)
-                        continue;
-                    g_pCompositor->closeWindow(w);
-                }
-            }
-            g_pXWayland = std::make_unique<CXWayland>(g_pCompositor->m_bEnableXwayland);
-        }
+    if (!isFirstLaunch &&
+        g_pXWayland /* XWayland has to be initialized by CCompositor::initManagers for this to make sense, and it doesn't have to be (e.g. very early plugin load) */) {
+        bool prevEnabledXwayland = g_pXWayland->enabled();
+        if (g_pCompositor->m_bWantsXwayland != prevEnabledXwayland)
+            g_pXWayland = makeUnique<CXWayland>(g_pCompositor->m_bWantsXwayland);
    } else
-        g_pCompositor->m_bEnableXwayland = PENABLEXWAYLAND;
+        g_pCompositor->m_bWantsXwayland = PENABLEXWAYLAND;
 #endif

    if (!isFirstLaunch && !g_pCompositor->m_bUnsafeState)
@@ -992,6 +1038,10 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
    // update plugins
    handlePluginLoads();

+    // update persistent workspaces
+    if (!isFirstLaunch)
+        ensurePersistentWorkspacesPresent();
+
    EMIT_HOOK_EVENT("configReloaded", nullptr);
    if (g_pEventManager)
        g_pEventManager->postEvent(SHyprIPCEvent{"configreloaded", ""});
@@ -999,17 +1049,14 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {

 void CConfigManager::init() {

+    g_pConfigWatcher->setOnChange([this](const CConfigWatcher::SConfigWatchEvent& e) {
+        Debug::log(LOG, "CConfigManager: file {} modified, reloading", e.file);
+        reload();
+    });
+
    const std::string CONFIGPATH = getMainConfigPath();
    reload();

-    struct stat fileStat;
-    int         err = stat(CONFIGPATH.c_str(), &fileStat);
-    if (err != 0) {
-        Debug::log(WARN, "Error at statting config, error {}", errno);
-    }
-
-    configModifyTimes[CONFIGPATH] = fileStat.st_mtime;
-
    isFirstLaunch = false;
 }

@@ -1050,37 +1097,6 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
    return RET.error ? RET.getError() : "";
 }

-void CConfigManager::tick() {
-    std::string CONFIGPATH = getMainConfigPath();
-    if (!std::filesystem::exists(CONFIGPATH)) {
-        Debug::log(ERR, "Config doesn't exist??");
-        return;
-    }
-
-    bool parse = false;
-
-    for (auto const& cf : configPaths) {
-        struct stat fileStat;
-        int         err = stat(cf.c_str(), &fileStat);
-        if (err != 0) {
-            Debug::log(WARN, "Error at ticking config at {}, error {}: {}", cf, err, strerror(err));
-            continue;
-        }
-
-        // check if we need to reload cfg
-        if (fileStat.st_mtime != configModifyTimes[cf] || m_bForceReload) {
-            parse                 = true;
-            configModifyTimes[cf] = fileStat.st_mtime;
-        }
-    }
-
-    if (parse) {
-        m_bForceReload = false;
-
-        reload();
-    }
-}
-
 Hyprlang::CConfigValue* CConfigManager::getConfigValueSafeDevice(const std::string& dev, const std::string& val, const std::string& fallback) {

    const auto VAL = m_pConfig->getSpecialConfigValuePtr("device", val.c_str(), dev.c_str());
@@ -1258,10 +1274,10 @@ std::vector<SP<CWindowRule>> CConfigManager::getMatchingRules(PHLWINDOW pWindow,
                if (rule->szValue.starts_with("tag:") && !tags.isTagged(rule->szValue.substr(4)))
                    continue;

-                if (rule->szValue.starts_with("title:") && !RE2::FullMatch(pWindow->m_szTitle, rule->szValue.substr(6)))
+                if (rule->szValue.starts_with("title:") && !rule->rV1Regex.passes(pWindow->m_szTitle))
                    continue;

-                if (!RE2::FullMatch(pWindow->m_szClass, rule->szValue))
+                if (!rule->rV1Regex.passes(pWindow->m_szClass))
                    continue;

            } catch (...) {
@@ -1351,16 +1367,16 @@ std::vector<SP<CWindowRule>> CConfigManager::getMatchingRules(PHLWINDOW pWindow,
                if (!rule->szTag.empty() && !tags.isTagged(rule->szTag))
                    continue;

-                if (!rule->szClass.empty() && !RE2::FullMatch(pWindow->m_szClass, rule->szClass))
+                if (!rule->szClass.empty() && !rule->rClass.passes(pWindow->m_szClass))
                    continue;

-                if (!rule->szTitle.empty() && !RE2::FullMatch(pWindow->m_szTitle, rule->szTitle))
+                if (!rule->szTitle.empty() && !rule->rTitle.passes(pWindow->m_szTitle))
                    continue;

-                if (!rule->szInitialTitle.empty() && !RE2::FullMatch(pWindow->m_szInitialTitle, rule->szInitialTitle))
+                if (!rule->szInitialTitle.empty() && !rule->rInitialTitle.passes(pWindow->m_szInitialTitle))
                    continue;

-                if (!rule->szInitialClass.empty() && !RE2::FullMatch(pWindow->m_szInitialClass, rule->szInitialClass))
+                if (!rule->szInitialClass.empty() && !rule->rInitialClass.passes(pWindow->m_szInitialClass))
                    continue;

            } catch (std::exception& e) {
@@ -1419,7 +1435,7 @@ std::vector<SP<CLayerRule>> CConfigManager::getMatchingRules(PHLLS pLS) {
        if (lr->targetNamespace.starts_with("address:0x")) {
            if (std::format("address:0x{:x}", (uintptr_t)pLS.get()) != lr->targetNamespace)
                continue;
-        } else if (!RE2::FullMatch(pLS->layerSurface->layerNamespace, lr->targetNamespace))
+        } else if (!lr->targetNamespaceRegex.passes(pLS->layerSurface->layerNamespace))
            continue;

        // hit
@@ -1449,7 +1465,7 @@ void CConfigManager::dispatchExecOnce() {
    isLaunchingExecOnce = true;

    for (auto const& c : firstExecRequests) {
-        handleRawExec("", c);
+        c.withRules ? handleExec("", c.exec) : handleRawExec("", c.exec);
    }

    firstExecRequests.clear(); // free some kb of memory :P
@@ -1483,22 +1499,6 @@ void CConfigManager::dispatchExecShutdown() {
    handleExecShutdown("", "hyprctl dispatch exit");
 }

-void CConfigManager::appendMonitorRule(const SMonitorRule& r) {
-    m_vMonitorRules.emplace_back(r);
-}
-
-bool CConfigManager::replaceMonitorRule(const SMonitorRule& newrule) {
-    // Looks for an existing monitor rule (compared by name).
-    // If the rule exists, it is replaced with the input rule.
-    for (auto& r : m_vMonitorRules) {
-        if (r.name == newrule.name) {
-            r = newrule;
-            return true;
-        }
-    }
-    return false;
-}
-
 void CConfigManager::performMonitorReload() {

    bool overAgain = false;
@@ -1509,7 +1509,7 @@ void CConfigManager::performMonitorReload() {

        auto rule = getMonitorRuleFor(m);

-        if (!g_pHyprRenderer->applyMonitorRule(m, &rule)) {
+        if (!m->applyMonitorRule(&rule)) {
            overAgain = true;
            break;
        }
@@ -1567,7 +1567,7 @@ void CConfigManager::ensureMonitorStatus() {
        auto rule = getMonitorRuleFor(rm);

        if (rule.disabled == rm->m_bEnabled)
-            g_pHyprRenderer->applyMonitorRule(rm, &rule);
+            rm->applyMonitorRule(&rule);
    }
 }

@@ -1650,8 +1650,8 @@ void CConfigManager::ensureVRR(PHLMONITOR pMonitor) {
    }
 }

-SAnimationPropertyConfig* CConfigManager::getAnimationPropertyConfig(const std::string& name) {
-    return &animationConfig[name];
+SP<SAnimationPropertyConfig> CConfigManager::getAnimationPropertyConfig(const std::string& name) {
+    return m_AnimationTree.getConfig(name);
 }

 void CConfigManager::addParseError(const std::string& err) {
@@ -1686,7 +1686,7 @@ void CConfigManager::addExecRule(const SExecRequestedRule& rule) {
 }

 void CConfigManager::handlePluginLoads() {
-    if (g_pPluginSystem == nullptr)
+    if (!g_pPluginSystem)
        return;

    bool pluginsChanged = false;
@@ -1705,8 +1705,7 @@ void CConfigManager::handlePluginLoads() {

    if (pluginsChanged) {
        g_pHyprError->destroy();
-        m_bForceReload = true;
-        tick();
+        reload();
    }
 }

@@ -1714,12 +1713,8 @@ ICustomConfigValueData::~ICustomConfigValueData() {
    ; // empty
 }

-std::unordered_map<std::string, SAnimationPropertyConfig> CConfigManager::getAnimationConfig() {
-    return animationConfig;
-}
-
-void onPluginLoadUnload(const std::string& name, bool load) {
-    //
+const std::unordered_map<std::string, SP<SAnimationPropertyConfig>>& CConfigManager::getAnimationConfig() {
+    return m_AnimationTree.getFullConfig();
 }

 void CConfigManager::addPluginConfigVar(HANDLE handle, const std::string& name, const Hyprlang::CConfigValue& value) {
@@ -1772,7 +1767,17 @@ std::string CConfigManager::getDefaultWorkspaceFor(const std::string& name) {

 std::optional<std::string> CConfigManager::handleRawExec(const std::string& command, const std::string& args) {
    if (isFirstLaunch) {
-        firstExecRequests.push_back(args);
+        firstExecRequests.push_back({args, false});
+        return {};
+    }
+
+    g_pKeybindManager->spawnRaw(args);
+    return {};
+}
+
+std::optional<std::string> CConfigManager::handleExec(const std::string& command, const std::string& args) {
+    if (isFirstLaunch) {
+        firstExecRequests.push_back({args, true});
        return {};
    }

@@ -1782,7 +1787,14 @@ std::optional<std::string> CConfigManager::handleRawExec(const std::string& comm

 std::optional<std::string> CConfigManager::handleExecOnce(const std::string& command, const std::string& args) {
    if (isFirstLaunch)
-        firstExecRequests.push_back(args);
+        firstExecRequests.push_back({args, true});
+
+    return {};
+}
+
+std::optional<std::string> CConfigManager::handleExecRawOnce(const std::string& command, const std::string& args) {
+    if (isFirstLaunch)
+        firstExecRequests.push_back({args, false});

    return {};
 }
@@ -2065,17 +2077,6 @@ std::optional<std::string> CConfigManager::handleBezier(const std::string& comma
    return {};
 }

-void CConfigManager::setAnimForChildren(SAnimationPropertyConfig* const ANIM) {
-    for (auto& [name, anim] : animationConfig) {
-        if (anim.pParentAnimation == ANIM && !anim.overridden) {
-            // if a child isnt overridden, set the values of the parent
-            anim.pValues = ANIM->pValues;
-
-            setAnimForChildren(&anim);
-        }
-    }
-};
-
 std::optional<std::string> CConfigManager::handleAnimation(const std::string& command, const std::string& args) {
    const auto ARGS = CVarList(args);

@@ -2084,14 +2085,9 @@ std::optional<std::string> CConfigManager::handleAnimation(const std::string& co
    // anim name
    const auto ANIMNAME = ARGS[0];

-    const auto PANIM = animationConfig.find(ANIMNAME);
-
-    if (PANIM == animationConfig.end())
+    if (!m_AnimationTree.nodeExists(ANIMNAME))
        return "no such animation";

-    PANIM->second.overridden = true;
-    PANIM->second.pValues    = &PANIM->second;
-
    // This helper casts strings like "1", "true", "off", "yes"... to int.
    int64_t enabledInt = configStringToInt(ARGS[1]).value_or(0) == 1;

@@ -2099,43 +2095,41 @@ std::optional<std::string> CConfigManager::handleAnimation(const std::string& co
    if (enabledInt != 0 && enabledInt != 1)
        return "invalid animation on/off state";

-    PANIM->second.internalEnabled = configStringToInt(ARGS[1]).value_or(0) == 1;
-
-    if (PANIM->second.internalEnabled) {
-        // speed
-        if (isNumber(ARGS[2], true)) {
-            PANIM->second.internalSpeed = std::stof(ARGS[2]);
-
-            if (PANIM->second.internalSpeed <= 0) {
-                PANIM->second.internalSpeed = 1.f;
-                return "invalid speed";
-            }
-        } else {
-            PANIM->second.internalSpeed = 10.f;
-            return "invalid speed";
-        }
-
-        // curve
-        PANIM->second.internalBezier = ARGS[3];
-
-        if (!g_pAnimationManager->bezierExists(ARGS[3])) {
-            PANIM->second.internalBezier = "default";
-            return "no such bezier";
-        }
-
-        // style
-        PANIM->second.internalStyle = ARGS[4];
-
-        if (ARGS[4] != "") {
-            auto ERR = g_pAnimationManager->styleValidInConfigVar(ANIMNAME, ARGS[4]);
-
-            if (ERR != "")
-                return ERR;
-        }
+    if (!enabledInt) {
+        m_AnimationTree.setConfigForNode(ANIMNAME, enabledInt, 1, "default");
+        return {};
    }

-    // now, check for children, recursively
-    setAnimForChildren(&PANIM->second);
+    float speed = -1;
+
+    // speed
+    if (isNumber(ARGS[2], true)) {
+        speed = std::stof(ARGS[2]);
+
+        if (speed <= 0) {
+            speed = 1.f;
+            return "invalid speed";
+        }
+    } else {
+        speed = 10.f;
+        return "invalid speed";
+    }
+
+    std::string bezierName = ARGS[3];
+    m_AnimationTree.setConfigForNode(ANIMNAME, enabledInt, speed, ARGS[3], ARGS[4]);
+
+    if (!g_pAnimationManager->bezierExists(bezierName)) {
+        const auto PANIMNODE      = m_AnimationTree.getConfig(ANIMNAME);
+        PANIMNODE->internalBezier = "default";
+        return "no such bezier";
+    }
+
+    if (ARGS[4] != "") {
+        auto ERR = g_pAnimationManager->styleValidInConfigVar(ANIMNAME, ARGS[4]);
+
+        if (ERR != "")
+            return ERR;
+    }

    return {};
 }
@@ -2301,6 +2295,8 @@ std::optional<std::string> CConfigManager::handleWindowRule(const std::string& c
        return "Invalid rule: " + RULE;
    }

+    newRule->rV1Regex = {VALUE.starts_with("title:") ? VALUE.substr(6) : VALUE};
+
    if (RULE.starts_with("size") || RULE.starts_with("maxsize") || RULE.starts_with("minsize"))
        m_vWindowRules.insert(m_vWindowRules.begin(), newRule);
    else
@@ -2329,6 +2325,8 @@ std::optional<std::string> CConfigManager::handleLayerRule(const std::string& co
        return "Invalid rule found: " + RULE;
    }

+    rule->targetNamespaceRegex = {VALUE};
+
    m_vLayerRules.emplace_back(rule);

    for (auto const& m : g_pCompositor->m_vMonitors)
@@ -2427,17 +2425,25 @@ std::optional<std::string> CConfigManager::handleWindowRuleV2(const std::string&
    if (TAGPOS != std::string::npos)
        rule->szTag = extract(TAGPOS + 4);

-    if (CLASSPOS != std::string::npos)
+    if (CLASSPOS != std::string::npos) {
        rule->szClass = extract(CLASSPOS + 6);
+        rule->rClass  = {rule->szClass};
+    }

-    if (TITLEPOS != std::string::npos)
+    if (TITLEPOS != std::string::npos) {
        rule->szTitle = extract(TITLEPOS + 6);
+        rule->rTitle  = {rule->szTitle};
+    }

-    if (INITIALCLASSPOS != std::string::npos)
+    if (INITIALCLASSPOS != std::string::npos) {
        rule->szInitialClass = extract(INITIALCLASSPOS + 13);
+        rule->rInitialClass  = {rule->szInitialClass};
+    }

-    if (INITIALTITLEPOS != std::string::npos)
+    if (INITIALTITLEPOS != std::string::npos) {
        rule->szInitialTitle = extract(INITIALTITLEPOS + 13);
+        rule->rInitialTitle  = {rule->szInitialTitle};
+    }

    if (X11POS != std::string::npos)
        rule->bX11 = extract(X11POS + 9) == "1" ? 1 : 0;
@@ -2688,8 +2694,14 @@ std::optional<std::string> CConfigManager::handleSource(const std::string& comma
        Debug::log(ERR, "source= path garbage");
        return "source= path " + rawpath + " bogus!";
    }
-    std::unique_ptr<glob_t, void (*)(glob_t*)> glob_buf{new glob_t, [](glob_t* g) { globfree(g); }};
-    memset(glob_buf.get(), 0, sizeof(glob_t));
+
+    std::unique_ptr<glob_t, void (*)(glob_t*)> glob_buf{static_cast<glob_t*>(calloc(1, sizeof(glob_t))), // allocate and zero-initialize
+                                                        [](glob_t* g) {
+                                                            if (g) {
+                                                                globfree(g); // free internal resources allocated by glob()
+                                                                free(g);     // free the memory for the glob_t structure
+                                                            }
+                                                        }};

    if (auto r = glob(absolutePath(rawpath, configCurrentPath).c_str(), GLOB_TILDE, nullptr, glob_buf.get()); r != 0) {
        std::string err = std::format("source= globbing error: {}", r == GLOB_NOMATCH ? "found no match" : GLOB_ABORTED ? "read error" : "out of memory");
@@ -2711,16 +2723,8 @@ std::optional<std::string> CConfigManager::handleSource(const std::string& comma
            Debug::log(ERR, "source= file doesn't exist: {}", value);
            return "source= file " + value + " doesn't exist!";
        }
-        configPaths.push_back(value);
+        m_configPaths.emplace_back(value);

-        struct stat fileStat;
-        int         err = stat(value.c_str(), &fileStat);
-        if (err != 0) {
-            Debug::log(WARN, "Error at ticking config at {}, error {}: {}", value, err, strerror(err));
-            return {};
-        }
-
-        configModifyTimes[value]     = fileStat.st_mtime;
        auto configCurrentPathBackup = configCurrentPath;
        configCurrentPath            = value;

@@ -2782,7 +2786,7 @@ bool CConfigManager::shouldUseSoftwareCursors() {
    switch (*PNOHW) {
        case 0: return false;
        case 1: return true;
-        default: return g_pHyprRenderer->isNvidia();
+        default: break;
    }

    return true;
@@ -2840,3 +2844,7 @@ std::string SConfigOptionDescription::jsonify() const {

    return json;
 }
+
+void CConfigManager::ensurePersistentWorkspacesPresent() {
+    g_pCompositor->ensurePersistentWorkspacesPresent(m_vWorkspaceRules);
+}
--- a/src/config/ConfigManager.hpp
+++ b/src/config/ConfigManager.hpp
@@ -1,31 +1,30 @@
 #pragma once

+#include <hyprutils/animation/AnimationConfig.hpp>
 #define CONFIG_MANAGER_H

 #include <map>
-#include "../debug/Log.hpp"
 #include <unordered_map>
 #include "../defines.hpp"
 #include <variant>
 #include <vector>
-#include <algorithm>
 #include <optional>
 #include <functional>
 #include <xf86drmMode.h>
-#include "../helpers/WLClasses.hpp"
 #include "../helpers/Monitor.hpp"
-#include "../helpers/varlist/VarList.hpp"
 #include "../desktop/Window.hpp"
-#include "../desktop/LayerSurface.hpp"
+#include "../desktop/LayerRule.hpp"

-#include "defaultConfig.hpp"
 #include "ConfigDataValues.hpp"
+#include "../SharedDefs.hpp"
+#include "../helpers/Color.hpp"
+#include "../desktop/DesktopTypes.hpp"
+#include "../helpers/memory/Memory.hpp"
+#include "../desktop/WindowRule.hpp"
+#include "../managers/XWaylandManager.hpp"

 #include <hyprlang.hpp>

-#define INITANIMCFG(name)           animationConfig[name] = {}
-#define CREATEANIMCFG(name, parent) animationConfig[name] = {false, "", "", 0.f, -1, &animationConfig["global"], &animationConfig[parent]}
-
 #define HANDLE void*

 struct SWorkspaceRule {
@@ -54,18 +53,6 @@ struct SMonitorAdditionalReservedArea {
    int right  = 0;
 };

-struct SAnimationPropertyConfig {
-    bool                      overridden = true;
-
-    std::string               internalBezier  = "";
-    std::string               internalStyle   = "";
-    float                     internalSpeed   = 0.f;
-    int                       internalEnabled = -1;
-
-    SAnimationPropertyConfig* pValues          = nullptr;
-    SAnimationPropertyConfig* pParentAnimation = nullptr;
-};
-
 struct SPluginKeyword {
    HANDLE                       handle = nullptr;
    std::string                  name   = "";
@@ -146,12 +133,18 @@ struct SConfigOptionDescription {
    std::variant<SBoolData, SRangeData, SFloatData, SStringData, SColorData, SChoiceData, SGradientData, SVectorData> data;
 };

+struct SFirstExecRequest {
+    std::string exec      = "";
+    bool        withRules = false;
+};
+
 class CConfigManager {
  public:
    CConfigManager();

-    void                                                            tick();
    void                                                            init();
+    void                                                            reload();
+    std::string                                                     verify();

    int                                                             getDeviceInt(const std::string&, const std::string&, const std::string& fallback = "");
    float                                                           getDeviceFloat(const std::string&, const std::string&, const std::string& fallback = "");
@@ -163,8 +156,7 @@ class CConfigManager {

    void* const*                                                    getConfigValuePtr(const std::string&);
    Hyprlang::CConfigValue*                                         getHyprlangConfigValuePtr(const std::string& name, const std::string& specialCat = "");
-    void                                                            onPluginLoadUnload(const std::string& name, bool load);
-    static std::string                                              getMainConfigPath();
+    std::string                                                     getMainConfigPath();
    std::string                                                     getConfigString();

    SMonitorRule                                                    getMonitorRuleFor(const PHLMONITOR);
@@ -177,43 +169,45 @@ class CConfigManager {

    std::vector<SP<CWindowRule>>                                    getMatchingRules(PHLWINDOW, bool dynamic = true, bool shadowExec = false);
    std::vector<SP<CLayerRule>>                                     getMatchingRules(PHLLS);
+    void                                                            ensurePersistentWorkspacesPresent();

    const std::vector<SConfigOptionDescription>&                    getAllDescriptions();

    std::unordered_map<std::string, SMonitorAdditionalReservedArea> m_mAdditionalReservedAreas;

-    std::unordered_map<std::string, SAnimationPropertyConfig>       getAnimationConfig();
+    const std::unordered_map<std::string, SP<Hyprutils::Animation::SAnimationPropertyConfig>>& getAnimationConfig();

-    void                                                            addPluginConfigVar(HANDLE handle, const std::string& name, const Hyprlang::CConfigValue& value);
+    void addPluginConfigVar(HANDLE handle, const std::string& name, const Hyprlang::CConfigValue& value);
    void addPluginKeyword(HANDLE handle, const std::string& name, Hyprlang::PCONFIGHANDLERFUNC fun, Hyprlang::SHandlerOptions opts = {});
    void removePluginConfig(HANDLE handle);

    // no-op when done.
-    void                      dispatchExecOnce();
-    void                      dispatchExecShutdown();
+    void                                               dispatchExecOnce();
+    void                                               dispatchExecShutdown();

-    void                      performMonitorReload();
-    void                      appendMonitorRule(const SMonitorRule&);
-    bool                      replaceMonitorRule(const SMonitorRule&);
-    void                      ensureMonitorStatus();
-    void                      ensureVRR(PHLMONITOR pMonitor = nullptr);
+    void                                               performMonitorReload();
+    void                                               ensureMonitorStatus();
+    void                                               ensureVRR(PHLMONITOR pMonitor = nullptr);

-    bool                      shouldUseSoftwareCursors();
+    bool                                               shouldUseSoftwareCursors();
+    void                                               updateWatcher();

-    std::string               parseKeyword(const std::string&, const std::string&);
+    std::string                                        parseKeyword(const std::string&, const std::string&);

-    void                      addParseError(const std::string&);
+    void                                               addParseError(const std::string&);

-    SAnimationPropertyConfig* getAnimationPropertyConfig(const std::string&);
+    SP<Hyprutils::Animation::SAnimationPropertyConfig> getAnimationPropertyConfig(const std::string&);

-    void                      addExecRule(const SExecRequestedRule&);
+    void                                               addExecRule(const SExecRequestedRule&);

-    void                      handlePluginLoads();
-    std::string               getErrors();
+    void                                               handlePluginLoads();
+    std::string                                        getErrors();

    // keywords
    std::optional<std::string>                                                                     handleRawExec(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleExec(const std::string&, const std::string&);
    std::optional<std::string>                                                                     handleExecOnce(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleExecRawOnce(const std::string&, const std::string&);
    std::optional<std::string>                                                                     handleExecShutdown(const std::string&, const std::string&);
    std::optional<std::string>                                                                     handleMonitor(const std::string&, const std::string&);
    std::optional<std::string>                                                                     handleBind(const std::string&, const std::string&);
@@ -262,56 +256,55 @@ class CConfigManager {
    };

    std::unordered_map<std::string, std::function<CWindowOverridableVar<float>*(PHLWINDOW)>> mfWindowProperties = {
+        {"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; }}};

-    bool m_bWantsMonitorReload = false;
-    bool m_bForceReload        = false;
-    bool m_bNoMonitorReload    = false;
-    bool isLaunchingExecOnce   = false; // For exec-once to skip initial ws tracking
+    bool m_bWantsMonitorReload                  = false;
+    bool m_bNoMonitorReload                     = false;
+    bool isLaunchingExecOnce                    = false; // For exec-once to skip initial ws tracking
+    bool m_bLastConfigVerificationWasSuccessful = true;

  private:
-    std::unique_ptr<Hyprlang::CConfig>                        m_pConfig;
+    UP<Hyprlang::CConfig>                            m_pConfig;

-    std::vector<std::string>                                  configPaths;       // stores all the config paths
-    std::unordered_map<std::string, time_t>                   configModifyTimes; // stores modify times
+    std::vector<std::string>                         m_configPaths;

-    std::unordered_map<std::string, SAnimationPropertyConfig> animationConfig; // stores all the animations with their set values
+    Hyprutils::Animation::CAnimationConfigTree       m_AnimationTree;

-    std::string                                               m_szCurrentSubmap = ""; // For storing the current keybind submap
+    std::string                                      m_szCurrentSubmap = ""; // For storing the current keybind submap

-    std::vector<SExecRequestedRule>                           execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
+    std::vector<SExecRequestedRule>                  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_vDeclaredPlugins;
+    std::vector<SPluginKeyword>                      pluginKeywords;
+    std::vector<SPluginVariable>                     pluginVariables;

-    bool                                                      isFirstLaunch = true; // For exec-once
+    bool                                             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_vMonitorRules;
+    std::vector<SWorkspaceRule>                      m_vWorkspaceRules;
+    std::vector<SP<CWindowRule>>                     m_vWindowRules;
+    std::vector<SP<CLayerRule>>                      m_vLayerRules;
+    std::vector<std::string>                         m_dBlurLSNamespaces;

-    bool                                                      firstExecDispatched     = false;
-    bool                                                      m_bManualCrashInitiated = false;
-    std::vector<std::string>                                  firstExecRequests;
-    std::vector<std::string>                                  finalExecRequests;
+    bool                                             firstExecDispatched     = false;
+    bool                                             m_bManualCrashInitiated = false;

-    std::vector<std::pair<std::string, std::string>>          m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
-    std::string                                               m_szConfigErrors = "";
+    std::vector<SFirstExecRequest>                   firstExecRequests; // bool is for if with rules
+    std::vector<std::string>                         finalExecRequests;
+
+    std::vector<std::pair<std::string, std::string>> m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
+    std::string                                      m_szConfigErrors = "";

    // internal methods
-    void                              setAnimForChildren(SAnimationPropertyConfig* const);
-    void                              updateBlurredLS(const std::string&, const bool);
-    void                              setDefaultAnimationVars();
-    std::optional<std::string>        resetHLConfig();
-    static std::optional<std::string> generateConfig(std::string configPath);
-    static std::optional<std::string> verifyConfigExists();
-    void                              postConfigReload(const Hyprlang::CParseResult& result);
-    void                              reload();
-    SWorkspaceRule                    mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&);
+    void                       updateBlurredLS(const std::string&, const bool);
+    void                       setDefaultAnimationVars();
+    std::optional<std::string> resetHLConfig();
+    std::optional<std::string> generateConfig(std::string configPath);
+    std::optional<std::string> verifyConfigExists();
+    void                       postConfigReload(const Hyprlang::CParseResult& result);
+    SWorkspaceRule             mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&);
 };

-inline std::unique_ptr<CConfigManager> g_pConfigManager;
+inline UP<CConfigManager> g_pConfigManager;
--- a/src/config/ConfigValue.hpp
+++ b/src/config/ConfigValue.hpp
@@ -3,7 +3,6 @@
 #include <string>
 #include <typeindex>
 #include <hyprlang.hpp>
-#include "../debug/Log.hpp"
 #include "../macros.hpp"
 #include "ConfigManager.hpp"

@@ -71,4 +70,4 @@ template <>
 inline Hyprlang::CUSTOMTYPE CConfigValue<Hyprlang::CUSTOMTYPE>::operator*() const {
    RASSERT(false, "Impossible to implement operator* of CConfigValue<Hyprlang::CUSTOMTYPE>, use ptr()");
    return *ptr();
-}
+}
--- a/src/config/ConfigWatcher.cpp
+++ b/src/config/ConfigWatcher.cpp
@@ -0,0 +1,84 @@
+#include "ConfigWatcher.hpp"
+#include <sys/inotify.h>
+#include "../debug/Log.hpp"
+#include <ranges>
+#include <fcntl.h>
+#include <unistd.h>
+#include <filesystem>
+
+CConfigWatcher::CConfigWatcher() : m_inotifyFd(inotify_init()) {
+    if (m_inotifyFd < 0) {
+        Debug::log(ERR, "CConfigWatcher couldn't open an inotify node. Config will not be automatically reloaded");
+        return;
+    }
+
+    const int FLAGS = fcntl(m_inotifyFd, F_GETFL, 0);
+    if (fcntl(m_inotifyFd, F_SETFL, FLAGS | O_NONBLOCK) < 0) {
+        Debug::log(ERR, "CConfigWatcher couldn't non-block inotify node. Config will not be automatically reloaded");
+        close(m_inotifyFd);
+        m_inotifyFd = -1;
+        return;
+    }
+}
+
+CConfigWatcher::~CConfigWatcher() {
+    if (m_inotifyFd >= 0)
+        close(m_inotifyFd);
+}
+
+int CConfigWatcher::getInotifyFD() {
+    return m_inotifyFd;
+}
+
+void CConfigWatcher::setWatchList(const std::vector<std::string>& paths) {
+
+    // we clear all watches first, because whichever fired is now invalid
+    // or that is at least what it seems to be.
+    // since we don't know which fired,
+    // plus it doesn't matter that much, these ops are done rarely and fast anyways.
+
+    // cleanup old paths
+    for (auto& watch : m_watches) {
+        inotify_rm_watch(m_inotifyFd, watch.wd);
+    }
+
+    m_watches.clear();
+
+    // add new paths
+    for (const auto& path : paths) {
+        m_watches.emplace_back(SInotifyWatch{
+            .wd   = inotify_add_watch(m_inotifyFd, path.c_str(), IN_MODIFY | IN_DONT_FOLLOW),
+            .file = path,
+        });
+
+        std::error_code ec, ec2;
+        const auto      CANONICAL  = std::filesystem::canonical(path, ec);
+        const auto      IS_SYMLINK = std::filesystem::is_symlink(path, ec2);
+        if (!ec && !ec2 && IS_SYMLINK) {
+            m_watches.emplace_back(SInotifyWatch{
+                .wd   = inotify_add_watch(m_inotifyFd, CANONICAL.c_str(), IN_MODIFY),
+                .file = path,
+            });
+        }
+    }
+}
+
+void CConfigWatcher::setOnChange(const std::function<void(const SConfigWatchEvent&)>& fn) {
+    m_watchCallback = fn;
+}
+
+void CConfigWatcher::onInotifyEvent() {
+    inotify_event ev;
+    while (read(m_inotifyFd, &ev, sizeof(ev)) > 0) {
+        const auto WD = std::ranges::find_if(m_watches.begin(), m_watches.end(), [wd = ev.wd](const auto& e) { return e.wd == wd; });
+
+        if (WD == m_watches.end()) {
+            Debug::log(ERR, "CConfigWatcher: got an event for wd {} which we don't have?!", ev.wd);
+            return;
+        }
+
+        m_watchCallback(SConfigWatchEvent{
+            .file = WD->file,
+        });
+    }
+}
--- a/src/config/ConfigWatcher.hpp
+++ b/src/config/ConfigWatcher.hpp
@@ -0,0 +1,32 @@
+#pragma once
+#include "../helpers/memory/Memory.hpp"
+#include <vector>
+#include <string>
+#include <functional>
+
+class CConfigWatcher {
+  public:
+    CConfigWatcher();
+    ~CConfigWatcher();
+
+    struct SConfigWatchEvent {
+        std::string file;
+    };
+
+    int  getInotifyFD();
+    void setWatchList(const std::vector<std::string>& paths);
+    void setOnChange(const std::function<void(const SConfigWatchEvent&)>& fn);
+    void onInotifyEvent();
+
+  private:
+    struct SInotifyWatch {
+        int         wd = -1;
+        std::string file;
+    };
+
+    std::function<void(const SConfigWatchEvent&)> m_watchCallback;
+    std::vector<SInotifyWatch>                    m_watches;
+    int                                           m_inotifyFd = -1;
+};
+
+inline UP<CConfigWatcher> g_pConfigWatcher = makeUnique<CConfigWatcher>();
--- a/src/config/defaultConfig.hpp
+++ b/src/config/defaultConfig.hpp
@@ -94,6 +94,7 @@ general {
 # https://wiki.hyprland.org/Configuring/Variables/#decoration
 decoration {
    rounding = 10
+    rounding_power = 2

    # Change transparency of focused and unfocused windows
    active_opacity = 1.0
--- a/src/debug/CrashReporter.cpp
+++ b/src/debug/CrashReporter.cpp
@@ -6,6 +6,7 @@
 #include <cerrno>
 #include <sys/stat.h>
 #include <filesystem>
+#include "../helpers/MiscFunctions.hpp"

 #include "../plugins/PluginSystem.hpp"
 #include "../signal-safe.hpp"
@@ -111,7 +112,7 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 #ifdef LEGACY_RENDERER
    finalCrashReport += "legacyrenderer\n";
 #endif
-#ifndef ISDEBUG
+#if ISDEBUG
    finalCrashReport += "debug\n";
 #endif
 #ifdef NO_XWAYLAND
@@ -161,7 +162,7 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 #if defined(__DragonFly__) || defined(__FreeBSD__)
    finalCrashReport.writeCmdOutput("pciconf -lv | grep -F -A4 vga");
 #else
-    finalCrashReport.writeCmdOutput("lspci -vnn | grep VGA");
+    finalCrashReport.writeCmdOutput("lspci -vnn | grep -E '(VGA|Display|3D)'");
 #endif

    finalCrashReport += "\n\nos-release:\n";
--- a/src/debug/HyprCtl.cpp
+++ b/src/debug/HyprCtl.cpp
@@ -39,8 +39,18 @@ using namespace Hyprutils::String;
 #include "debug/RollingLogFollow.hpp"
 #include "config/ConfigManager.hpp"
 #include "helpers/MiscFunctions.hpp"
+#include "../desktop/LayerSurface.hpp"
 #include "../version.h"

+#include "../Compositor.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/XWaylandManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../plugins/PluginSystem.hpp"
+#include "../managers/AnimationManager.hpp"
+#include "../debug/HyprNotificationOverlay.hpp"
+#include "../render/Renderer.hpp"
+
 static void trimTrailingComma(std::string& str) {
    if (!str.empty() && str.back() == ',')
        str.pop_back();
@@ -142,7 +152,7 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
    return result;
 }

-std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
    CVarList vars(request, 0, ' ');
    auto     allMonitors = false;

@@ -248,8 +258,8 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
    "focusHistoryID": {},
    "inhibitingIdle": {}
 }},)#",
-            (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,
+            (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"),
@@ -261,15 +271,16 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
            "{}\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.lock().get(), getFocusHistoryID(w), (int)g_pInputManager->isWindowInhibiting(w, false));
+            (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.lock().get(), getFocusHistoryID(w),
+            (int)g_pInputManager->isWindowInhibiting(w, false));
    }
 }

-std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";
    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
        result += "[";
@@ -368,7 +379,8 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
        return result;
    }
 }
-std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::string request) {
+
+static std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::string request) {
    if (!g_pCompositor->m_pLastMonitor)
        return "unsafe state";

@@ -381,7 +393,7 @@ std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::string requ
    return CHyprCtl::getWorkspaceData(w, format);
 }

-std::string workspacesRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string workspacesRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";

    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -402,7 +414,7 @@ std::string workspacesRequest(eHyprCtlOutputFormat format, std::string request)
    return result;
 }

-std::string workspaceRulesRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string workspaceRulesRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";
    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
        result += "[";
@@ -422,7 +434,7 @@ std::string workspaceRulesRequest(eHyprCtlOutputFormat format, std::string reque
    return result;
 }

-std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string request) {
    const auto PWINDOW = g_pCompositor->m_pLastWindow.lock();

    if (!validMapped(PWINDOW))
@@ -436,7 +448,7 @@ std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string request
    return result;
 }

-std::string layersRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string layersRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";

    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -510,7 +522,7 @@ std::string layersRequest(eHyprCtlOutputFormat format, std::string request) {
    return result;
 }

-std::string layoutsRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string layoutsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";
    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
        result += "[";
@@ -532,7 +544,7 @@ std::string layoutsRequest(eHyprCtlOutputFormat format, std::string request) {
    return result;
 }

-std::string configErrorsRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string configErrorsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result     = "";
    std::string currErrors = g_pConfigManager->getErrors();
    CVarList    errLines(currErrors, 0, '\n');
@@ -555,7 +567,7 @@ std::string configErrorsRequest(eHyprCtlOutputFormat format, std::string request
    return result;
 }

-std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";

    auto        getModState = [](SP<IKeyboard> keyboard, const char* xkbModName) -> bool {
@@ -725,14 +737,14 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
    return result;
 }

-std::string animationsRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string animationsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string ret = "";
    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
        ret += "animations:\n";

        for (auto const& ac : g_pConfigManager->getAnimationConfig()) {
-            ret += std::format("\n\tname: {}\n\t\toverriden: {}\n\t\tbezier: {}\n\t\tenabled: {}\n\t\tspeed: {:.2f}\n\t\tstyle: {}\n", ac.first, (int)ac.second.overridden,
-                               ac.second.internalBezier, ac.second.internalEnabled, ac.second.internalSpeed, ac.second.internalStyle);
+            ret += std::format("\n\tname: {}\n\t\toverriden: {}\n\t\tbezier: {}\n\t\tenabled: {}\n\t\tspeed: {:.2f}\n\t\tstyle: {}\n", ac.first, (int)ac.second->overridden,
+                               ac.second->internalBezier, ac.second->internalEnabled, ac.second->internalSpeed, ac.second->internalStyle);
        }

        ret += "beziers:\n";
@@ -754,8 +766,8 @@ std::string animationsRequest(eHyprCtlOutputFormat format, std::string request)
    "speed": {:.2f},
    "style": "{}"
 }},)#",
-                               ac.first, ac.second.overridden ? "true" : "false", escapeJSONStrings(ac.second.internalBezier), ac.second.internalEnabled ? "true" : "false",
-                               ac.second.internalSpeed, escapeJSONStrings(ac.second.internalStyle));
+                               ac.first, ac.second->overridden ? "true" : "false", escapeJSONStrings(ac.second->internalBezier), ac.second->internalEnabled ? "true" : "false",
+                               ac.second->internalSpeed, escapeJSONStrings(ac.second->internalStyle));
        }

        ret[ret.length() - 1] = ']';
@@ -778,7 +790,7 @@ std::string animationsRequest(eHyprCtlOutputFormat format, std::string request)
    return ret;
 }

-std::string rollinglogRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string rollinglogRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";

    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -792,7 +804,7 @@ std::string rollinglogRequest(eHyprCtlOutputFormat format, std::string request)
    return result;
 }

-std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string ret       = "";
    const auto  SHORTCUTS = PROTO::globalShortcuts->getAllShortcuts();
    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
@@ -815,7 +827,7 @@ std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::string requ
    return ret;
 }

-std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
+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) {
@@ -883,14 +895,14 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
                                         HYPRLAND_VERSION, GIT_BRANCH, GIT_COMMIT_HASH, GIT_DIRTY, commitMsg, GIT_COMMIT_DATE, GIT_TAG, GIT_COMMITS, AQUAMARINE_VERSION,
                                         HYPRLANG_VERSION, HYPRUTILS_VERSION, HYPRCURSOR_VERSION, HYPRGRAPHICS_VERSION);

-#if (!defined(LEGACY_RENDERER) && !defined(ISDEBUG) && !defined(NO_XWAYLAND))
+#if (!defined(LEGACY_RENDERER) && !ISDEBUG && !defined(NO_XWAYLAND))
        result += "no flags were set\n";
 #else
        result += "flags set:\n";
 #ifdef LEGACY_RENDERER
        result += "legacyrenderer\n";
 #endif
-#ifdef ISDEBUG
+#if ISDEBUG
        result += "debug\n";
 #endif
 #ifdef NO_XWAYLAND
@@ -921,7 +933,7 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
 #ifdef LEGACY_RENDERER
        result += "\"legacyrenderer\",";
 #endif
-#ifdef ISDEBUG
+#if ISDEBUG
        result += "\"debug\",";
 #endif
 #ifdef NO_XWAYLAND
@@ -976,7 +988,7 @@ std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request)
        }
    } catch (...) { GPUINFO = "error"; }
 #else
-    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
+    const std::string GPUINFO = execAndGet("lspci -vnn | grep -E '(VGA|Display|3D)'");
 #endif
    result += "GPU information: \n" + GPUINFO;
    if (GPUINFO.contains("NVIDIA") && std::filesystem::exists("/proc/driver/nvidia/version")) {
@@ -1018,7 +1030,7 @@ std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request)
    return result;
 }

-std::string dispatchRequest(eHyprCtlOutputFormat format, std::string in) {
+static std::string dispatchRequest(eHyprCtlOutputFormat format, std::string in) {
    // get rid of the dispatch keyword
    in = in.substr(in.find_first_of(' ') + 1);

@@ -1039,7 +1051,7 @@ std::string dispatchRequest(eHyprCtlOutputFormat format, std::string in) {
    return res.success ? "ok" : res.error;
 }

-std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
+static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
    // Find the first space to strip the keyword keyword
    auto const firstSpacePos = in.find_first_of(' ');
    if (firstSpacePos == std::string::npos) // Handle the case where there's no space found (invalid input)
@@ -1088,6 +1100,9 @@ std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
        }
    }

+    if (COMMAND.contains("misc:disable_autoreload"))
+        g_pConfigManager->updateWatcher();
+
    // 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")) {
@@ -1105,32 +1120,29 @@ std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
    return retval;
 }

-std::string reloadRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string reloadRequest(eHyprCtlOutputFormat format, std::string request) {

    const auto REQMODE = request.substr(request.find_last_of(' ') + 1);

-    g_pConfigManager->m_bForceReload = true;
-
-    if (REQMODE == "config-only") {
+    if (REQMODE == "config-only")
        g_pConfigManager->m_bNoMonitorReload = true;
-    }

-    g_pConfigManager->tick();
+    g_pConfigManager->reload();

    return "ok";
 }

-std::string killRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string killRequest(eHyprCtlOutputFormat format, std::string request) {
    g_pInputManager->setClickMode(CLICKMODE_KILL);

    return "ok";
 }

-std::string splashRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string splashRequest(eHyprCtlOutputFormat format, std::string request) {
    return g_pCompositor->m_szCurrentSplash;
 }

-std::string cursorPosRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string cursorPosRequest(eHyprCtlOutputFormat format, std::string request) {
    const auto CURSORPOS = g_pInputManager->getMouseCoordsInternal().floor();

    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
@@ -1148,41 +1160,33 @@ std::string cursorPosRequest(eHyprCtlOutputFormat format, std::string request) {
    return "error";
 }

-std::string dispatchBatch(eHyprCtlOutputFormat format, std::string request) {
-    // split by ;
-
-    request             = request.substr(9);
-    std::string curitem = "";
-    std::string reply   = "";
-
-    auto        nextItem = [&]() {
-        auto idx = request.find_first_of(';');
-
-        if (idx != std::string::npos) {
-            curitem = request.substr(0, idx);
-            request = request.substr(idx + 1);
-        } else {
-            curitem = request;
-            request = "";
-        }
-
-        curitem = trim(curitem);
-    };
-
-    nextItem();
+static std::string dispatchBatch(eHyprCtlOutputFormat format, std::string request) {
+    // split by ; ignores ; inside [] and adds ; on last command

+    request                     = request.substr(9);
+    std::string       reply     = "";
    const std::string DELIMITER = "\n\n\n";
+    int               bracket   = 0;
+    size_t            idx       = 0;

-    while (curitem != "" || request != "") {
-        reply += g_pHyprCtl->getReply(curitem) + DELIMITER;
-
-        nextItem();
+    for (size_t i = 0; i <= request.size(); ++i) {
+        char ch = (i < request.size()) ? request[i] : ';';
+        if (ch == '[')
+            ++bracket;
+        else if (ch == ']')
+            --bracket;
+        else if (ch == ';' && bracket == 0) {
+            if (idx < i)
+                reply += g_pHyprCtl->getReply(trim(request.substr(idx, i - idx))).append(DELIMITER);
+            idx = i + 1;
+            continue;
+        }
    }

    return reply.substr(0, std::max(static_cast<int>(reply.size() - DELIMITER.size()), 0));
 }

-std::string dispatchSetCursor(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchSetCursor(eHyprCtlOutputFormat format, std::string request) {
    CVarList    vars(request, 0, ' ');

    const auto  SIZESTR = vars[vars.size() - 1];
@@ -1206,7 +1210,7 @@ std::string dispatchSetCursor(eHyprCtlOutputFormat format, std::string request)
    return "ok";
 }

-std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::string request) {
    CVarList      vars(request, 0, ' ');

    const auto    KB  = vars[1];
@@ -1281,7 +1285,7 @@ std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::string requ
    return "ok";
 }

-std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string request) {
    CVarList    vars(request, 0, ' ');

    std::string errorMessage = "";
@@ -1310,12 +1314,12 @@ std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string request) {
    return "ok";
 }

-std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
-    auto result = g_pKeybindManager->m_mDispatchers["setprop"](request.substr(request.find_first_of(' ') + 1, -1));
+static std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
+    auto result = g_pKeybindManager->m_mDispatchers["setprop"](request.substr(request.find_first_of(' ') + 1));
    return "DEPRECATED: use hyprctl dispatch setprop instead" + (result.success ? "" : "\n" + result.error);
 }

-std::string dispatchGetOption(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchGetOption(eHyprCtlOutputFormat format, std::string request) {
    std::string curitem = "";

    auto        nextItem = [&]() {
@@ -1371,7 +1375,7 @@ std::string dispatchGetOption(eHyprCtlOutputFormat format, std::string request)
    return "invalid type (internal error)";
 }

-std::string decorationRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string decorationRequest(eHyprCtlOutputFormat format, std::string request) {
    CVarList   vars(request, 0, ' ');
    const auto PWINDOW = g_pCompositor->getWindowByRegex(vars[1]);

@@ -1397,7 +1401,7 @@ std::string decorationRequest(eHyprCtlOutputFormat format, std::string request)
    return result;
 }

-std::string dispatchOutput(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string request) {
    CVarList vars(request, 0, ' ');

    if (vars.size() < 2)
@@ -1452,7 +1456,7 @@ std::string dispatchOutput(eHyprCtlOutputFormat format, std::string request) {
    return "ok";
 }

-std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string request) {
    CVarList vars(request, 0, ' ');

    if (vars.size() < 2)
@@ -1521,7 +1525,7 @@ std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string request) {
    return "ok";
 }

-std::string dispatchNotify(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchNotify(eHyprCtlOutputFormat format, std::string request) {
    CVarList vars(request, 0, ' ');

    if (vars.size() < 5)
@@ -1576,7 +1580,7 @@ std::string dispatchNotify(eHyprCtlOutputFormat format, std::string request) {
    return "ok";
 }

-std::string dispatchDismissNotify(eHyprCtlOutputFormat format, std::string request) {
+static std::string dispatchDismissNotify(eHyprCtlOutputFormat format, std::string request) {
    CVarList vars(request, 0, ' ');

    int      amount = -1;
@@ -1596,7 +1600,7 @@ std::string dispatchDismissNotify(eHyprCtlOutputFormat format, std::string reque
    return "ok";
 }

-std::string getIsLocked(eHyprCtlOutputFormat format, std::string request) {
+static std::string getIsLocked(eHyprCtlOutputFormat format, std::string request) {
    std::string lockedStr = g_pSessionLockManager->isSessionLocked() ? "true" : "false";
    if (format == eHyprCtlOutputFormat::FORMAT_JSON)
        lockedStr = std::format(R"#(
@@ -1608,7 +1612,7 @@ std::string getIsLocked(eHyprCtlOutputFormat format, std::string request) {
    return lockedStr;
 }

-std::string getDescriptions(eHyprCtlOutputFormat format, std::string request) {
+static std::string getDescriptions(eHyprCtlOutputFormat format, std::string request) {
    std::string json  = "{";
    const auto& DESCS = g_pConfigManager->getAllDescriptions();

@@ -1623,7 +1627,7 @@ std::string getDescriptions(eHyprCtlOutputFormat format, std::string request) {
    return json;
 }

-std::string submapRequest(eHyprCtlOutputFormat format, std::string request) {
+static std::string submapRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string submap = g_pKeybindManager->getCurrentSubmap();
    if (submap.empty())
        submap = "default";
@@ -1792,7 +1796,7 @@ std::string CHyprCtl::makeDynamicCall(const std::string& input) {
    return getReply(input);
 }

-bool successWrite(int fd, const std::string& data, bool needLog = true) {
+static bool successWrite(int fd, const std::string& data, bool needLog = true) {
    if (write(fd, data.c_str(), data.length()) > 0)
        return true;

@@ -1805,7 +1809,7 @@ bool successWrite(int fd, const std::string& data, bool needLog = true) {
    return false;
 }

-void runWritingDebugLogThread(const int conn) {
+static void runWritingDebugLogThread(const int conn) {
    using namespace std::chrono_literals;
    Debug::log(LOG, "In followlog thread, got connection, start writing: {}", conn);
    //will be finished, when reading side close connection
@@ -1828,11 +1832,11 @@ void runWritingDebugLogThread(const int conn) {
    }).detach();
 }

-bool isFollowUpRollingLogRequest(const std::string& request) {
+static bool isFollowUpRollingLogRequest(const std::string& request) {
    return request.contains("rollinglog") && request.contains("f");
 }

-int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
+static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
    if (mask & WL_EVENT_ERROR || mask & WL_EVENT_HANGUP)
        return 0;

--- a/src/debug/HyprCtl.hpp
+++ b/src/debug/HyprCtl.hpp
@@ -1,8 +1,8 @@
 #pragma once

-#include "../Compositor.hpp"
 #include <fstream>
 #include "../helpers/MiscFunctions.hpp"
+#include "../desktop/Window.hpp"
 #include <functional>

 // exposed for main.cpp
@@ -38,4 +38,4 @@ class CHyprCtl {
    std::string                      m_socketPath;
 };

-inline std::unique_ptr<CHyprCtl> g_pHyprCtl;
+inline UP<CHyprCtl> g_pHyprCtl;
--- a/src/debug/HyprDebugOverlay.cpp
+++ b/src/debug/HyprDebugOverlay.cpp
@@ -2,6 +2,9 @@
 #include "HyprDebugOverlay.hpp"
 #include "config/ConfigValue.hpp"
 #include "../Compositor.hpp"
+#include "../render/pass/TexPassElement.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/AnimationManager.hpp"

 CHyprDebugOverlay::CHyprDebugOverlay() {
    m_pTexture = makeShared<CTexture>();
@@ -195,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);
+    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_wbLastDrawnBox);

    return posY - offset;
 }
@@ -268,6 +271,8 @@ void CHyprDebugOverlay::draw() {

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);

-    CBox pMonBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
-    g_pHyprOpenGL->renderTexture(m_pTexture, &pMonBox, 1.f);
+    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));
 }
--- a/src/debug/HyprDebugOverlay.hpp
+++ b/src/debug/HyprDebugOverlay.hpp
@@ -1,7 +1,6 @@
 #pragma once

 #include "../defines.hpp"
-#include "../helpers/Monitor.hpp"
 #include "../render/Texture.hpp"
 #include <cairo/cairo.h>
 #include <map>
@@ -49,4 +48,4 @@ class CHyprDebugOverlay {
    friend class CHyprRenderer;
 };

-inline std::unique_ptr<CHyprDebugOverlay> g_pDebugOverlay;
+inline UP<CHyprDebugOverlay> g_pDebugOverlay;
--- a/src/debug/HyprNotificationOverlay.cpp
+++ b/src/debug/HyprNotificationOverlay.cpp
@@ -3,8 +3,13 @@
 #include "HyprNotificationOverlay.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
+#include "../render/pass/TexPassElement.hpp"

-inline auto iconBackendFromLayout(PangoLayout* layout) {
+#include "../managers/AnimationManager.hpp"
+#include "../managers/HookSystemManager.hpp"
+#include "../render/Renderer.hpp"
+
+static inline auto iconBackendFromLayout(PangoLayout* layout) {
    // preference: Nerd > FontAwesome > text
    auto eIconBackendChecks = std::array<eIconBackend, 2>{ICONS_BACKEND_NF, ICONS_BACKEND_FA};
    for (auto iconID : eIconBackendChecks) {
@@ -21,7 +26,7 @@ CHyprNotificationOverlay::CHyprNotificationOverlay() {
        if (m_vNotifications.size() == 0)
            return;

-        g_pHyprRenderer->damageBox(&m_bLastDamage);
+        g_pHyprRenderer->damageBox(m_bLastDamage);
    });

    m_pTexture = makeShared<CTexture>();
@@ -35,7 +40,7 @@ CHyprNotificationOverlay::~CHyprNotificationOverlay() {
 }

 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(std::make_unique<SNotification>()).get();
+    const auto PNOTIF = m_vNotifications.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;
@@ -220,8 +225,8 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {

    CBox damage = drawNotifications(pMonitor);

-    g_pHyprRenderer->damageBox(&damage);
-    g_pHyprRenderer->damageBox(&m_bLastDamage);
+    g_pHyprRenderer->damageBox(damage);
+    g_pHyprRenderer->damageBox(m_bLastDamage);

    g_pCompositor->scheduleFrameForMonitor(pMonitor);

@@ -241,8 +246,12 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, MONSIZE.x, MONSIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);

-    CBox pMonBox = {0, 0, MONSIZE.x, MONSIZE.y};
-    g_pHyprOpenGL->renderTexture(m_pTexture, &pMonBox, 1.f);
+    CTexPassElement::SRenderData data;
+    data.tex = m_pTexture;
+    data.box = {0, 0, MONSIZE.x, MONSIZE.y};
+    data.a   = 1.F;
+
+    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }

 bool CHyprNotificationOverlay::hasAny() {
--- a/src/debug/HyprNotificationOverlay.hpp
+++ b/src/debug/HyprNotificationOverlay.hpp
@@ -2,7 +2,6 @@

 #include "../defines.hpp"
 #include "../helpers/Timer.hpp"
-#include "../helpers/Monitor.hpp"
 #include "../render/Texture.hpp"
 #include "../SharedDefs.hpp"

@@ -47,18 +46,18 @@ class CHyprNotificationOverlay {
    bool hasAny();

  private:
-    CBox                                        drawNotifications(PHLMONITOR pMonitor);
-    CBox                                        m_bLastDamage;
+    CBox                           drawNotifications(PHLMONITOR pMonitor);
+    CBox                           m_bLastDamage;

-    std::vector<std::unique_ptr<SNotification>> m_vNotifications;
+    std::vector<UP<SNotification>> m_vNotifications;

-    cairo_surface_t*                            m_pCairoSurface = nullptr;
-    cairo_t*                                    m_pCairo        = nullptr;
+    cairo_surface_t*               m_pCairoSurface = nullptr;
+    cairo_t*                       m_pCairo        = nullptr;

-    PHLMONITORREF                               m_pLastMonitor;
-    Vector2D                                    m_vecLastSize = Vector2D(-1, -1);
+    PHLMONITORREF                  m_pLastMonitor;
+    Vector2D                       m_vecLastSize = Vector2D(-1, -1);

-    SP<CTexture>                                m_pTexture;
+    SP<CTexture>                   m_pTexture;
 };

-inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay;
+inline UP<CHyprNotificationOverlay> g_pHyprNotificationOverlay;
--- a/src/debug/Log.cpp
+++ b/src/debug/Log.cpp
@@ -1,6 +1,5 @@
 #include "Log.hpp"
 #include "../defines.hpp"
-#include "../Compositor.hpp"
 #include "RollingLogFollow.hpp"

 #include <fstream>
--- a/src/debug/Log.hpp
+++ b/src/debug/Log.hpp
@@ -5,8 +5,6 @@
 #include <fstream>
 #include <chrono>
 #include <mutex>
-#include "../includes.hpp"
-#include "../helpers/MiscFunctions.hpp"

 #define LOGMESSAGESIZE   1024
 #define ROLLING_LOG_SIZE 4096
--- a/src/defines.hpp
+++ b/src/defines.hpp
@@ -1,3 +1,5 @@
+#pragma once
+
 #include "includes.hpp"
 #include "debug/Log.hpp"
 #include "helpers/Color.hpp"
--- a/src/desktop/DesktopTypes.hpp
+++ b/src/desktop/DesktopTypes.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "../macros.hpp"
+#include "../helpers/memory/Memory.hpp"
 class CWorkspace;
 class CWindow;
 class CLayerSurface;
--- a/src/desktop/LayerRule.cpp
+++ b/src/desktop/LayerRule.cpp
@@ -1,3 +1,4 @@
+#include <re2/re2.h>
 #include "LayerRule.hpp"
 #include <unordered_set>
 #include <algorithm>
--- a/src/desktop/LayerRule.hpp
+++ b/src/desktop/LayerRule.hpp
@@ -2,6 +2,7 @@

 #include <string>
 #include <cstdint>
+#include "Rule.hpp"

 class CLayerRule {
  public:
@@ -21,8 +22,10 @@ class CLayerRule {
        RULE_ZUMBA,
    };

-    eRuleType         ruleType = RULE_INVALID;
+    eRuleType           ruleType = RULE_INVALID;

-    const std::string targetNamespace;
-    const std::string rule;
+    const std::string   targetNamespace;
+    const std::string   rule;
+
+    CRuleRegexContainer targetNamespaceRegex;
 };
--- a/src/desktop/LayerSurface.cpp
+++ b/src/desktop/LayerSurface.cpp
@@ -4,6 +4,13 @@
 #include "../protocols/LayerShell.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../managers/SeatManager.hpp"
+#include "../managers/AnimationManager.hpp"
+#include "../render/Renderer.hpp"
+#include "../config/ConfigManager.hpp"
+#include "../helpers/Monitor.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/HookSystemManager.hpp"
+#include "../managers/EventManager.hpp"

 PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
    PHLLS pLS = SP<CLayerSurface>(new CLayerSurface(resource));
@@ -25,22 +32,19 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
    pLS->szNamespace = resource->layerNamespace;

    pLS->layer     = resource->current.layer;
-    pLS->popupHead = std::make_unique<CPopup>(pLS);
+    pLS->popupHead = CPopup::create(pLS);
    pLS->monitor   = pMonitor;
    pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);

    pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);

-    pLS->alpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
-    pLS->realPosition.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
-    pLS->realSize.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
-    pLS->alpha.registerVar();
-    pLS->realPosition.registerVar();
-    pLS->realSize.registerVar();
+    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);

    pLS->registerCallbacks();

-    pLS->alpha.setValueAndWarp(0.f);
+    pLS->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);

@@ -48,7 +52,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
 }

 void CLayerSurface::registerCallbacks() {
-    alpha.setUpdateCallback([this](void*) {
+    alpha->setUpdateCallback([this](auto) {
        if (dimAround)
            g_pHyprRenderer->damageMonitor(monitor.lock());
    });
@@ -93,7 +97,8 @@ void CLayerSurface::onDestroy() {
            onUnmap();
        } else {
            Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-            alpha.setValueAndWarp(0.f);
+            if (alpha)
+                alpha->setValueAndWarp(0.f);
            fadingOut = true;
            g_pCompositor->addToFadingOutSafe(self.lock());
        }
@@ -110,7 +115,7 @@ void CLayerSurface::onDestroy() {

        // and damage
        CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
-        g_pHyprRenderer->damageBox(&geomFixed);
+        g_pHyprRenderer->damageBox(geomFixed);
    }

    readyToDelete = true;
@@ -174,7 +179,7 @@ void CLayerSurface::onMap() {
    position = Vector2D(geometry.x, geometry.y);

    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    g_pHyprRenderer->damageBox(geomFixed);
    const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_bHasFullscreenWindow && PMONITOR->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN;

    startAnimation(!(layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
@@ -210,7 +215,7 @@ void CLayerSurface::onUnmap() {
    }

    // make a snapshot and start fade
-    g_pHyprOpenGL->makeLayerSnapshot(self.lock());
+    g_pHyprRenderer->makeLayerSnapshot(self.lock());

    startAnimation(false);

@@ -235,13 +240,13 @@ void CLayerSurface::onUnmap() {
        g_pSeatManager->setKeyboardFocus(g_pCompositor->m_pLastFocus.lock());

    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    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};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    g_pHyprRenderer->damageBox(geomFixed);

-    g_pInputManager->sendMotionEventsToFocused();
+    g_pInputManager->simulateMouseMovement();

    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 }
@@ -270,7 +275,7 @@ void CLayerSurface::onCommit() {
        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd

    CBox geomFixed = {geometry.x, geometry.y, geometry.width, geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    g_pHyprRenderer->damageBox(geomFixed);

    if (layerSurface->current.committed != 0) {
        if (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
@@ -307,17 +312,17 @@ void CLayerSurface::onCommit() {
        }
    }

-    if (realPosition.goal() != geometry.pos()) {
-        if (realPosition.isBeingAnimated())
-            realPosition = geometry.pos();
+    if (realPosition->goal() != geometry.pos()) {
+        if (realPosition->isBeingAnimated())
+            *realPosition = geometry.pos();
        else
-            realPosition.setValueAndWarp(geometry.pos());
+            realPosition->setValueAndWarp(geometry.pos());
    }
-    if (realSize.goal() != geometry.size()) {
-        if (realSize.isBeingAnimated())
-            realSize = geometry.size();
+    if (realSize->goal() != geometry.size()) {
+        if (realSize->isBeingAnimated())
+            *realSize = geometry.size();
        else
-            realSize.setValueAndWarp(geometry.size());
+            realSize->setValueAndWarp(geometry.size());
    }

    if (mapped && (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_INTERACTIVITY)) {
@@ -327,7 +332,7 @@ void CLayerSurface::onCommit() {
            nullptr);
        if (!WASLASTFOCUS && popupHead) {
            popupHead->breadthfirst(
-                [&WASLASTFOCUS](CPopup* popup, void* data) {
+                [&WASLASTFOCUS](WP<CPopup> popup, void* data) {
                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_pWLSurface && g_pSeatManager->state.keyboardFocus == popup->m_pWLSurface->resource());
                },
                nullptr);
@@ -434,17 +439,17 @@ void CLayerSurface::applyRules() {
 }

 void CLayerSurface::startAnimation(bool in, bool instant) {
-    const auto ANIMSTYLE = animationStyle.value_or(realPosition.m_pConfig->pValues->internalStyle);
    if (in) {
-        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersIn");
-        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersIn");
-        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn");
+        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
    } else {
-        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersOut");
-        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersOut");
-        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut");
+        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
+        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
+        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut"));
    }

+    const auto ANIMSTYLE = animationStyle.value_or(realPosition->getStyle());
    if (ANIMSTYLE.starts_with("slide")) {
        // get closest edge
        const auto MIDDLE = geometry.middle();
@@ -485,9 +490,9 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
            }
        }

-        realSize.setValueAndWarp(geometry.size());
-        alpha.setValueAndWarp(in ? 0.f : 1.f);
-        alpha = in ? 1.f : 0.f;
+        realSize->setValueAndWarp(geometry.size());
+        alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *alpha = in ? 1.f : 0.f;

        Vector2D prePos;

@@ -512,11 +517,11 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
        }

        if (in) {
-            realPosition.setValueAndWarp(prePos);
-            realPosition = geometry.pos();
+            realPosition->setValueAndWarp(prePos);
+            *realPosition = geometry.pos();
        } else {
-            realPosition.setValueAndWarp(geometry.pos());
-            realPosition = prePos;
+            realPosition->setValueAndWarp(geometry.pos());
+            *realPosition = prePos;
        }

    } else if (ANIMSTYLE.starts_with("popin")) {
@@ -535,25 +540,25 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
        const auto GOALSIZE = (geometry.size() * minPerc).clamp({5, 5});
        const auto GOALPOS  = geometry.pos() + (geometry.size() - GOALSIZE) / 2.f;

-        alpha.setValueAndWarp(in ? 0.f : 1.f);
-        alpha = in ? 1.f : 0.f;
+        alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *alpha = in ? 1.f : 0.f;

        if (in) {
-            realSize.setValueAndWarp(GOALSIZE);
-            realPosition.setValueAndWarp(GOALPOS);
-            realSize     = geometry.size();
-            realPosition = geometry.pos();
+            realSize->setValueAndWarp(GOALSIZE);
+            realPosition->setValueAndWarp(GOALPOS);
+            *realSize     = geometry.size();
+            *realPosition = geometry.pos();
        } else {
-            realSize.setValueAndWarp(geometry.size());
-            realPosition.setValueAndWarp(geometry.pos());
-            realSize     = GOALSIZE;
-            realPosition = GOALPOS;
+            realSize->setValueAndWarp(geometry.size());
+            realPosition->setValueAndWarp(geometry.pos());
+            *realSize     = GOALSIZE;
+            *realPosition = GOALPOS;
        }
    } else {
        // fade
-        realPosition.setValueAndWarp(geometry.pos());
-        realSize.setValueAndWarp(geometry.size());
-        alpha = in ? 1.f : 0.f;
+        realPosition->setValueAndWarp(geometry.pos());
+        realSize->setValueAndWarp(geometry.size());
+        *alpha = in ? 1.f : 0.f;
    }

    if (!in)
@@ -564,7 +569,7 @@ bool CLayerSurface::isFadedOut() {
    if (!fadingOut)
        return false;

-    return !realPosition.isBeingAnimated() && !realSize.isBeingAnimated() && !alpha.isBeingAnimated();
+    return !realPosition->isBeingAnimated() && !realSize->isBeingAnimated() && !alpha->isBeingAnimated();
 }

 int CLayerSurface::popupsCount() {
@@ -572,7 +577,7 @@ int CLayerSurface::popupsCount() {
        return 0;

    int no = -1; // we have one dummy
-    popupHead->breadthfirst([](CPopup* p, void* data) { *(int*)data += 1; }, &no);
+    popupHead->breadthfirst([](WP<CPopup> p, void* data) { *(int*)data += 1; }, &no);
    return no;
 }

--- a/src/desktop/LayerSurface.hpp
+++ b/src/desktop/LayerSurface.hpp
@@ -4,7 +4,6 @@
 #include "../defines.hpp"
 #include "WLSurface.hpp"
 #include "../helpers/AnimatedVariable.hpp"
-#include "LayerRule.hpp"

 class CLayerShellResource;

@@ -18,17 +17,17 @@ class CLayerSurface {
  public:
    ~CLayerSurface();

-    void                        applyRules();
-    void                        startAnimation(bool in, bool instant = false);
-    bool                        isFadedOut();
-    int                         popupsCount();
+    void                    applyRules();
+    void                    startAnimation(bool in, bool instant = false);
+    bool                    isFadedOut();
+    int                     popupsCount();

-    CAnimatedVariable<Vector2D> realPosition;
-    CAnimatedVariable<Vector2D> realSize;
-    CAnimatedVariable<float>    alpha;
+    PHLANIMVAR<Vector2D>    realPosition;
+    PHLANIMVAR<Vector2D>    realSize;
+    PHLANIMVAR<float>       alpha;

-    WP<CLayerShellResource>     layerSurface;
-    wl_list                     link;
+    WP<CLayerShellResource> layerSurface;
+    wl_list                 link;

    // the header providing the enum type cannot be imported here
    int                        interactivity = 0;
@@ -60,7 +59,7 @@ class CLayerSurface {
    CBox                       geometry = {0, 0, 0, 0};
    Vector2D                   position;
    std::string                szNamespace = "";
-    std::unique_ptr<CPopup>    popupHead;
+    UP<CPopup>                 popupHead;

    void                       onDestroy();
    void                       onMap();
--- a/src/desktop/Popup.cpp
+++ b/src/desktop/Popup.cpp
@@ -6,24 +6,43 @@
 #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"
+#include "../render/OpenGL.hpp"
 #include <ranges>

-CPopup::CPopup(PHLWINDOW pOwner) : m_pWindowOwner(pOwner) {
-    initAllSignals();
+UP<CPopup> CPopup::create(PHLWINDOW pOwner) {
+    auto popup            = UP<CPopup>(new CPopup());
+    popup->m_pWindowOwner = pOwner;
+    popup->m_pSelf        = popup;
+    popup->initAllSignals();
+    return popup;
 }

-CPopup::CPopup(PHLLS pOwner) : m_pLayerOwner(pOwner) {
-    initAllSignals();
+UP<CPopup> CPopup::create(PHLLS pOwner) {
+    auto popup           = UP<CPopup>(new CPopup());
+    popup->m_pLayerOwner = pOwner;
+    popup->m_pSelf       = popup;
+    popup->initAllSignals();
+    return popup;
 }

-CPopup::CPopup(SP<CXDGPopupResource> popup, CPopup* pOwner) : m_pWindowOwner(pOwner->m_pWindowOwner), m_pLayerOwner(pOwner->m_pLayerOwner), m_pParent(pOwner), m_pResource(popup) {
-    m_pWLSurface = CWLSurface::create();
-    m_pWLSurface->assign(popup->surface->surface.lock(), this);
+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());

-    m_vLastSize = popup->surface->current.geometry.size();
-    reposition();
+    popup->m_vLastSize = resource->surface->current.geometry.size();
+    popup->reposition();

-    initAllSignals();
+    popup->initAllSignals();
+    return popup;
 }

 CPopup::~CPopup() {
@@ -54,7 +73,8 @@ void CPopup::initAllSignals() {
 }

 void CPopup::onNewPopup(SP<CXDGPopupResource> popup) {
-    const auto POPUP = m_vChildren.emplace_back(makeShared<CPopup>(popup, this)).get();
+    const auto& POPUP = m_vChildren.emplace_back(CPopup::create(popup, m_pSelf));
+    POPUP->m_pSelf    = POPUP;
    Debug::log(LOG, "New popup at {:x}", (uintptr_t)POPUP);
 }

@@ -79,13 +99,13 @@ void CPopup::onMap() {

    CBox       box = m_pWLSurface->resource()->extends();
    box.translate(COORDS).expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);

    m_vLastPos = coordsRelativeToParent();

    g_pInputManager->simulateMouseMovement();

-    m_pSubsurfaceHead = std::make_unique<CSubsurface>(this);
+    m_pSubsurfaceHead = CSubsurface::create(m_pSelf);

    //unconstrain();
    sendScale();
@@ -113,7 +133,7 @@ void CPopup::onUnmap() {

    CBox       box = m_pWLSurface->resource()->extends();
    box.translate(COORDS).expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);

    m_pSubsurfaceHead.reset();

@@ -122,19 +142,20 @@ void CPopup::onUnmap() {

    // damage all children
    breadthfirst(
-        [](CPopup* p, void* data) {
+        [](WP<CPopup> p, void* data) {
            if (!p->m_pResource)
                return;

            auto box = CBox{p->coordsGlobal(), p->size()};
-            g_pHyprRenderer->damageBox(&box);
+            g_pHyprRenderer->damageBox(box);
        },
        nullptr);

-    const bool WASLASTFOCUS = g_pSeatManager->state.keyboardFocus == m_pWLSurface->resource() || g_pSeatManager->state.pointerFocus == m_pWLSurface->resource();
+    // TODO: probably refocus, but without a motion event?
+    // const bool WASLASTFOCUS = g_pSeatManager->state.keyboardFocus == m_pWLSurface->resource() || g_pSeatManager->state.pointerFocus == m_pWLSurface->resource();

-    if (WASLASTFOCUS)
-        g_pInputManager->simulateMouseMovement();
+    // if (WASLASTFOCUS)
+    //     g_pInputManager->simulateMouseMovement();
 }

 void CPopup::onCommit(bool ignoreSiblings) {
@@ -166,10 +187,10 @@ void CPopup::onCommit(bool ignoreSiblings) {

    if (m_vLastSize != m_pResource->surface->surface->current.size || m_bRequestedReposition || m_vLastPos != COORDSLOCAL) {
        CBox box = {localToGlobal(m_vLastPos), m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
+        g_pHyprRenderer->damageBox(box);
        m_vLastSize = m_pResource->surface->surface->current.size;
        box         = {COORDS, m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
+        g_pHyprRenderer->damageBox(box);

        m_vLastPos = COORDSLOCAL;
    }
@@ -219,7 +240,7 @@ Vector2D CPopup::coordsRelativeToParent() {
    if (!m_pResource)
        return {};

-    CPopup* current = this;
+    WP<CPopup> current = m_pSelf;
    offset -= current->m_pResource->surface->current.geometry.pos();

    while (current->m_pParent && current->m_pResource) {
@@ -243,16 +264,16 @@ Vector2D CPopup::localToGlobal(const Vector2D& rel) {

 Vector2D CPopup::t1ParentCoords() {
    if (!m_pWindowOwner.expired())
-        return m_pWindowOwner->m_vRealPosition.value();
+        return m_pWindowOwner->m_vRealPosition->value();
    if (!m_pLayerOwner.expired())
-        return m_pLayerOwner->realPosition.value();
+        return m_pLayerOwner->realPosition->value();

    ASSERT(false);
    return {};
 }

 void CPopup::recheckTree() {
-    CPopup* curr = this;
+    WP<CPopup> curr = m_pSelf;
    while (curr->m_pParent) {
        curr = curr->m_pParent;
    }
@@ -261,7 +282,8 @@ void CPopup::recheckTree() {
 }

 void CPopup::recheckChildrenRecursive() {
-    auto cpy = m_vChildren;
+    std::vector<WP<CPopup>> cpy;
+    std::ranges::for_each(m_vChildren, [&cpy](const auto& el) { cpy.emplace_back(el); });
    for (auto const& c : cpy) {
        c->onCommit(true);
        c->recheckChildrenRecursive();
@@ -292,17 +314,17 @@ bool CPopup::visible() {
    return false;
 }

-void CPopup::bfHelper(std::vector<CPopup*> const& nodes, std::function<void(CPopup*, void*)> fn, void* data) {
+void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(WP<CPopup>, void*)> fn, void* data) {
    for (auto const& n : nodes) {
        fn(n, data);
    }

-    std::vector<CPopup*> nodes2;
+    std::vector<WP<CPopup>> nodes2;
    nodes2.reserve(nodes.size() * 2);

    for (auto const& n : nodes) {
        for (auto const& c : n->m_vChildren) {
-            nodes2.push_back(c.get());
+            nodes2.push_back(c->m_pSelf);
        }
    }

@@ -310,35 +332,37 @@ void CPopup::bfHelper(std::vector<CPopup*> const& nodes, std::function<void(CPop
        bfHelper(nodes2, fn, data);
 }

-void CPopup::breadthfirst(std::function<void(CPopup*, void*)> fn, void* data) {
-    std::vector<CPopup*> popups;
-    popups.push_back(this);
+void CPopup::breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data) {
+    std::vector<WP<CPopup>> popups;
+    popups.push_back(m_pSelf);
    bfHelper(popups, fn, data);
 }

-CPopup* CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
-    std::vector<CPopup*> popups;
-    breadthfirst([](CPopup* popup, void* data) { ((std::vector<CPopup*>*)data)->push_back(popup); }, &popups);
+WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
+    std::vector<WP<CPopup>> popups;
+    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)
            continue;

        if (!allowsInput) {
-            const Vector2D offset = p->m_pResource ? (p->size() - p->m_pResource->geometry.size()) / 2.F : Vector2D{};
-            const Vector2D size   = p->m_pResource ? p->m_pResource->geometry.size() : p->size();
+            const Vector2D offset =
+                p->m_pResource && p->m_pResource->surface ? (p->size() - p->m_pResource->geometry.size()) / 2.F - p->m_pResource->surface->current.geometry.pos() : Vector2D{};
+            const Vector2D size = p->m_pResource ? p->m_pResource->geometry.size() : p->size();

            const auto     BOX = CBox{p->coordsGlobal() + offset, size};
            if (BOX.containsPoint(globalCoords))
                return p;
        } else {
-            const Vector2D offset = p->m_pResource ? (p->size() - p->m_pResource->geometry.size()) / 2.F : Vector2D{};
-            const auto     REGION =
+            const Vector2D offset =
+                p->m_pResource && p->m_pResource->surface ? (p->size() - p->m_pResource->geometry.size()) / 2.F - p->m_pResource->surface->current.geometry.pos() : Vector2D{};
+            const auto REGION =
                CRegion{p->m_pWLSurface->resource()->current.input}.intersect(CBox{{}, p->m_pWLSurface->resource()->current.size}).translate(p->coordsGlobal() + offset);
            if (REGION.containsPoint(globalCoords))
                return p;
        }
    }

-    return nullptr;
+    return {};
 }
--- a/src/desktop/Popup.hpp
+++ b/src/desktop/Popup.hpp
@@ -1,20 +1,20 @@
 #pragma once

 #include <vector>
-#include <memory>
 #include "Subsurface.hpp"
 #include "../helpers/signal/Signal.hpp"
+#include "../helpers/memory/Memory.hpp"

 class CXDGPopupResource;

 class CPopup {
  public:
    // dummy head nodes
-    CPopup(PHLWINDOW pOwner);
-    CPopup(PHLLS pOwner);
+    static UP<CPopup> create(PHLWINDOW pOwner);
+    static UP<CPopup> create(PHLLS pOwner);

    // real nodes
-    CPopup(SP<CXDGPopupResource> popup, CPopup* pOwner);
+    static UP<CPopup> create(SP<CXDGPopupResource> popup, WP<CPopup> pOwner);

    ~CPopup();

@@ -36,20 +36,23 @@ class CPopup {
    bool           visible();

    // will also loop over this node
-    void    breadthfirst(std::function<void(CPopup*, void*)> fn, void* data);
-    CPopup* at(const Vector2D& globalCoords, bool allowsInput = false);
+    void       breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data);
+    WP<CPopup> at(const Vector2D& globalCoords, bool allowsInput = false);

    //
    SP<CWLSurface> m_pWLSurface;
+    WP<CPopup>     m_pSelf;
    bool           m_bMapped = false;

  private:
+    CPopup() = default;
+
    // T1 owners, each popup has to have one of these
    PHLWINDOWREF m_pWindowOwner;
    PHLLSREF     m_pLayerOwner;

    // T2 owners
-    CPopup*               m_pParent = nullptr;
+    WP<CPopup>            m_pParent;

    WP<CXDGPopupResource> m_pResource;

@@ -61,8 +64,8 @@ class CPopup {
    bool                  m_bInert = false;

    //
-    std::vector<SP<CPopup>>      m_vChildren;
-    std::unique_ptr<CSubsurface> m_pSubsurfaceHead;
+    std::vector<UP<CPopup>> m_vChildren;
+    UP<CSubsurface>         m_pSubsurfaceHead;

    struct {
        CHyprSignalListener newPopup;
@@ -81,5 +84,5 @@ class CPopup {

    Vector2D    localToGlobal(const Vector2D& rel);
    Vector2D    t1ParentCoords();
-    static void bfHelper(std::vector<CPopup*> const& nodes, std::function<void(CPopup*, void*)> fn, void* data);
+    static void bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(WP<CPopup>, void*)> fn, void* data);
 };
--- a/src/desktop/Rule.cpp
+++ b/src/desktop/Rule.cpp
@@ -0,0 +1,22 @@
+#include <re2/re2.h>
+#include "../helpers/memory/Memory.hpp"
+#include "Rule.hpp"
+#include "../debug/Log.hpp"
+
+CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) {
+    const bool NEGATIVE = regex_.starts_with("negative:");
+
+    negative = NEGATIVE;
+    regex    = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
+
+    // TODO: maybe pop an error?
+    if (!regex->ok())
+        Debug::log(ERR, "RuleRegexContainer: regex {} failed to parse!", regex_);
+}
+
+bool CRuleRegexContainer::passes(const std::string& str) const {
+    if (!regex)
+        return false;
+
+    return RE2::FullMatch(str, *regex) != negative;
+}
--- a/src/desktop/Rule.hpp
+++ b/src/desktop/Rule.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <hyprutils/memory/UniquePtr.hpp>
+
+//NOLINTNEXTLINE
+namespace re2 {
+    class RE2;
+};
+
+class CRuleRegexContainer {
+  public:
+    CRuleRegexContainer() = default;
+
+    CRuleRegexContainer(const std::string& regex);
+
+    bool passes(const std::string& str) const;
+
+  private:
+    Hyprutils::Memory::CUniquePointer<re2::RE2> regex;
+    bool                                        negative = false;
+};
--- a/src/desktop/Subsurface.cpp
+++ b/src/desktop/Subsurface.cpp
@@ -4,29 +4,50 @@
 #include "../config/ConfigValue.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/core/Subcompositor.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/input/InputManager.hpp"

-CSubsurface::CSubsurface(PHLWINDOW pOwner) : m_pWindowParent(pOwner) {
-    initSignals();
-    initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+UP<CSubsurface> CSubsurface::create(PHLWINDOW pOwner) {
+    auto subsurface             = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_pWindowParent = pOwner;
+    subsurface->m_pSelf         = subsurface;
+
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+    return subsurface;
 }

-CSubsurface::CSubsurface(CPopup* pOwner) : m_pPopupParent(pOwner) {
-    initSignals();
-    initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+UP<CSubsurface> CSubsurface::create(WP<CPopup> pOwner) {
+    auto subsurface            = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_pPopupParent = pOwner;
+    subsurface->m_pSelf        = subsurface;
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+    return subsurface;
 }

-CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner) : m_pSubsurface(pSubsurface), m_pWindowParent(pOwner) {
-    m_pWLSurface = CWLSurface::create();
-    m_pWLSurface->assign(pSubsurface->surface.lock(), this);
-    initSignals();
-    initExistingSubsurfaces(pSubsurface->surface.lock());
+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());
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
+    return subsurface;
 }

-CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, CPopup* pOwner) : m_pSubsurface(pSubsurface), m_pPopupParent(pOwner) {
-    m_pWLSurface = CWLSurface::create();
-    m_pWLSurface->assign(pSubsurface->surface.lock(), this);
-    initSignals();
-    initExistingSubsurfaces(pSubsurface->surface.lock());
+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());
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
+    return subsurface;
 }

 CSubsurface::~CSubsurface() {
@@ -99,11 +120,20 @@ void CSubsurface::onCommit() {
    checkSiblingDamage();

    if (m_vLastSize != m_pWLSurface->resource()->current.size) {
-        CBox box{COORDS, m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
-        m_vLastSize = m_pWLSurface->resource()->current.size;
-        box         = {COORDS, m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
+        // 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)
+            box = m_pPopupParent->m_pWLSurface->getSurfaceBoxGlobal().value_or(CBox{});
+        else if (m_pWindowParent)
+            box = m_pWindowParent->getWindowMainSurfaceBox();
+
+        g_pHyprRenderer->damageBox(box);
    }
 }

@@ -121,16 +151,18 @@ void CSubsurface::onDestroy() {
 }

 void CSubsurface::onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface) {
-    CSubsurface* PSUBSURFACE = nullptr;
+    WP<CSubsurface> PSUBSURFACE;

    if (!m_pWindowParent.expired())
-        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pWindowParent.lock())).get();
+        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pWindowParent.lock()));
    else if (m_pPopupParent)
-        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pPopupParent)).get();
+        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pPopupParent));
+
+    PSUBSURFACE->m_pSelf = PSUBSURFACE;

    ASSERT(PSUBSURFACE);

-    PSUBSURFACE->m_pParent = this;
+    PSUBSURFACE->m_pParent = m_pSelf;
 }

 void CSubsurface::onMap() {
@@ -139,7 +171,7 @@ void CSubsurface::onMap() {
    const auto COORDS = coordsGlobal();
    CBox       box{COORDS, m_vLastSize};
    box.expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);

    if (!m_pWindowParent.expired())
        m_pWindowParent->updateSurfaceScaleTransformDetails();
@@ -149,7 +181,7 @@ void CSubsurface::onUnmap() {
    const auto COORDS = coordsGlobal();
    CBox       box{COORDS, m_vLastSize};
    box.expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);

    if (m_pWLSurface->resource() == g_pCompositor->m_pLastFocus)
        g_pInputManager->releaseAllMouseButtons();
@@ -169,7 +201,7 @@ Vector2D CSubsurface::coordsGlobal() {
    Vector2D coords = coordsRelativeToParent();

    if (!m_pWindowParent.expired())
-        coords += m_pWindowParent->m_vRealPosition.value();
+        coords += m_pWindowParent->m_vRealPosition->value();
    else if (m_pPopupParent)
        coords += m_pPopupParent->coordsGlobal();

--- a/src/desktop/Subsurface.hpp
+++ b/src/desktop/Subsurface.hpp
@@ -10,31 +10,35 @@ class CWLSubsurfaceResource;
 class CSubsurface {
  public:
    // root dummy nodes
-    CSubsurface(PHLWINDOW pOwner);
-    CSubsurface(CPopup* pOwner);
+    static UP<CSubsurface> create(PHLWINDOW pOwner);
+    static UP<CSubsurface> create(WP<CPopup> pOwner);

    // real nodes
-    CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner);
-    CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, CPopup* pOwner);
+    static UP<CSubsurface> create(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner);
+    static UP<CSubsurface> create(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner);

    ~CSubsurface();

-    Vector2D coordsRelativeToParent();
-    Vector2D coordsGlobal();
+    Vector2D        coordsRelativeToParent();
+    Vector2D        coordsGlobal();

-    Vector2D size();
+    Vector2D        size();

-    void     onCommit();
-    void     onDestroy();
-    void     onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface);
-    void     onMap();
-    void     onUnmap();
+    void            onCommit();
+    void            onDestroy();
+    void            onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface);
+    void            onMap();
+    void            onUnmap();

-    bool     visible();
+    bool            visible();

-    void     recheckDamageForSubsurfaces();
+    void            recheckDamageForSubsurfaces();
+
+    WP<CSubsurface> m_pSelf;

  private:
+    CSubsurface() = default;
+
    struct {
        CHyprSignalListener destroySubsurface;
        CHyprSignalListener commitSubsurface;
@@ -48,16 +52,16 @@ class CSubsurface {
    Vector2D                  m_vLastSize = {};

    // if nullptr, means it's a dummy node
-    CSubsurface*                              m_pParent = nullptr;
+    WP<CSubsurface>              m_pParent;

-    PHLWINDOWREF                              m_pWindowParent;
-    CPopup*                                   m_pPopupParent = nullptr;
+    PHLWINDOWREF                 m_pWindowParent;
+    WP<CPopup>                   m_pPopupParent;

-    std::vector<std::unique_ptr<CSubsurface>> m_vChildren;
+    std::vector<UP<CSubsurface>> m_vChildren;

-    bool                                      m_bInert = false;
+    bool                         m_bInert = false;

-    void                                      initSignals();
-    void                                      initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
-    void                                      checkSiblingDamage();
+    void                         initSignals();
+    void                         initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
+    void                         checkSiblingDamage();
 };
--- a/src/desktop/WLSurface.cpp
+++ b/src/desktop/WLSurface.cpp
@@ -1,7 +1,9 @@
 #include "WLSurface.hpp"
-#include "../Compositor.hpp"
+#include "LayerSurface.hpp"
+#include "../desktop/Window.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/LayerShell.hpp"
+#include "../render/Renderer.hpp"

 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface) {
    m_pResource = pSurface;
@@ -72,7 +74,7 @@ Vector2D CWLSurface::correctSmallVec() const {
    const auto SIZE = getViewporterCorrectedSize();
    const auto O    = m_pWindowOwner.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_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize->value() / O->m_vReportedSize);
 }

 Vector2D CWLSurface::correctSmallVecBuf() const {
--- a/src/desktop/WLSurface.hpp
+++ b/src/desktop/WLSurface.hpp
@@ -84,7 +84,11 @@ class CWLSurface {
    static SP<CWLSurface> fromResource(SP<CWLSurfaceResource> pSurface);

    // used by the alpha-modifier protocol
-    float m_pAlphaModifier = 1.F;
+    float m_fAlphaModifier = 1.F;
+
+    // used by the hyprland-surface protocol
+    float   m_fOverallOpacity = 1.F;
+    CRegion m_visibleRegion;

    struct {
        CSignal destroy;
@@ -116,4 +120,5 @@ class CWLSurface {
    } listeners;

    friend class CPointerConstraint;
-};
+    friend class CXxColorManagerV4;
+};
--- a/src/desktop/Window.cpp
+++ b/src/desktop/Window.cpp
@@ -1,3 +1,4 @@
+#include <hyprutils/animation/AnimatedVariable.hpp>
 #include <re2/re2.h>

 #include <any>
@@ -11,12 +12,23 @@
 #include "../render/decorations/CHyprBorderDecoration.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../managers/TokenManager.hpp"
+#include "../managers/AnimationManager.hpp"
 #include "../protocols/XDGShell.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../xwayland/XWayland.hpp"
+#include "../helpers/Color.hpp"
+#include "../events/Events.hpp"
+#include "../managers/XWaylandManager.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/HookSystemManager.hpp"
+#include "../managers/EventManager.hpp"
+#include "../managers/input/InputManager.hpp"

 #include <hyprutils/string/String.hpp>
+
 using namespace Hyprutils::String;
+using namespace Hyprutils::Animation;

 PHLWINDOW CWindow::create(SP<CXWaylandSurface> surface) {
    PHLWINDOW pWindow = SP<CWindow>(new CWindow(surface));
@@ -24,18 +36,19 @@ PHLWINDOW CWindow::create(SP<CXWaylandSurface> surface) {
    pWindow->m_pSelf  = pWindow;
    pWindow->m_bIsX11 = true;

-    pWindow->m_vRealPosition.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_vRealSize.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_fBorderFadeAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
-    pWindow->m_fBorderAngleAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("borderangle"), pWindow, AVARDAMAGE_BORDER);
-    pWindow->m_fAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_fActiveInactiveAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_cRealShadowColor.create(g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
-    pWindow->m_fDimPercent.create(g_pConfigManager->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_fMovingToWorkspaceAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pWindow->m_vRealPosition, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pWindow->m_vRealSize, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fBorderFadeAnimationProgress, g_pConfigManager->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fBorderAngleAnimationProgress, g_pConfigManager->getAnimationPropertyConfig("borderangle"), pWindow, AVARDAMAGE_BORDER);
+    g_pAnimationManager->createAnimation(1.f, pWindow->m_fAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->m_fActiveInactiveAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(CHyprColor(), pWindow->m_cRealShadowColor, g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fDimPercent, g_pConfigManager->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingToWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingFromWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);

-    pWindow->addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(pWindow));
-    pWindow->addWindowDeco(std::make_unique<CHyprBorderDecoration>(pWindow));
+    pWindow->addWindowDeco(makeUnique<CHyprDropShadowDecoration>(pWindow));
+    pWindow->addWindowDeco(makeUnique<CHyprBorderDecoration>(pWindow));

    return pWindow;
 }
@@ -46,18 +59,19 @@ PHLWINDOW CWindow::create(SP<CXDGSurfaceResource> resource) {
    pWindow->m_pSelf           = pWindow;
    resource->toplevel->window = pWindow;

-    pWindow->m_vRealPosition.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_vRealSize.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_fBorderFadeAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
-    pWindow->m_fBorderAngleAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("borderangle"), pWindow, AVARDAMAGE_BORDER);
-    pWindow->m_fAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_fActiveInactiveAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_cRealShadowColor.create(g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
-    pWindow->m_fDimPercent.create(g_pConfigManager->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
-    pWindow->m_fMovingToWorkspaceAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pWindow->m_vRealPosition, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pWindow->m_vRealSize, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fBorderFadeAnimationProgress, g_pConfigManager->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fBorderAngleAnimationProgress, g_pConfigManager->getAnimationPropertyConfig("borderangle"), pWindow, AVARDAMAGE_BORDER);
+    g_pAnimationManager->createAnimation(1.f, pWindow->m_fAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->m_fActiveInactiveAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(CHyprColor(), pWindow->m_cRealShadowColor, g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fDimPercent, g_pConfigManager->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingToWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingFromWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);

-    pWindow->addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(pWindow));
-    pWindow->addWindowDeco(std::make_unique<CHyprBorderDecoration>(pWindow));
+    pWindow->addWindowDeco(makeUnique<CHyprDropShadowDecoration>(pWindow));
+    pWindow->addWindowDeco(makeUnique<CHyprBorderDecoration>(pWindow));

    pWindow->m_pWLSurface->assign(pWindow->m_pXDGSurface->surface.lock(), pWindow);

@@ -116,8 +130,8 @@ SBoxExtents CWindow::getFullWindowExtents() {

    if (m_sWindowData.dimAround.valueOrDefault()) {
        if (const auto PMONITOR = m_pMonitor.lock(); PMONITOR)
-            return {{m_vRealPosition.value().x - PMONITOR->vecPosition.x, m_vRealPosition.value().y - PMONITOR->vecPosition.y},
-                    {PMONITOR->vecSize.x - (m_vRealPosition.value().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_vRealPosition.value().y - PMONITOR->vecPosition.y)}};
+            return {{m_vRealPosition->value().x - PMONITOR->vecPosition.x, m_vRealPosition->value().y - PMONITOR->vecPosition.y},
+                    {PMONITOR->vecSize.x - (m_vRealPosition->value().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_vRealPosition->value().y - PMONITOR->vecPosition.y)}};
    }

    SBoxExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
@@ -140,7 +154,7 @@ SBoxExtents CWindow::getFullWindowExtents() {
        CBox surfaceExtents = {0, 0, 0, 0};
        // TODO: this could be better, perhaps make a getFullWindowRegion?
        m_pPopupHead->breadthfirst(
-            [](CPopup* popup, void* data) {
+            [](WP<CPopup> popup, void* data) {
                if (!popup->m_pWLSurface || !popup->m_pWLSurface->resource())
                    return;

@@ -181,8 +195,8 @@ CBox CWindow::getFullWindowBoundingBox() {

    auto maxExtents = getFullWindowExtents();

-    CBox finalBox = {m_vRealPosition.value().x - maxExtents.topLeft.x, m_vRealPosition.value().y - maxExtents.topLeft.y,
-                     m_vRealSize.value().x + maxExtents.topLeft.x + maxExtents.bottomRight.x, m_vRealSize.value().y + maxExtents.topLeft.y + maxExtents.bottomRight.y};
+    CBox finalBox = {m_vRealPosition->value().x - maxExtents.topLeft.x, m_vRealPosition->value().y - maxExtents.topLeft.y,
+                     m_vRealSize->value().x + maxExtents.topLeft.x + maxExtents.bottomRight.x, m_vRealSize->value().y + maxExtents.topLeft.y + maxExtents.bottomRight.y};

    return finalBox;
 }
@@ -236,7 +250,7 @@ CBox CWindow::getWindowBoxUnified(uint64_t properties) {
    if (properties & FULL_EXTENTS)
        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationExtents(m_pSelf.lock(), false));

-    CBox box = {m_vRealPosition.value().x, m_vRealPosition.value().y, m_vRealSize.value().x, m_vRealSize.value().y};
+    CBox box = {m_vRealPosition->value().x, m_vRealPosition->value().y, m_vRealSize->value().x, m_vRealSize->value().y};
    box.addExtents(EXTENTS);

    return box;
@@ -268,6 +282,8 @@ void CWindow::updateWindowDecos() {

    // make a copy because updateWindow can remove decos.
    std::vector<IHyprWindowDecoration*> decos;
+    // reserve to avoid reallocations
+    decos.reserve(m_dWindowDecorations.size());

    for (auto const& wd : m_dWindowDecorations) {
        decos.push_back(wd.get());
@@ -280,7 +296,7 @@ void CWindow::updateWindowDecos() {
    }
 }

-void CWindow::addWindowDeco(std::unique_ptr<IHyprWindowDecoration> deco) {
+void CWindow::addWindowDeco(UP<IHyprWindowDecoration> deco) {
    m_dWindowDecorations.emplace_back(std::move(deco));
    g_pDecorationPositioner->forceRecalcFor(m_pSelf.lock());
    updateWindowDecos();
@@ -406,10 +422,12 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {

    const auto  OLDWORKSPACE = m_pWorkspace;

-    m_iMonitorMovedFrom = OLDWORKSPACE ? OLDWORKSPACE->monitorID() : -1;
-    m_fMovingToWorkspaceAlpha.setValueAndWarp(1.F);
-    m_fMovingToWorkspaceAlpha = 0.F;
-    m_fMovingToWorkspaceAlpha.setCallbackOnEnd([this](void* thisptr) { m_iMonitorMovedFrom = -1; });
+    if (OLDWORKSPACE->isVisible()) {
+        m_fMovingToWorkspaceAlpha->setValueAndWarp(1.F);
+        *m_fMovingToWorkspaceAlpha = 0.F;
+        m_fMovingToWorkspaceAlpha->setCallbackOnEnd([this](auto) { m_iMonitorMovedFrom = -1; });
+        m_iMonitorMovedFrom = OLDWORKSPACE ? OLDWORKSPACE->monitorID() : -1;
+    }

    m_pWorkspace = pWorkspace;

@@ -437,7 +455,7 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
    }

    // update xwayland coords
-    g_pXWaylandManager->setWindowSize(m_pSelf.lock(), m_vRealSize.value());
+    sendWindowSize(m_vRealSize->goal());

    if (OLDWORKSPACE && g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE->m_iID) && OLDWORKSPACE->getWindows() == 0 && *PCLOSEONLASTSPECIAL) {
        if (const auto PMONITOR = OLDWORKSPACE->m_pMonitor.lock(); PMONITOR)
@@ -473,19 +491,6 @@ PHLWINDOW CWindow::x11TransientFor() {
    return nullptr;
 }

-void CWindow::removeDecorationByType(eDecorationType type) {
-    for (auto const& wd : m_dWindowDecorations) {
-        if (wd->getDecorationType() == type)
-            m_vDecosToRemove.push_back(wd.get());
-    }
-
-    updateWindowDecos();
-}
-
-void unregisterVar(void* ptr) {
-    ((CBaseAnimatedVariable*)ptr)->unregister();
-}
-
 void CWindow::onUnmap() {
    static auto PCLOSEONLASTSPECIAL = CConfigValue<Hyprlang::INT>("misc:close_special_on_empty");
    static auto PINITIALWSTRACKING  = CConfigValue<Hyprlang::INT>("misc:initial_workspace_tracking");
@@ -504,18 +509,6 @@ void CWindow::onUnmap() {

    m_iLastWorkspace = m_pWorkspace->m_iID;

-    m_vRealPosition.setCallbackOnEnd(unregisterVar);
-    m_vRealSize.setCallbackOnEnd(unregisterVar);
-    m_fBorderFadeAnimationProgress.setCallbackOnEnd(unregisterVar);
-    m_fBorderAngleAnimationProgress.setCallbackOnEnd(unregisterVar);
-    m_fActiveInactiveAlpha.setCallbackOnEnd(unregisterVar);
-    m_fAlpha.setCallbackOnEnd(unregisterVar);
-    m_cRealShadowColor.setCallbackOnEnd(unregisterVar);
-    m_fDimPercent.setCallbackOnEnd(unregisterVar);
-    m_fMovingToWorkspaceAlpha.setCallbackOnEnd(unregisterVar);
-
-    m_vRealSize.setCallbackOnBegin(nullptr);
-
    std::erase_if(g_pCompositor->m_vWindowFocusHistory, [&](const auto& other) { return other.expired() || other.lock().get() == this; });

    if (*PCLOSEONLASTSPECIAL && m_pWorkspace && m_pWorkspace->getWindows() == 0 && onSpecialWorkspace()) {
@@ -547,30 +540,26 @@ void CWindow::onUnmap() {

 void CWindow::onMap() {
    // JIC, reset the callbacks. If any are set, we'll make sure they are cleared so we don't accidentally unset them. (In case a window got remapped)
-    m_vRealPosition.resetAllCallbacks();
-    m_vRealSize.resetAllCallbacks();
-    m_fBorderFadeAnimationProgress.resetAllCallbacks();
-    m_fBorderAngleAnimationProgress.resetAllCallbacks();
-    m_fActiveInactiveAlpha.resetAllCallbacks();
-    m_fAlpha.resetAllCallbacks();
-    m_cRealShadowColor.resetAllCallbacks();
-    m_fDimPercent.resetAllCallbacks();
-    m_fMovingToWorkspaceAlpha.resetAllCallbacks();
+    m_vRealPosition->resetAllCallbacks();
+    m_vRealSize->resetAllCallbacks();
+    m_fBorderFadeAnimationProgress->resetAllCallbacks();
+    m_fBorderAngleAnimationProgress->resetAllCallbacks();
+    m_fActiveInactiveAlpha->resetAllCallbacks();
+    m_fAlpha->resetAllCallbacks();
+    m_cRealShadowColor->resetAllCallbacks();
+    m_fDimPercent->resetAllCallbacks();
+    m_fMovingToWorkspaceAlpha->resetAllCallbacks();
+    m_fMovingFromWorkspaceAlpha->resetAllCallbacks();

-    m_vRealPosition.registerVar();
-    m_vRealSize.registerVar();
-    m_fBorderFadeAnimationProgress.registerVar();
-    m_fBorderAngleAnimationProgress.registerVar();
-    m_fActiveInactiveAlpha.registerVar();
-    m_fAlpha.registerVar();
-    m_cRealShadowColor.registerVar();
-    m_fDimPercent.registerVar();
-    m_fMovingToWorkspaceAlpha.registerVar();
+    m_fMovingFromWorkspaceAlpha->setValueAndWarp(1.F);

-    m_fBorderAngleAnimationProgress.setCallbackOnEnd([&](void* ptr) { onBorderAngleAnimEnd(ptr); }, false);
+    if (m_fBorderAngleAnimationProgress->enabled()) {
+        m_fBorderAngleAnimationProgress->setValueAndWarp(0.f);
+        m_fBorderAngleAnimationProgress->setCallbackOnEnd([&](WP<CBaseAnimatedVariable> p) { onBorderAngleAnimEnd(p); }, false);
+        *m_fBorderAngleAnimationProgress = 1.f;
+    }

-    m_fBorderAngleAnimationProgress.setValueAndWarp(0.f);
-    m_fBorderAngleAnimationProgress = 1.f;
+    m_fMovingFromWorkspaceAlpha->setValueAndWarp(1.F);

    g_pCompositor->m_vWindowFocusHistory.push_back(m_pSelf);

@@ -582,24 +571,26 @@ void CWindow::onMap() {
    if (m_bIsX11)
        return;

-    m_pSubsurfaceHead = std::make_unique<CSubsurface>(m_pSelf.lock());
-    m_pPopupHead      = std::make_unique<CPopup>(m_pSelf.lock());
+    m_pSubsurfaceHead = CSubsurface::create(m_pSelf.lock());
+    m_pPopupHead      = CPopup::create(m_pSelf.lock());
 }

-void CWindow::onBorderAngleAnimEnd(void* ptr) {
-    const auto        PANIMVAR = (CAnimatedVariable<float>*)ptr;
-
-    const std::string STYLE = PANIMVAR->getConfig()->pValues->internalStyle;
-
-    if (STYLE != "loop" || !PANIMVAR->getConfig()->pValues->internalEnabled)
+void CWindow::onBorderAngleAnimEnd(WP<CBaseAnimatedVariable> pav) {
+    const auto PAV = pav.lock();
+    if (!PAV)
        return;

+    if (PAV->getStyle() != "loop" || !PAV->enabled())
+        return;
+
+    const auto PANIMVAR = dynamic_cast<CAnimatedVariable<float>*>(PAV.get());
+
    PANIMVAR->setCallbackOnEnd(nullptr); // we remove the callback here because otherwise setvalueandwarp will recurse this

    PANIMVAR->setValueAndWarp(0);
    *PANIMVAR = 1.f;

-    PANIMVAR->setCallbackOnEnd([&](void* ptr) { onBorderAngleAnimEnd(ptr); }, false);
+    PANIMVAR->setCallbackOnEnd([&](WP<CBaseAnimatedVariable> pav) { onBorderAngleAnimEnd(pav); }, false);
 }

 void CWindow::setHidden(bool hidden) {
@@ -826,27 +817,28 @@ void CWindow::updateDynamicRules() {
 // it is assumed that the point is within the real window box (m_vRealPosition, m_vRealSize)
 // otherwise behaviour is undefined
 bool CWindow::isInCurvedCorner(double x, double y) {
-    const int ROUNDING = rounding();
+    const int ROUNDING      = rounding();
+    const int ROUNDINGPOWER = roundingPower();
    if (getRealBorderSize() >= ROUNDING)
        return false;

    // (x0, y0), (x0, y1), ... are the center point of rounding at each corner
-    double x0 = m_vRealPosition.value().x + ROUNDING;
-    double y0 = m_vRealPosition.value().y + ROUNDING;
-    double x1 = m_vRealPosition.value().x + m_vRealSize.value().x - ROUNDING;
-    double y1 = m_vRealPosition.value().y + m_vRealSize.value().y - ROUNDING;
+    double x0 = m_vRealPosition->value().x + ROUNDING;
+    double y0 = m_vRealPosition->value().y + ROUNDING;
+    double x1 = m_vRealPosition->value().x + m_vRealSize->value().x - ROUNDING;
+    double y1 = m_vRealPosition->value().y + m_vRealSize->value().y - ROUNDING;

    if (x < x0 && y < y0) {
-        return Vector2D{x0, y0}.distance(Vector2D{x, y}) > (double)ROUNDING;
+        return std::pow(x0 - x, ROUNDINGPOWER) + std::pow(y0 - y, ROUNDINGPOWER) > std::pow((double)ROUNDING, ROUNDINGPOWER);
    }
    if (x > x1 && y < y0) {
-        return Vector2D{x1, y0}.distance(Vector2D{x, y}) > (double)ROUNDING;
+        return std::pow(x - x1, ROUNDINGPOWER) + std::pow(y0 - y, ROUNDINGPOWER) > std::pow((double)ROUNDING, ROUNDINGPOWER);
    }
    if (x < x0 && y > y1) {
-        return Vector2D{x0, y1}.distance(Vector2D{x, y}) > (double)ROUNDING;
+        return std::pow(x0 - x, ROUNDINGPOWER) + std::pow(y - y1, ROUNDINGPOWER) > std::pow((double)ROUNDING, ROUNDINGPOWER);
    }
    if (x > x1 && y > y1) {
-        return Vector2D{x1, y1}.distance(Vector2D{x, y}) > (double)ROUNDING;
+        return std::pow(x - x1, ROUNDINGPOWER) + std::pow(y - y1, ROUNDINGPOWER) > std::pow((double)ROUNDING, ROUNDINGPOWER);
    }

    return false;
@@ -857,7 +849,7 @@ bool CWindow::hasPopupAt(const Vector2D& pos) {
    if (m_bIsX11)
        return false;

-    CPopup* popup = m_pPopupHead->at(pos);
+    auto popup = m_pPopupHead->at(pos);

    return popup && popup->m_pWLSurface->resource();
 }
@@ -882,7 +874,7 @@ void CWindow::createGroup() {
        m_sGroupData.locked      = false;
        m_sGroupData.deny        = false;

-        addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(m_pSelf.lock()));
+        addWindowDeco(makeUnique<CHyprGroupBarDecoration>(m_pSelf.lock()));

        if (m_pWorkspace) {
            m_pWorkspace->updateWindows();
@@ -1028,22 +1020,22 @@ void CWindow::setGroupCurrent(PHLWINDOW pWindow) {
    const auto WORKSPACE  = PCURRENT->m_pWorkspace;
    const auto MODE       = PCURRENT->m_sFullscreenState.internal;

-    const auto PWINDOWSIZE = PCURRENT->m_vRealSize.goal();
-    const auto PWINDOWPOS  = PCURRENT->m_vRealPosition.goal();
-
    const auto CURRENTISFOCUS = PCURRENT == g_pCompositor->m_pLastWindow.lock();

    if (FULLSCREEN)
        g_pCompositor->setWindowFullscreenInternal(PCURRENT, FSMODE_NONE);

+    const auto PWINDOWSIZE = PCURRENT->m_vRealSize->goal();
+    const auto PWINDOWPOS  = PCURRENT->m_vRealPosition->goal();
+
    PCURRENT->setHidden(true);
    pWindow->setHidden(false); // can remove m_pLastWindow

    g_pLayoutManager->getCurrentLayout()->replaceWindowDataWith(PCURRENT, pWindow);

    if (PCURRENT->m_bIsFloating) {
-        pWindow->m_vRealPosition.setValueAndWarp(PWINDOWPOS);
-        pWindow->m_vRealSize.setValueAndWarp(PWINDOWSIZE);
+        pWindow->m_vRealPosition->setValueAndWarp(PWINDOWPOS);
+        pWindow->m_vRealSize->setValueAndWarp(PWINDOWSIZE);
    }

    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
@@ -1064,7 +1056,7 @@ void CWindow::insertWindowToGroup(PHLWINDOW pWindow) {
    const auto ENDAT   = m_sGroupData.pNextWindow.lock();

    if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
-        pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow));
+        pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));

    if (!pWindow->m_sGroupData.pNextWindow.lock()) {
        BEGINAT->m_sGroupData.pNextWindow = pWindow;
@@ -1125,22 +1117,22 @@ void CWindow::updateGroupOutputs() {
        curr->m_pMonitor = m_pMonitor;
        curr->moveToWorkspace(WS);

-        curr->m_vRealPosition = m_vRealPosition.goal();
-        curr->m_vRealSize     = m_vRealSize.goal();
+        *curr->m_vRealPosition = m_vRealPosition->goal();
+        *curr->m_vRealSize     = m_vRealSize->goal();

        curr = curr->m_sGroupData.pNextWindow.lock();
    }
 }

 Vector2D CWindow::middle() {
-    return m_vRealPosition.goal() + m_vRealSize.goal() / 2.f;
+    return m_vRealPosition->goal() + m_vRealSize->goal() / 2.f;
 }

 bool CWindow::opaque() {
-    if (m_fAlpha.value() != 1.f || m_fActiveInactiveAlpha.value() != 1.f)
+    if (m_fAlpha->value() != 1.f || m_fActiveInactiveAlpha->value() != 1.f)
        return false;

-    if (m_vRealSize.goal().floor() != m_vReportedSize)
+    if (m_vRealSize->goal().floor() != m_vReportedSize)
        return false;

    const auto PWORKSPACE = m_pWorkspace;
@@ -1148,7 +1140,7 @@ bool CWindow::opaque() {
    if (m_pWLSurface->small() && !m_pWLSurface->m_bFillIgnoreSmall)
        return false;

-    if (PWORKSPACE->m_fAlpha.value() != 1.f)
+    if (PWORKSPACE->m_fAlpha->value() != 1.f)
        return false;

    if (m_bIsX11 && m_pXWaylandSurface && m_pXWaylandSurface->surface && m_pXWaylandSurface->surface->current.texture)
@@ -1166,13 +1158,21 @@ bool CWindow::opaque() {
 }

 float CWindow::rounding() {
-    static auto PROUNDING = CConfigValue<Hyprlang::INT>("decoration:rounding");
+    static auto PROUNDING      = CConfigValue<Hyprlang::INT>("decoration:rounding");
+    static auto PROUNDINGPOWER = CConfigValue<Hyprlang::FLOAT>("decoration:rounding_power");

-    float       rounding = m_sWindowData.rounding.valueOr(*PROUNDING);
+    float       roundingPower = m_sWindowData.roundingPower.valueOr(*PROUNDINGPOWER);
+    float       rounding      = m_sWindowData.rounding.valueOr(*PROUNDING) * (roundingPower / 2.0); /* Make perceived roundness consistent. */

    return m_sWindowData.noRounding.valueOrDefault() ? 0 : rounding;
 }

+float CWindow::roundingPower() {
+    static auto PROUNDINGPOWER = CConfigValue<Hyprlang::FLOAT>("decoration:rounding_power");
+
+    return m_sWindowData.roundingPower.valueOr(*PROUNDINGPOWER);
+}
+
 void CWindow::updateWindowData() {
    const auto PWORKSPACE    = m_pWorkspace;
    const auto WORKSPACERULE = PWORKSPACE ? g_pConfigManager->getWorkspaceRuleFor(PWORKSPACE) : SWorkspaceRule{};
@@ -1230,15 +1230,13 @@ void CWindow::setSuspended(bool suspend) {
 }

 bool CWindow::visibleOnMonitor(PHLMONITOR pMonitor) {
-    CBox wbox = {m_vRealPosition.value(), m_vRealSize.value()};
+    CBox wbox = {m_vRealPosition->value(), m_vRealSize->value()};

    return !wbox.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty();
 }

 void CWindow::setAnimationsToMove() {
-    auto* const PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
-    m_vRealPosition.setConfig(PANIMCFG);
-    m_vRealSize.setConfig(PANIMCFG);
+    m_vRealPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsMove"));
    m_bAnimatingIn = false;
 }

@@ -1259,16 +1257,16 @@ void CWindow::onWorkspaceAnimUpdate() {
        return;

    const auto WINBB = getFullWindowBoundingBox();
-    if (PWORKSPACE->m_vRenderOffset.value().x != 0) {
-        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.value().x / PWSMON->vecSize.x;
+    if (PWORKSPACE->m_vRenderOffset->value().x != 0) {
+        const auto PROGRESS = PWORKSPACE->m_vRenderOffset->value().x / PWSMON->vecSize.x;

        if (WINBB.x < PWSMON->vecPosition.x)
            offset.x += (PWSMON->vecPosition.x - WINBB.x) * PROGRESS;

        if (WINBB.x + WINBB.width > PWSMON->vecPosition.x + PWSMON->vecSize.x)
            offset.x += (WINBB.x + WINBB.width - PWSMON->vecPosition.x - PWSMON->vecSize.x) * PROGRESS;
-    } else if (PWORKSPACE->m_vRenderOffset.value().y != 0) {
-        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.value().y / PWSMON->vecSize.y;
+    } else if (PWORKSPACE->m_vRenderOffset->value().y != 0) {
+        const auto PROGRESS = PWORKSPACE->m_vRenderOffset->value().y / PWSMON->vecSize.y;

        if (WINBB.y < PWSMON->vecPosition.y)
            offset.y += (PWSMON->vecPosition.y - WINBB.y) * PROGRESS;
@@ -1280,12 +1278,20 @@ void CWindow::onWorkspaceAnimUpdate() {
    m_vFloatingOffset = offset;
 }

+void CWindow::onFocusAnimUpdate() {
+    // borderangle once
+    if (m_fBorderAngleAnimationProgress->enabled() && !m_fBorderAngleAnimationProgress->isBeingAnimated()) {
+        m_fBorderAngleAnimationProgress->setValueAndWarp(0.f);
+        *m_fBorderAngleAnimationProgress = 1.f;
+    }
+}
+
 int CWindow::popupsCount() {
    if (m_bIsX11)
        return 0;

    int no = -1;
-    m_pPopupHead->breadthfirst([](CPopup* p, void* d) { *((int*)d) += 1; }, &no);
+    m_pPopupHead->breadthfirst([](WP<CPopup> p, void* d) { *((int*)d) += 1; }, &no);
    return no;
 }

@@ -1299,13 +1305,13 @@ int CWindow::surfacesCount() {
 }

 void CWindow::clampWindowSize(const std::optional<Vector2D> minSize, const std::optional<Vector2D> maxSize) {
-    const Vector2D REALSIZE = m_vRealSize.goal();
+    const Vector2D REALSIZE = m_vRealSize->goal();
    const Vector2D NEWSIZE  = REALSIZE.clamp(minSize.value_or(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), maxSize.value_or(Vector2D{INFINITY, INFINITY}));
    const Vector2D DELTA    = REALSIZE - NEWSIZE;

-    m_vRealPosition = m_vRealPosition.goal() + DELTA / 2.0;
-    m_vRealSize     = NEWSIZE;
-    g_pXWaylandManager->setWindowSize(m_pSelf.lock(), NEWSIZE);
+    *m_vRealPosition = m_vRealPosition->goal() + DELTA / 2.0;
+    *m_vRealSize     = NEWSIZE;
+    sendWindowSize(NEWSIZE);
 }

 bool CWindow::isFullscreen() {
@@ -1397,15 +1403,26 @@ void CWindow::activate(bool force) {
 }

 void CWindow::onUpdateState() {
-    std::optional<bool> requestsFS = m_pXDGSurface ? m_pXDGSurface->toplevel->state.requestsFullscreen : m_pXWaylandSurface->state.requestsFullscreen;
-    std::optional<bool> requestsMX = m_pXDGSurface ? m_pXDGSurface->toplevel->state.requestsMaximize : m_pXWaylandSurface->state.requestsMaximize;
+    std::optional<bool>      requestsFS = m_pXDGSurface ? m_pXDGSurface->toplevel->state.requestsFullscreen : m_pXWaylandSurface->state.requestsFullscreen;
+    std::optional<MONITORID> requestsID = m_pXDGSurface ? m_pXDGSurface->toplevel->state.requestsFullscreenMonitor : MONITOR_INVALID;
+    std::optional<bool>      requestsMX = m_pXDGSurface ? m_pXDGSurface->toplevel->state.requestsMaximize : m_pXWaylandSurface->state.requestsMaximize;

    if (requestsFS.has_value() && !(m_eSuppressedEvents & SUPPRESS_FULLSCREEN)) {
-        bool fs = requestsFS.value();
-        if (m_bIsMapped) {
-            g_pCompositor->changeWindowFullscreenModeClient(m_pSelf.lock(), FSMODE_FULLSCREEN, requestsFS.value());
+        if (requestsID.has_value() && (requestsID.value() != MONITOR_INVALID) && !(m_eSuppressedEvents & SUPPRESS_FULLSCREEN_OUTPUT)) {
+            if (m_bIsMapped) {
+                const auto monitor = g_pCompositor->getMonitorFromID(requestsID.value());
+                g_pCompositor->moveWindowToWorkspaceSafe(m_pSelf.lock(), monitor->activeWorkspace);
+                g_pCompositor->setActiveMonitor(monitor);
+            }
+
+            if (!m_bIsMapped)
+                m_iWantsInitialFullscreenMonitor = requestsID.value();
        }

+        bool fs = requestsFS.value();
+        if (m_bIsMapped)
+            g_pCompositor->changeWindowFullscreenModeClient(m_pSelf.lock(), FSMODE_FULLSCREEN, requestsFS.value());
+
        if (!m_bIsMapped)
            m_bWantsInitialFullscreen = fs;
    }
@@ -1518,7 +1535,7 @@ void CWindow::onX11Configure(CBox box) {
    g_pHyprRenderer->damageWindow(m_pSelf.lock());

    if (!m_bIsFloating || isFullscreen() || g_pInputManager->currentlyDraggedWindow == m_pSelf) {
-        g_pXWaylandManager->setWindowSize(m_pSelf.lock(), m_vRealSize.goal(), true);
+        sendWindowSize(m_vRealSize->goal(), true);
        g_pInputManager->refocus();
        g_pHyprRenderer->damageWindow(m_pSelf.lock());
        return;
@@ -1531,21 +1548,21 @@ void CWindow::onX11Configure(CBox box) {

    const auto LOGICALPOS = g_pXWaylandManager->xwaylandToWaylandCoords(box.pos());

-    m_vRealPosition.setValueAndWarp(LOGICALPOS);
-    m_vRealSize.setValueAndWarp(box.size());
+    m_vRealPosition->setValueAndWarp(LOGICALPOS);
+    m_vRealSize->setValueAndWarp(box.size());

    static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
    if (*PXWLFORCESCALEZERO) {
        if (const auto PMONITOR = m_pMonitor.lock(); PMONITOR) {
-            m_vRealSize.setValueAndWarp(m_vRealSize.goal() / PMONITOR->scale);
+            m_vRealSize->setValueAndWarp(m_vRealSize->goal() / PMONITOR->scale);
            m_fX11SurfaceScaledBy = PMONITOR->scale;
        }
    }

-    m_vPosition = m_vRealPosition.value();
-    m_vSize     = m_vRealSize.value();
+    m_vPosition = m_vRealPosition->goal();
+    m_vSize     = m_vRealSize->goal();

-    m_pXWaylandSurface->configure(box);
+    sendWindowSize(box.size(), true);

    m_vPendingReportedSize = box.size();
    m_vReportedSize        = box.size();
@@ -1555,7 +1572,7 @@ void CWindow::onX11Configure(CBox box) {
    if (!m_pWorkspace || !m_pWorkspace->isVisible())
        return; // further things are only for visible windows

-    m_pWorkspace = g_pCompositor->getMonitorFromVector(m_vRealPosition.value() + m_vRealSize.value() / 2.f)->activeWorkspace;
+    m_pWorkspace = g_pCompositor->getMonitorFromVector(m_vRealPosition->goal() + m_vRealSize->goal() / 2.f)->activeWorkspace;

    g_pCompositor->changeWindowZOrder(m_pSelf.lock(), true);

@@ -1675,3 +1692,35 @@ Vector2D CWindow::requestedMaxSize() {

    return maxSize;
 }
+
+void CWindow::sendWindowSize(Vector2D size, bool force, std::optional<Vector2D> overridePos) {
+    static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
+    const auto  PMONITOR           = m_pMonitor.lock();
+
+    size = size.clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
+
+    // calculate pos
+    // TODO: this should be decoupled from setWindowSize IMO
+    Vector2D windowPos = overridePos.value_or(m_vRealPosition->goal());
+
+    if (m_bIsX11 && PMONITOR) {
+        windowPos = g_pXWaylandManager->waylandToXWaylandCoords(windowPos);
+        if (*PXWLFORCESCALEZERO)
+            size *= PMONITOR->scale;
+    }
+
+    if (!force && m_vPendingReportedSize == size && (windowPos == m_vReportedPosition || !m_bIsX11))
+        return;
+
+    m_vReportedPosition    = windowPos;
+    m_vPendingReportedSize = size;
+    m_fX11SurfaceScaledBy  = 1.0f;
+
+    if (*PXWLFORCESCALEZERO && m_bIsX11 && PMONITOR)
+        m_fX11SurfaceScaledBy = PMONITOR->scale;
+
+    if (m_bIsX11 && m_pXWaylandSurface)
+        m_pXWaylandSurface->configure({windowPos, size});
+    else if (m_pXDGSurface && m_pXDGSurface->toplevel)
+        m_vPendingSizeAcks.emplace_back(m_pXDGSurface->toplevel->setSize(size), size.floor());
+}
--- a/src/desktop/Window.hpp
+++ b/src/desktop/Window.hpp
@@ -2,9 +2,9 @@

 #include <vector>
 #include <string>
+#include <optional>

 #include "../config/ConfigDataValues.hpp"
-#include "../defines.hpp"
 #include "../helpers/AnimatedVariable.hpp"
 #include "../helpers/math/Math.hpp"
 #include "../helpers/signal/Signal.hpp"
@@ -12,6 +12,7 @@
 #include "../macros.hpp"
 #include "../managers/XWaylandManager.hpp"
 #include "../render/decorations/IHyprWindowDecoration.hpp"
+#include "../render/Transformer.hpp"
 #include "DesktopTypes.hpp"
 #include "Popup.hpp"
 #include "Subsurface.hpp"
@@ -57,6 +58,7 @@ enum eSuppressEvents : uint8_t {
    SUPPRESS_MAXIMIZE           = 1 << 1,
    SUPPRESS_ACTIVATE           = 1 << 2,
    SUPPRESS_ACTIVATE_FOCUSONLY = 1 << 3,
+    SUPPRESS_FULLSCREEN_OUTPUT  = 1 << 4,
 };

 class IWindowTransformer;
@@ -183,6 +185,7 @@ struct SWindowData {
    CWindowOverridableVar<bool>               renderUnfocused    = false;

    CWindowOverridableVar<int>                rounding;
+    CWindowOverridableVar<float>              roundingPower;
    CWindowOverridableVar<int>                borderSize;

    CWindowOverridableVar<float>              scrollMouse;
@@ -232,8 +235,8 @@ class CWindow {
    Vector2D m_vSize     = Vector2D(0, 0);

    // this is the real position and size used to draw the thing
-    CAnimatedVariable<Vector2D> m_vRealPosition;
-    CAnimatedVariable<Vector2D> m_vRealSize;
+    PHLANIMVAR<Vector2D> m_vRealPosition;
+    PHLANIMVAR<Vector2D> m_vRealSize;

    // for not spamming the protocols
    Vector2D                                     m_vReportedPosition;
@@ -287,29 +290,30 @@ class CWindow {
    bool m_bNoInitialFocus = false;

    // Fullscreen and Maximize
-    bool m_bWantsInitialFullscreen = false;
+    bool      m_bWantsInitialFullscreen        = false;
+    MONITORID m_iWantsInitialFullscreenMonitor = MONITOR_INVALID;

    // bitfield eSuppressEvents
    uint64_t m_eSuppressedEvents = SUPPRESS_NONE;

    // desktop components
-    std::unique_ptr<CSubsurface> m_pSubsurfaceHead;
-    std::unique_ptr<CPopup>      m_pPopupHead;
+    UP<CSubsurface> m_pSubsurfaceHead;
+    UP<CPopup>      m_pPopupHead;

    // Animated border
-    CGradientValueData       m_cRealBorderColor         = {0};
-    CGradientValueData       m_cRealBorderColorPrevious = {0};
-    CAnimatedVariable<float> m_fBorderFadeAnimationProgress;
-    CAnimatedVariable<float> m_fBorderAngleAnimationProgress;
+    CGradientValueData m_cRealBorderColor         = {0};
+    CGradientValueData m_cRealBorderColorPrevious = {0};
+    PHLANIMVAR<float>  m_fBorderFadeAnimationProgress;
+    PHLANIMVAR<float>  m_fBorderAngleAnimationProgress;

    // Fade in-out
-    CAnimatedVariable<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_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;

    // For pinned (sticky) windows
    bool m_bPinned = false;
@@ -325,27 +329,28 @@ class CWindow {

    // Window decorations
    // TODO: make this a SP.
-    std::vector<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations;
-    std::vector<IHyprWindowDecoration*>                 m_vDecosToRemove;
+    std::vector<UP<IHyprWindowDecoration>> m_dWindowDecorations;
+    std::vector<IHyprWindowDecoration*>    m_vDecosToRemove;

    // Special render data, rules, etc
    SWindowData m_sWindowData;

    // Transformers
-    std::vector<std::unique_ptr<IWindowTransformer>> m_vTransformers;
+    std::vector<UP<IWindowTransformer>> m_vTransformers;

    // for alpha
-    CAnimatedVariable<float> m_fActiveInactiveAlpha;
+    PHLANIMVAR<float> m_fActiveInactiveAlpha;
+    PHLANIMVAR<float> m_fMovingFromWorkspaceAlpha;

    // animated shadow color
-    CAnimatedVariable<CHyprColor> m_cRealShadowColor;
+    PHLANIMVAR<CHyprColor> m_cRealShadowColor;

    // animated tint
-    CAnimatedVariable<float> m_fDimPercent;
+    PHLANIMVAR<float> m_fDimPercent;

    // animate moving to an invisible workspace
-    int                      m_iMonitorMovedFrom = -1; // -1 means not moving
-    CAnimatedVariable<float> m_fMovingToWorkspaceAlpha;
+    int               m_iMonitorMovedFrom = -1; // -1 means not moving
+    PHLANIMVAR<float> m_fMovingToWorkspaceAlpha;

    // swallowing
    PHLWINDOWREF m_pSwallowed;
@@ -392,14 +397,13 @@ class CWindow {
    SBoxExtents            getFullWindowExtents();
    CBox                   getWindowBoxUnified(uint64_t props);
    CBox                   getWindowIdealBoundingBoxIgnoreReserved();
-    void                   addWindowDeco(std::unique_ptr<IHyprWindowDecoration> deco);
+    void                   addWindowDeco(UP<IHyprWindowDecoration> deco);
    void                   updateWindowDecos();
    void                   removeWindowDeco(IHyprWindowDecoration* deco);
    void                   uncacheWindowDecos();
    bool                   checkInputOnDecos(const eInputType, const Vector2D&, std::any = {});
    pid_t                  getPID();
    IHyprWindowDecoration* getDecorationByType(eDecorationType);
-    void                   removeDecorationByType(eDecorationType);
    void                   updateToplevel();
    void                   updateSurfaceScaleTransformDetails(bool force = false);
    void                   moveToWorkspace(PHLWORKSPACE);
@@ -414,6 +418,7 @@ class CWindow {
    Vector2D               middle();
    bool                   opaque();
    float                  rounding();
+    float                  roundingPower();
    bool                   canBeTorn();
    void                   setSuspended(bool suspend);
    bool                   visibleOnMonitor(PHLMONITOR pMonitor);
@@ -430,7 +435,7 @@ class CWindow {
    float                  getScrollTouchpad();
    void                   updateWindowData();
    void                   updateWindowData(const struct SWorkspaceRule&);
-    void                   onBorderAngleAnimEnd(void* ptr);
+    void                   onBorderAngleAnimEnd(WP<Hyprutils::Animation::CBaseAnimatedVariable> pav);
    bool                   isInCurvedCorner(double x, double y);
    bool                   hasPopupAt(const Vector2D& pos);
    int                    popupsCount();
@@ -450,6 +455,7 @@ class CWindow {
    void                   switchWithWindowInGroup(PHLWINDOW pWindow);
    void                   setAnimationsToMove();
    void                   onWorkspaceAnimUpdate();
+    void                   onFocusAnimUpdate();
    void                   onUpdateState();
    void                   onUpdateMeta();
    void                   onX11Configure(CBox box);
@@ -463,9 +469,10 @@ class CWindow {
    bool                   isModal();
    Vector2D               requestedMinSize();
    Vector2D               requestedMaxSize();
+    void                   sendWindowSize(Vector2D size, bool force = false, std::optional<Vector2D> overridePos = std::nullopt);

    CBox                   getWindowMainSurfaceBox() const {
-        return {m_vRealPosition.value().x, m_vRealPosition.value().y, m_vRealSize.value().x, m_vRealSize.value().y};
+        return {m_vRealPosition->value().x, m_vRealPosition->value().y, m_vRealSize->value().x, m_vRealSize->value().y};
    }

    // listeners
--- a/src/desktop/WindowRule.cpp
+++ b/src/desktop/WindowRule.cpp
@@ -1,14 +1,15 @@
 #include "WindowRule.hpp"
 #include <unordered_set>
 #include <algorithm>
+#include <re2/re2.h>
 #include "../config/ConfigManager.hpp"

 static const auto RULES = std::unordered_set<std::string>{
    "float", "fullscreen", "maximize", "noinitialfocus", "pin", "stayfocused", "tile", "renderunfocused",
 };
 static const auto RULES_PREFIX = std::unordered_set<std::string>{
-    "animation", "bordercolor", "bordersize", "center",   "fullscreenstate", "group",          "idleinhibit", "maxsize",       "minsize", "monitor",   "move", "opacity",
-    "plugin:",   "prop",        "pseudo",     "rounding", "scrollmouse",     "scrolltouchpad", "size",        "suppressevent", "tag",     "workspace", "xray",
+    "animation", "bordercolor", "bordersize", "center",   "fullscreenstate", "group",       "idleinhibit",    "maxsize", "minsize",       "monitor", "move",      "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) {
@@ -87,4 +88,4 @@ CWindowRule::CWindowRule(const std::string& rule, const std::string& value, bool
            ruleType = RULE_INVALID;
        }
    }
-}
+}
--- a/src/desktop/WindowRule.hpp
+++ b/src/desktop/WindowRule.hpp
@@ -2,6 +2,7 @@

 #include <string>
 #include <cstdint>
+#include "Rule.hpp"

 class CWindowRule {
  public:
@@ -57,4 +58,11 @@ class CWindowRule {
    std::string       szFullscreenState = ""; // empty means any
    std::string       szOnWorkspace     = ""; // empty means any
    std::string       szWorkspace       = ""; // empty means any
+
+    // precompiled regexes
+    CRuleRegexContainer rTitle;
+    CRuleRegexContainer rClass;
+    CRuleRegexContainer rInitialTitle;
+    CRuleRegexContainer rInitialClass;
+    CRuleRegexContainer rV1Regex;
 };
--- a/src/desktop/Workspace.cpp
+++ b/src/desktop/Workspace.cpp
@@ -1,7 +1,12 @@
 #include "Workspace.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
+#include "config/ConfigManager.hpp"
+#include "managers/AnimationManager.hpp"
+#include "../managers/EventManager.hpp"
+#include "../managers/HookSystemManager.hpp"

+#include <hyprutils/animation/AnimatedVariable.hpp>
 #include <hyprutils/string/String.hpp>
 using namespace Hyprutils::String;

@@ -19,16 +24,10 @@ CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, boo
 void CWorkspace::init(PHLWORKSPACE self) {
    m_pSelf = self;

-    m_vRenderOffset.create(m_bIsSpecialWorkspace ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspaceIn") :
-                                                   g_pConfigManager->getAnimationPropertyConfig("workspacesIn"),
-                           self, AVARDAMAGE_ENTIRE);
-    m_fAlpha.create(AVARTYPE_FLOAT,
-                    m_bIsSpecialWorkspace ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspaceIn") : g_pConfigManager->getAnimationPropertyConfig("workspacesIn"), self,
-                    AVARDAMAGE_ENTIRE);
-    m_fAlpha.setValueAndWarp(1.f);
-
-    m_vRenderOffset.registerVar();
-    m_fAlpha.registerVar();
+    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,
+                                         AVARDAMAGE_ENTIRE);

    const auto RULEFORTHIS = g_pConfigManager->getWorkspaceRuleFor(self);
    if (RULEFORTHIS.defaultName.has_value())
@@ -55,16 +54,11 @@ void CWorkspace::init(PHLWORKSPACE self) {
    EMIT_HOOK_EVENT("createWorkspace", this);
 }

-SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName(bool perMonitor) const {
-    if (perMonitor)
-        return m_sPrevWorkspacePerMonitor;
-
+SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const {
    return m_sPrevWorkspace;
 }

 CWorkspace::~CWorkspace() {
-    m_vRenderOffset.unregister();
-
    Debug::log(LOG, "Destroying workspace ID {}", m_iID);

    // check if g_pHookSystem and g_pEventManager exist, they might be destroyed as in when the compositor is closing.
@@ -82,15 +76,15 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
    if (!instant) {
        const std::string ANIMNAME = std::format("{}{}", m_bIsSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");

-        m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig(ANIMNAME);
-        m_vRenderOffset.m_pConfig = g_pConfigManager->getAnimationPropertyConfig(ANIMNAME);
+        m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
    }

-    const auto  ANIMSTYLE     = m_fAlpha.m_pConfig->pValues->internalStyle;
+    const auto  ANIMSTYLE     = m_fAlpha->getStyle();
    static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");

    // set floating windows offset callbacks
-    m_vRenderOffset.setUpdateCallback([&](void*) {
+    m_vRenderOffset->setUpdateCallback([&](auto) {
        for (auto const& w : g_pCompositor->m_vWindows) {
            if (!validMapped(w) || w->workspaceID() != m_iID)
                continue;
@@ -110,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_fAlpha->setValueAndWarp(1.f);
+        m_vRenderOffset->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_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);
            } 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_fAlpha->setValueAndWarp(1.f);
+                *m_fAlpha        = 0.f;
+                *m_vRenderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.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_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);
            } 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_fAlpha->setValueAndWarp(1.f);
+                *m_fAlpha        = 0.f;
+                *m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.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_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.

        if (in) {
-            m_fAlpha.setValueAndWarp(0.f);
-            m_fAlpha = 1.f;
+            m_fAlpha->setValueAndWarp(0.f);
+            *m_fAlpha = 1.f;
        } else {
-            m_fAlpha.setValueAndWarp(1.f);
-            m_fAlpha = 0.f;
+            m_fAlpha->setValueAndWarp(1.f);
+            *m_fAlpha = 0.f;
        }
    } else if (ANIMSTYLE == "slidevert") {
        // fallback is slide
        const auto PMONITOR  = m_pMonitor.lock();
        const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;

-        m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_fAlpha->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_vRenderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
+            *m_vRenderOffset = Vector2D(0, 0);
        } else {
-            m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
+            *m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
        }
    } else {
        // fallback is slide
        const auto PMONITOR  = m_pMonitor.lock();
        const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;

-        m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_fAlpha->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_vRenderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
+            *m_vRenderOffset = Vector2D(0, 0);
        } else {
-            m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
+            *m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
        }
    }

    if (m_bIsSpecialWorkspace) {
        // required for open/close animations
        if (in) {
-            m_fAlpha.setValueAndWarp(0.f);
-            m_fAlpha = 1.f;
+            m_fAlpha->setValueAndWarp(0.f);
+            *m_fAlpha = 1.f;
        } else {
-            m_fAlpha.setValueAndWarp(1.f);
-            m_fAlpha = 0.f;
+            m_fAlpha->setValueAndWarp(1.f);
+            *m_fAlpha = 0.f;
        }
    }

    if (instant) {
-        m_vRenderOffset.warp();
-        m_fAlpha.warp();
+        m_vRenderOffset->warp();
+        m_fAlpha->warp();
    }
 }

@@ -221,10 +215,7 @@ void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
    m_sPrevWorkspace.id   = prev->m_iID;
    m_sPrevWorkspace.name = prev->m_szName;

-    if (prev->m_pMonitor == m_pMonitor) {
-        m_sPrevWorkspacePerMonitor.id   = prev->m_iID;
-        m_sPrevWorkspacePerMonitor.name = prev->m_szName;
-    }
+    prev->m_pMonitor->addPrevWorkspaceID(prev->m_iID);
 }

 std::string CWorkspace::getConfigName() {
@@ -633,7 +624,7 @@ void CWorkspace::forceReportSizesToWindows() {
        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
            continue;

-        g_pXWaylandManager->setWindowSize(w, w->m_vRealSize.value(), true);
+        w->sendWindowSize(w->m_vRealSize->goal(), true);
    }
 }

--- a/src/desktop/Workspace.hpp
+++ b/src/desktop/Workspace.hpp
@@ -24,22 +24,19 @@ 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;
-    // Previous workspace ID and name is stored during a workspace change, allowing travel
-    // to the previous workspace.
-    SWorkspaceIDName m_sPrevWorkspace, m_sPrevWorkspacePerMonitor;
+    WORKSPACEID     m_iID    = WORKSPACE_INVALID;
+    std::string     m_szName = "";
+    PHLMONITORREF   m_pMonitor;

-    bool             m_bHasFullscreenWindow = false;
-    eFullscreenMode  m_efFullscreenMode     = FSMODE_NONE;
+    bool            m_bHasFullscreenWindow = false;
+    eFullscreenMode m_efFullscreenMode     = FSMODE_NONE;

-    wl_array         m_wlrCoordinateArr;
+    wl_array        m_wlrCoordinateArr;

    // for animations
-    CAnimatedVariable<Vector2D> m_vRenderOffset;
-    CAnimatedVariable<float>    m_fAlpha;
-    bool                        m_bForceRendering = false;
+    PHLANIMVAR<Vector2D> m_vRenderOffset;
+    PHLANIMVAR<float>    m_fAlpha;
+    bool                 m_bForceRendering = false;

    // allows damage to propagate.
    bool m_bVisible = false;
@@ -72,7 +69,7 @@ class CWorkspace {
    std::string      getConfigName();
    bool             matchesStaticSelector(const std::string& selector);
    void             markInert();
-    SWorkspaceIDName getPrevWorkspaceIDName(bool perMonitor) const;
+    SWorkspaceIDName getPrevWorkspaceIDName() const;
    void             updateWindowDecos();
    void             updateWindowData();
    int              getWindows(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
@@ -88,7 +85,10 @@ class CWorkspace {
    void             updateWindows();

  private:
-    void                 init(PHLWORKSPACE self);
+    void init(PHLWORKSPACE self);
+    // Previous workspace ID and name is stored during a workspace change, allowing travel
+    // to the previous workspace.
+    SWorkspaceIDName     m_sPrevWorkspace;

    SP<HOOK_CALLBACK_FN> m_pFocusedWindowHook;
    bool                 m_bInert = true;
--- a/src/devices/IKeyboard.cpp
+++ b/src/devices/IKeyboard.cpp
@@ -44,6 +44,10 @@ void IKeyboard::clearManuallyAllocd() {
    if (xkbKeymapFD >= 0)
        close(xkbKeymapFD);

+    if (xkbSymState)
+        xkb_state_unref(xkbSymState);
+
+    xkbSymState    = nullptr;
    xkbKeymap      = nullptr;
    xkbState       = nullptr;
    xkbStaticState = nullptr;
--- a/src/devices/Keyboard.cpp
+++ b/src/devices/Keyboard.cpp
@@ -1,6 +1,5 @@
 #include "Keyboard.hpp"
 #include "../defines.hpp"
-#include "../Compositor.hpp"

 #include <aquamarine/input/Input.hpp>

--- a/src/devices/VirtualPointer.cpp
+++ b/src/devices/VirtualPointer.cpp
@@ -11,7 +11,7 @@ SP<CVirtualPointer> CVirtualPointer::create(SP<CVirtualPointerV1Resource> resour
 }

 CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : pointer(resource) {
-    if (!resource->good())
+    if UNLIKELY (!resource->good())
        return;

    listeners.destroy = pointer->events.destroy.registerListener([this](std::any d) {
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -12,10 +12,17 @@
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/ToplevelExport.hpp"
 #include "../xwayland/XSurface.hpp"
+#include "managers/AnimationManager.hpp"
 #include "managers/PointerManager.hpp"
+#include "../desktop/LayerSurface.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/EventManager.hpp"
+#include "../managers/AnimationManager.hpp"

 #include <hyprutils/string/String.hpp>
 using namespace Hyprutils::String;
+using namespace Hyprutils::Animation;

 // ------------------------------------------------------------ //
 //  __          _______ _   _ _____   ______          _______   //
@@ -27,15 +34,17 @@ using namespace Hyprutils::String;
 //                                                              //
 // ------------------------------------------------------------ //

-void setAnimToMove(void* data) {
-    auto* const            PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
+static void setVector2DAnimToMove(WP<CBaseAnimatedVariable> pav) {
+    const auto PAV = pav.lock();
+    if (!PAV)
+        return;

-    CBaseAnimatedVariable* animvar = (CBaseAnimatedVariable*)data;
+    CAnimatedVariable<Vector2D>* animvar = dynamic_cast<CAnimatedVariable<Vector2D>*>(PAV.get());
+    animvar->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsMove"));

-    animvar->setConfig(PANIMCFG);
-
-    if (animvar->getWindow() && !animvar->getWindow()->m_vRealPosition.isBeingAnimated() && !animvar->getWindow()->m_vRealSize.isBeingAnimated())
-        animvar->getWindow()->m_bAnimatingIn = false;
+    const auto PHLWINDOW = animvar->m_Context.pWindow.lock();
+    if (PHLWINDOW)
+        PHLWINDOW->m_bAnimatingIn = false;
 }

 void Events::listener_mapWindow(void* owner, void* data) {
@@ -121,22 +130,13 @@ void Events::listener_mapWindow(void* owner, void* data) {

    PWINDOW->m_bX11ShouldntFocus = PWINDOW->m_bX11ShouldntFocus || (PWINDOW->m_bIsX11 && PWINDOW->isX11OverrideRedirect() && !PWINDOW->m_pXWaylandSurface->wantsFocus());

-    if (PWORKSPACE->m_bDefaultFloating)
-        PWINDOW->m_bIsFloating = true;
-
-    if (PWORKSPACE->m_bDefaultPseudo) {
-        PWINDOW->m_bIsPseudotiled = true;
-        CBox desiredGeometry      = {0};
-        g_pXWaylandManager->getGeometryForWindow(PWINDOW, &desiredGeometry);
-        PWINDOW->m_vPseudoSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
-    }
-
    // window rules
    PWINDOW->m_vMatchedRules = g_pConfigManager->getMatchingRules(PWINDOW, false);
    std::optional<eFullscreenMode>  requestedInternalFSMode, requestedClientFSMode;
    std::optional<SFullscreenState> requestedFSState;
    if (PWINDOW->m_bWantsInitialFullscreen || (PWINDOW->m_bIsX11 && PWINDOW->m_pXWaylandSurface->fullscreen))
        requestedClientFSMode = FSMODE_FULLSCREEN;
+    MONITORID requestedFSMonitor = PWINDOW->m_iWantsInitialFullscreenMonitor;

    for (auto const& r : PWINDOW->m_vMatchedRules) {
        switch (r->ruleType) {
@@ -171,8 +171,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                        PMONITOR = PMONITORFROMID;
                    }
                    PWINDOW->m_pWorkspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
+                    PWORKSPACE            = PWINDOW->m_pWorkspace;

                    Debug::log(LOG, "Rule monitor, applying to {:mw}", PWINDOW);
+                    requestedFSMonitor = MONITOR_INVALID;
                } catch (std::exception& e) { Debug::log(ERR, "Rule monitor failed, rule: {} -> {} | err: {}", r->szRule, r->szValue, e.what()); }
                break;
            }
@@ -180,11 +182,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                // check if it isnt unset
                const auto WORKSPACERQ = r->szRule.substr(r->szRule.find_first_of(' ') + 1);

-                if (WORKSPACERQ == "unset") {
+                if (WORKSPACERQ == "unset")
                    requestedWorkspace = "";
-                } else {
+                else
                    requestedWorkspace = WORKSPACERQ;
-                }

                const auto JUSTWORKSPACE = WORKSPACERQ.contains(' ') ? WORKSPACERQ.substr(0, WORKSPACERQ.find_first_of(' ')) : WORKSPACERQ;

@@ -192,6 +193,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                    requestedWorkspace = "";

                Debug::log(LOG, "Rule workspace matched by {}, {} applied.", PWINDOW, r->szValue);
+                requestedFSMonitor = MONITOR_INVALID;
                break;
            }
            case CWindowRule::RULE_FLOAT: {
@@ -233,6 +235,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                        PWINDOW->m_eSuppressedEvents |= SUPPRESS_ACTIVATE;
                    else if (vars[i] == "activatefocus")
                        PWINDOW->m_eSuppressedEvents |= SUPPRESS_ACTIVATE_FOCUSONLY;
+                    else if (vars[i] == "fullscreenoutput")
+                        PWINDOW->m_eSuppressedEvents |= SUPPRESS_FULLSCREEN_OUTPUT;
                    else
                        Debug::log(ERR, "Error while parsing suppressevent windowrule: unknown event type {}", vars[i]);
                }
@@ -343,10 +347,39 @@ void Events::listener_mapWindow(void* owner, void* data) {

                PMONITOR = g_pCompositor->m_pLastMonitor.lock();
            }
+
+            requestedFSMonitor = MONITOR_INVALID;
        } else
            workspaceSilent = false;
    }

+    if (PWINDOW->m_eSuppressedEvents & SUPPRESS_FULLSCREEN_OUTPUT)
+        requestedFSMonitor = MONITOR_INVALID;
+    else if (requestedFSMonitor != MONITOR_INVALID) {
+        if (const auto PM = g_pCompositor->getMonitorFromID(requestedFSMonitor); PM)
+            PWINDOW->m_pMonitor = PM;
+
+        const auto PMONITORFROMID = PWINDOW->m_pMonitor.lock();
+
+        if (PWINDOW->m_pMonitor != PMONITOR) {
+            g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID()));
+            PMONITOR = PMONITORFROMID;
+        }
+        PWINDOW->m_pWorkspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
+        PWORKSPACE            = PWINDOW->m_pWorkspace;
+
+        Debug::log(LOG, "Requested monitor, applying to {:mw}", PWINDOW);
+    }
+
+    if (PWORKSPACE->m_bDefaultFloating)
+        PWINDOW->m_bIsFloating = true;
+
+    if (PWORKSPACE->m_bDefaultPseudo) {
+        PWINDOW->m_bIsPseudotiled = true;
+        CBox desiredGeometry      = g_pXWaylandManager->getGeometryForWindow(PWINDOW);
+        PWINDOW->m_vPseudoSize    = Vector2D(desiredGeometry.width, desiredGeometry.height);
+    }
+
    PWINDOW->updateWindowData();

    // Verify window swallowing. Get the swallower before calling onWindowCreated(PWINDOW) because getSwallower() wouldn't get it after if PWINDOW gets auto grouped.
@@ -378,10 +411,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                        const auto  MAXSIZE = PWINDOW->requestedMaxSize();

                        const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->vecSize.x) :
-                                                                stringToFloatClamp(SIZEXSTR, PWINDOW->m_vRealSize.goal().x, PMONITOR->vecSize.x);
+                                                                stringToFloatClamp(SIZEXSTR, PWINDOW->m_vRealSize->goal().x, PMONITOR->vecSize.x);

                        const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) :
-                                                                stringToFloatClamp(SIZEYSTR, PWINDOW->m_vRealSize.goal().y, PMONITOR->vecSize.y);
+                                                                stringToFloatClamp(SIZEYSTR, PWINDOW->m_vRealSize->goal().y, PMONITOR->vecSize.y);

                        Debug::log(LOG, "Rule size, applying to {}", PWINDOW);

@@ -418,7 +451,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                                (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);

                            if (subtractWindow)
-                                posX -= PWINDOW->m_vRealSize.goal().x;
+                                posX -= PWINDOW->m_vRealSize->goal().x;

                            if (CURSOR)
                                Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
@@ -430,7 +463,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                                posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x;
                            } else {
                                posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x +
-                                    (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goal().x);
+                                    (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize->goal().x);
                            }
                        }

@@ -441,7 +474,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                                (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);

                            if (subtractWindow)
-                                posY -= PWINDOW->m_vRealSize.goal().y;
+                                posY -= PWINDOW->m_vRealSize->goal().y;

                            if (CURSOR)
                                Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
@@ -453,7 +486,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                                posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y;
                            } else {
                                posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y +
-                                    (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goal().y);
+                                    (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize->goal().y);
                            }
                        }

@@ -461,15 +494,15 @@ void Events::listener_mapWindow(void* owner, void* data) {
                            int borderSize = PWINDOW->getRealBorderSize();

                            posX = std::clamp(posX, (int)(PMONITOR->vecReservedTopLeft.x + borderSize),
-                                              (int)(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PWINDOW->m_vRealSize.goal().x - borderSize));
+                                              (int)(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PWINDOW->m_vRealSize->goal().x - borderSize));

                            posY = std::clamp(posY, (int)(PMONITOR->vecReservedTopLeft.y + borderSize),
-                                              (int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_vRealSize.goal().y - borderSize));
+                                              (int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_vRealSize->goal().y - borderSize));
                        }

                        Debug::log(LOG, "Rule move, applying to {}", PWINDOW);

-                        PWINDOW->m_vRealPosition = Vector2D(posX, posY) + PMONITOR->vecPosition;
+                        *PWINDOW->m_vRealPosition = Vector2D(posX, posY) + PMONITOR->vecPosition;

                        PWINDOW->setHidden(false);
                    } catch (...) { Debug::log(LOG, "Rule move failed, rule: {} -> {}", r->szRule, r->szValue); }
@@ -481,7 +514,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                    if (ARGS[1] == "1")
                        RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;

-                    PWINDOW->m_vRealPosition = PMONITOR->middle() - PWINDOW->m_vRealSize.goal() / 2.f + RESERVEDOFFSET;
+                    *PWINDOW->m_vRealPosition = PMONITOR->middle() - PWINDOW->m_vRealSize->goal() / 2.f + RESERVEDOFFSET;
                    break;
                }

@@ -491,7 +524,7 @@ void Events::listener_mapWindow(void* owner, void* data) {

        // set the pseudo size to the GOAL of our current size
        // because the windows are animated on RealSize
-        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goal();
+        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize->goal();

        g_pCompositor->changeWindowZOrder(PWINDOW, true);
    } else {
@@ -524,7 +557,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
        }

        if (!setPseudo)
-            PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goal() - Vector2D(10, 10);
+            PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize->goal() - Vector2D(10, 10);
    }

    const auto PFOCUSEDWINDOWPREV = g_pCompositor->m_pLastWindow.lock();
@@ -554,11 +587,11 @@ void Events::listener_mapWindow(void* owner, void* data) {
        (!PWINDOW->isX11OverrideRedirect() || (PWINDOW->m_bIsX11 && PWINDOW->m_pXWaylandSurface->wantsFocus())) && !workspaceSilent && (!PFORCEFOCUS || PFORCEFOCUS == PWINDOW) &&
        !g_pInputManager->isConstrained()) {
        g_pCompositor->focusWindow(PWINDOW);
-        PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PACTIVEALPHA);
-        PWINDOW->m_fDimPercent.setValueAndWarp(PWINDOW->m_sWindowData.noDim.valueOrDefault() ? 0.f : *PDIMSTRENGTH);
+        PWINDOW->m_fActiveInactiveAlpha->setValueAndWarp(*PACTIVEALPHA);
+        PWINDOW->m_fDimPercent->setValueAndWarp(PWINDOW->m_sWindowData.noDim.valueOrDefault() ? 0.f : *PDIMSTRENGTH);
    } else {
-        PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PINACTIVEALPHA);
-        PWINDOW->m_fDimPercent.setValueAndWarp(0);
+        PWINDOW->m_fActiveInactiveAlpha->setValueAndWarp(*PINACTIVEALPHA);
+        PWINDOW->m_fDimPercent->setValueAndWarp(0);
    }

    if (requestedClientFSMode.has_value() && (PWINDOW->m_eSuppressedEvents & SUPPRESS_FULLSCREEN))
@@ -571,8 +604,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
        if (PWINDOW->m_pWorkspace->m_bHasFullscreenWindow)
            g_pCompositor->setWindowFullscreenInternal(PWINDOW->m_pWorkspace->getFullscreenWindow(), FSMODE_NONE);

-        PWINDOW->m_vRealPosition.warp();
-        PWINDOW->m_vRealSize.warp();
+        PWINDOW->m_vRealPosition->warp();
+        PWINDOW->m_vRealSize->warp();
        if (requestedFSState.has_value()) {
            PWINDOW->m_sWindowData.syncFullscreen = CWindowOverridableVar(false, PRIORITY_WINDOW_RULE);
            g_pCompositor->setWindowFullscreenState(PWINDOW, requestedFSState.value());
@@ -607,7 +640,7 @@ void Events::listener_mapWindow(void* owner, void* data) {

    PWINDOW->m_bFirstMap = false;

-    Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->szName, PWINDOW->m_vRealPosition.goal(), PWINDOW->m_vRealSize.goal());
+    Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->szName, PWINDOW->m_vRealPosition->goal(), PWINDOW->m_vRealSize->goal());

    auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_szName;
    g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", std::format("{:x},{},{},{}", PWINDOW, workspaceID, PWINDOW->m_szClass, PWINDOW->m_szTitle)});
@@ -620,17 +653,17 @@ void Events::listener_mapWindow(void* owner, void* data) {

    // do animations
    g_pAnimationManager->onWindowPostCreateClose(PWINDOW, false);
-    PWINDOW->m_fAlpha.setValueAndWarp(0.f);
-    PWINDOW->m_fAlpha = 1.f;
+    PWINDOW->m_fAlpha->setValueAndWarp(0.f);
+    *PWINDOW->m_fAlpha = 1.f;

-    PWINDOW->m_vRealPosition.setCallbackOnEnd(setAnimToMove);
-    PWINDOW->m_vRealSize.setCallbackOnEnd(setAnimToMove);
+    PWINDOW->m_vRealPosition->setCallbackOnEnd(setVector2DAnimToMove);
+    PWINDOW->m_vRealSize->setCallbackOnEnd(setVector2DAnimToMove);

    // recalc the values for this window
    g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
    // avoid this window being visible
    if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->isFullscreen() && !PWINDOW->m_bIsFloating)
-        PWINDOW->m_fAlpha.setValueAndWarp(0.f);
+        PWINDOW->m_fAlpha->setValueAndWarp(0.f);

    g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_pWLSurface->resource(), PMONITOR->scale);
    g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_pWLSurface->resource(), PMONITOR->transform);
@@ -646,6 +679,13 @@ void Events::listener_mapWindow(void* owner, void* data) {

    if (PMONITOR && PWINDOW->isX11OverrideRedirect())
        PWINDOW->m_fX11SurfaceScaledBy = PMONITOR->scale;
+
+    // Fix some X11 popups being invisible / having incorrect size on open.
+    // What the ACTUAL FUCK is going on?????? I HATE X11
+    if (!PWINDOW->isX11OverrideRedirect() && PWINDOW->m_bIsX11 && PWINDOW->m_bIsFloating) {
+        PWINDOW->sendWindowSize(PWINDOW->m_vRealSize->goal(), true, PWINDOW->m_vRealPosition->goal() - Vector2D{1, 1});
+        PWINDOW->sendWindowSize(PWINDOW->m_vRealSize->goal(), true);
+    }
 }

 void Events::listener_unmapWindow(void* owner, void* data) {
@@ -666,8 +706,8 @@ void Events::listener_unmapWindow(void* owner, void* data) {

    const auto PMONITOR = PWINDOW->m_pMonitor.lock();
    if (PMONITOR) {
-        PWINDOW->m_vOriginalClosedPos     = PWINDOW->m_vRealPosition.value() - PMONITOR->vecPosition;
-        PWINDOW->m_vOriginalClosedSize    = PWINDOW->m_vRealSize.value();
+        PWINDOW->m_vOriginalClosedPos     = PWINDOW->m_vRealPosition->value() - PMONITOR->vecPosition;
+        PWINDOW->m_vOriginalClosedSize    = PWINDOW->m_vRealSize->value();
        PWINDOW->m_eOriginalClosedExtents = PWINDOW->getFullWindowExtents();
    }

@@ -680,7 +720,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
        g_pCompositor->setWindowFullscreenInternal(PWINDOW, FSMODE_NONE);

    // Allow the renderer to catch the last frame.
-    g_pHyprOpenGL->makeWindowSnapshot(PWINDOW);
+    g_pHyprRenderer->makeWindowSnapshot(PWINDOW);

    // swallowing
    if (valid(PWINDOW->m_pSwallowed)) {
@@ -757,12 +797,12 @@ void Events::listener_unmapWindow(void* owner, void* data) {

    g_pCompositor->addToFadingOutSafe(PWINDOW);

-    if (!PWINDOW->m_bX11DoesntWantBorders)                                                    // don't animate out if they weren't animated in.
-        PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.value() + Vector2D(0.01f, 0.01f); // it has to be animated, otherwise onWindowPostCreateClose will ignore it
+    if (!PWINDOW->m_bX11DoesntWantBorders)                                                      // don't animate out if they weren't animated in.
+        *PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition->value() + Vector2D(0.01f, 0.01f); // it has to be animated, otherwise onWindowPostCreateClose will ignore it

    // anims
    g_pAnimationManager->onWindowPostCreateClose(PWINDOW, true);
-    PWINDOW->m_fAlpha = 0.f;
+    *PWINDOW->m_fAlpha = 0.f;

    // recheck idle inhibitors
    g_pInputManager->recheckIdleInhibitorStatus();
@@ -812,7 +852,7 @@ void Events::listener_commitWindow(void* owner, void* data) {
        g_pSeatManager->isPointerFrameSkipped = false;
        g_pSeatManager->isPointerFrameCommit  = false;
    } else
-        g_pHyprRenderer->damageSurface(PWINDOW->m_pWLSurface->resource(), PWINDOW->m_vRealPosition.goal().x, PWINDOW->m_vRealPosition.goal().y,
+        g_pHyprRenderer->damageSurface(PWINDOW->m_pWLSurface->resource(), PWINDOW->m_vRealPosition->goal().x, PWINDOW->m_vRealPosition->goal().y,
                                       PWINDOW->m_bIsX11 ? 1.0 / PWINDOW->m_fX11SurfaceScaledBy : 1.0);

    if (g_pSeatManager->isPointerFrameSkipped) {
@@ -872,15 +912,6 @@ void Events::listener_destroyWindow(void* owner, void* data) {
    PWINDOW->listeners.commit.reset();
 }

-void Events::listener_setTitleWindow(void* owner, void* data) {
-    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
-
-    if (!validMapped(PWINDOW))
-        return;
-
-    PWINDOW->onUpdateMeta();
-}
-
 void Events::listener_activateX11(void* owner, void* data) {
    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();

@@ -912,8 +943,8 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
    if (!PWINDOW->m_bIsMapped || !PWINDOW->m_pXWaylandSurface || !PWINDOW->m_pXWaylandSurface->overrideRedirect)
        return;

-    const auto POS = PWINDOW->m_vRealPosition.goal();
-    const auto SIZ = PWINDOW->m_vRealSize.goal();
+    const auto POS = PWINDOW->m_vRealPosition->goal();
+    const auto SIZ = PWINDOW->m_vRealSize->goal();

    if (PWINDOW->m_pXWaylandSurface->geometry.size() > Vector2D{1, 1})
        PWINDOW->setHidden(false);
@@ -921,7 +952,7 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
        PWINDOW->setHidden(true);

    if (PWINDOW->isFullscreen() || !PWINDOW->m_bIsFloating) {
-        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal(), true);
+        PWINDOW->sendWindowSize(PWINDOW->m_vRealSize->goal(), true);
        g_pHyprRenderer->damageWindow(PWINDOW);
        return;
    }
@@ -935,27 +966,27 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
        Debug::log(LOG, "Unmanaged window {} requests geometry update to {:j} {:j}", PWINDOW, LOGICALPOS, PWINDOW->m_pXWaylandSurface->geometry.size());

        g_pHyprRenderer->damageWindow(PWINDOW);
-        PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(LOGICALPOS.x, LOGICALPOS.y));
+        PWINDOW->m_vRealPosition->setValueAndWarp(Vector2D(LOGICALPOS.x, LOGICALPOS.y));

        if (abs(std::floor(SIZ.x) - PWINDOW->m_pXWaylandSurface->geometry.w) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_pXWaylandSurface->geometry.h) > 2)
-            PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_pXWaylandSurface->geometry.size());
+            PWINDOW->m_vRealSize->setValueAndWarp(PWINDOW->m_pXWaylandSurface->geometry.size());

        if (*PXWLFORCESCALEZERO) {
            if (const auto PMONITOR = PWINDOW->m_pMonitor.lock(); PMONITOR) {
-                PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goal() / PMONITOR->scale);
+                PWINDOW->m_vRealSize->setValueAndWarp(PWINDOW->m_vRealSize->goal() / PMONITOR->scale);
            }
        }

-        PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.goal();
-        PWINDOW->m_vSize     = PWINDOW->m_vRealSize.goal();
+        PWINDOW->m_vPosition = PWINDOW->m_vRealPosition->goal();
+        PWINDOW->m_vSize     = PWINDOW->m_vRealSize->goal();

-        PWINDOW->m_pWorkspace = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.value() + PWINDOW->m_vRealSize.value() / 2.f)->activeWorkspace;
+        PWINDOW->m_pWorkspace = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition->value() + PWINDOW->m_vRealSize->value() / 2.f)->activeWorkspace;

        g_pCompositor->changeWindowZOrder(PWINDOW, true);
        PWINDOW->updateWindowDecos();
        g_pHyprRenderer->damageWindow(PWINDOW);

-        PWINDOW->m_vReportedPosition    = PWINDOW->m_vRealPosition.goal();
-        PWINDOW->m_vPendingReportedSize = PWINDOW->m_vRealSize.goal();
+        PWINDOW->m_vReportedPosition    = PWINDOW->m_vRealPosition->goal();
+        PWINDOW->m_vPendingReportedSize = PWINDOW->m_vRealSize->goal();
    }
 }
--- a/src/helpers/AnimatedVariable.cpp
+++ b/src/helpers/AnimatedVariable.cpp
@@ -1,92 +0,0 @@
-#include "AnimatedVariable.hpp"
-#include "../managers/AnimationManager.hpp"
-#include "../config/ConfigManager.hpp"
-
-CBaseAnimatedVariable::CBaseAnimatedVariable(eAnimatedVarType type) : m_Type(type) {
-    ; // dummy var
-}
-
-void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, eAVarDamagePolicy policy) {
-    m_eDamagePolicy = policy;
-    m_pConfig       = pAnimConfig;
-    m_pWindow       = pWindow;
-
-    m_bDummy = false;
-}
-
-void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, eAVarDamagePolicy policy) {
-    m_eDamagePolicy = policy;
-    m_pConfig       = pAnimConfig;
-    m_pLayer        = pLayer;
-
-    m_bDummy = false;
-}
-
-void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLWORKSPACE pWorkspace, eAVarDamagePolicy policy) {
-    m_eDamagePolicy = policy;
-    m_pConfig       = pAnimConfig;
-    m_pWorkspace    = pWorkspace;
-
-    m_bDummy = false;
-}
-
-void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, eAVarDamagePolicy policy) {
-    m_eDamagePolicy = policy;
-    m_pConfig       = pAnimConfig;
-
-    m_bDummy = false;
-}
-
-CBaseAnimatedVariable::~CBaseAnimatedVariable() {
-    unregister();
-}
-
-void CBaseAnimatedVariable::unregister() {
-    if (!g_pAnimationManager)
-        return;
-    std::erase_if(g_pAnimationManager->m_vAnimatedVariables, [&](const auto& other) { return other == this; });
-    m_bIsRegistered = false;
-    disconnectFromActive();
-}
-
-void CBaseAnimatedVariable::registerVar() {
-    if (!m_bIsRegistered)
-        g_pAnimationManager->m_vAnimatedVariables.push_back(this);
-    m_bIsRegistered = true;
-}
-
-int CBaseAnimatedVariable::getDurationLeftMs() {
-    return std::max(
-        (int)(m_pConfig->pValues->internalSpeed * 100) - (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - animationBegin).count(), 0);
-}
-
-float CBaseAnimatedVariable::getPercent() {
-    const auto DURATIONPASSED = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - animationBegin).count();
-    return std::clamp((DURATIONPASSED / 100.f) / m_pConfig->pValues->internalSpeed, 0.f, 1.f);
-}
-
-float CBaseAnimatedVariable::getCurveValue() {
-    if (!m_bIsBeingAnimated)
-        return 1.f;
-
-    const auto SPENT = getPercent();
-
-    if (SPENT >= 1.f)
-        return 1.f;
-
-    return g_pAnimationManager->getBezier(m_pConfig->pValues->internalBezier)->getYForPoint(SPENT);
-}
-
-void CBaseAnimatedVariable::connectToActive() {
-    g_pAnimationManager->scheduleTick(); // otherwise the animation manager will never pick this up
-
-    if (!m_bIsConnectedToActive)
-        g_pAnimationManager->m_vActiveAnimatedVariables.push_back(this);
-
-    m_bIsConnectedToActive = true;
-}
-
-void CBaseAnimatedVariable::disconnectFromActive() {
-    std::erase_if(g_pAnimationManager->m_vActiveAnimatedVariables, [&](const auto& other) { return other == this; });
-    m_bIsConnectedToActive = false;
-}
--- a/src/helpers/AnimatedVariable.hpp
+++ b/src/helpers/AnimatedVariable.hpp
@@ -1,15 +1,18 @@
 #pragma once

-#include <functional>
-#include <any>
-#include <chrono>
-#include <type_traits>
-#include "math/Math.hpp"
+#include <hyprutils/animation/AnimatedVariable.hpp>
+
 #include "Color.hpp"
 #include "../defines.hpp"
-#include "../debug/Log.hpp"
 #include "../desktop/DesktopTypes.hpp"

+enum eAVarDamagePolicy : int8_t {
+    AVARDAMAGE_NONE   = -1,
+    AVARDAMAGE_ENTIRE = 0,
+    AVARDAMAGE_BORDER,
+    AVARDAMAGE_SHADOW
+};
+
 enum eAnimatedVarType : int8_t {
    AVARTYPE_INVALID = -1,
    AVARTYPE_FLOAT,
@@ -42,20 +45,6 @@ struct STypeToAnimatedVarType_t<CHyprColor> {
 template <class T>
 inline constexpr eAnimatedVarType typeToeAnimatedVarType = STypeToAnimatedVarType_t<T>::value;

-enum eAVarDamagePolicy : int8_t {
-    AVARDAMAGE_NONE   = -1,
-    AVARDAMAGE_ENTIRE = 0,
-    AVARDAMAGE_BORDER,
-    AVARDAMAGE_SHADOW
-};
-
-class CAnimationManager;
-struct SAnimationPropertyConfig;
-class CHyprRenderer;
-class CWindow;
-class CWorkspace;
-class CLayerSurface;
-
 // Utility to define a concept as a list of possible type
 template <class T, class... U>
 concept OneOf = (... or std::same_as<T, U>);
@@ -66,247 +55,19 @@ concept OneOf = (... or std::same_as<T, U>);
 template <class T>
 concept Animable = OneOf<T, Vector2D, float, CHyprColor>;

-class CBaseAnimatedVariable {
-  public:
-    CBaseAnimatedVariable(eAnimatedVarType type);
-    void create(SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, eAVarDamagePolicy policy);
-    void create(SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, eAVarDamagePolicy policy);
-    void create(SAnimationPropertyConfig* pAnimConfig, PHLWORKSPACE pWorkspace, eAVarDamagePolicy policy);
-    void create(SAnimationPropertyConfig* pAnimConfig, eAVarDamagePolicy policy);
+struct SAnimationContext {
+    PHLWINDOWREF      pWindow;
+    PHLWORKSPACEREF   pWorkspace;
+    PHLLSREF          pLayer;

-    CBaseAnimatedVariable(const CBaseAnimatedVariable&)            = delete;
-    CBaseAnimatedVariable(CBaseAnimatedVariable&&)                 = delete;
-    CBaseAnimatedVariable& operator=(const CBaseAnimatedVariable&) = delete;
-    CBaseAnimatedVariable& operator=(CBaseAnimatedVariable&&)      = delete;
-
-    virtual ~CBaseAnimatedVariable();
-
-    void         unregister();
-    void         registerVar();
-
-    virtual void warp(bool endCallback = true) = 0;
-
-    //
-    void setConfig(SAnimationPropertyConfig* pConfig) {
-        m_pConfig = pConfig;
-    }
-
-    SAnimationPropertyConfig* getConfig() {
-        return m_pConfig;
-    }
-
-    int getDurationLeftMs();
-
-    /* returns the spent (completion) % */
-    float getPercent();
-
-    /* returns the current curve value */
-    float getCurveValue();
-
-    // checks if an animation is in progress
-    bool isBeingAnimated() const {
-        return m_bIsBeingAnimated;
-    }
-
-    /*  sets a function to be ran when the animation finishes.
-        if an animation is not running, runs instantly.
-        if "remove" is set to true, will remove the callback when ran. */
-    void setCallbackOnEnd(std::function<void(void* thisptr)> func, bool remove = true) {
-        m_fEndCallback       = std::move(func);
-        m_bRemoveEndAfterRan = remove;
-
-        if (!isBeingAnimated())
-            onAnimationEnd();
-    }
-
-    /*  sets a function to be ran when an animation is started.
-        if "remove" is set to true, will remove the callback when ran. */
-    void setCallbackOnBegin(std::function<void(void* thisptr)> func, bool remove = true) {
-        m_fBeginCallback       = std::move(func);
-        m_bRemoveBeginAfterRan = remove;
-    }
-
-    /*  Sets the update callback, called every time the value is animated and a step is done
-        Warning: calling unregisterVar/registerVar in this handler will cause UB */
-    void setUpdateCallback(std::function<void(void* thisptr)> func) {
-        m_fUpdateCallback = std::move(func);
-    }
-
-    /*  resets all callbacks. Does not call any. */
-    void resetAllCallbacks() {
-        m_fBeginCallback       = nullptr;
-        m_fEndCallback         = nullptr;
-        m_fUpdateCallback      = nullptr;
-        m_bRemoveBeginAfterRan = false;
-        m_bRemoveEndAfterRan   = false;
-    }
-
-    PHLWINDOW getWindow() {
-        return m_pWindow.lock();
-    }
-
-  protected:
-    PHLWINDOWREF                          m_pWindow;
-    PHLWORKSPACEREF                       m_pWorkspace;
-    PHLLSREF                              m_pLayer;
-
-    SAnimationPropertyConfig*             m_pConfig = nullptr;
-
-    bool                                  m_bDummy           = true;
-    bool                                  m_bIsRegistered    = false;
-    bool                                  m_bIsBeingAnimated = false;
-
-    std::chrono::steady_clock::time_point animationBegin;
-
-    eAVarDamagePolicy                     m_eDamagePolicy = AVARDAMAGE_NONE;
-    eAnimatedVarType                      m_Type;
-
-    bool                                  m_bRemoveEndAfterRan   = true;
-    bool                                  m_bRemoveBeginAfterRan = true;
-    std::function<void(void* thisptr)>    m_fEndCallback;
-    std::function<void(void* thisptr)>    m_fBeginCallback;
-    std::function<void(void* thisptr)>    m_fUpdateCallback;
-
-    bool                                  m_bIsConnectedToActive = false;
-
-    void                                  connectToActive();
-
-    void                                  disconnectFromActive();
-
-    // methods
-    void onAnimationEnd() {
-        m_bIsBeingAnimated = false;
-        disconnectFromActive();
-
-        if (m_fEndCallback) {
-            // loading m_bRemoveEndAfterRan before calling the callback allows the callback to delete this animation safely if it is false.
-            auto removeEndCallback = m_bRemoveEndAfterRan;
-            m_fEndCallback(this);
-            if (removeEndCallback)
-                m_fEndCallback = nullptr; // reset
-        }
-    }
-
-    void onAnimationBegin() {
-        m_bIsBeingAnimated = true;
-        connectToActive();
-
-        if (m_fBeginCallback) {
-            m_fBeginCallback(this);
-            if (m_bRemoveBeginAfterRan)
-                m_fBeginCallback = nullptr; // reset
-        }
-    }
-
-    friend class CAnimationManager;
-    friend class CWorkspace;
-    friend class CLayerSurface;
-    friend class CHyprRenderer;
+    eAVarDamagePolicy eDamagePolicy = AVARDAMAGE_NONE;
 };

 template <Animable VarType>
-class CAnimatedVariable : public CBaseAnimatedVariable {
-  public:
-    CAnimatedVariable() : CBaseAnimatedVariable(typeToeAnimatedVarType<VarType>) {
-        ;
-    } // dummy var
+using CAnimatedVariable = Hyprutils::Animation::CGenericAnimatedVariable<VarType, SAnimationContext>;

-    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, eAVarDamagePolicy policy) {
-        create(pAnimConfig, pWindow, policy);
-        m_Value = value;
-        m_Goal  = value;
-    }
-    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, eAVarDamagePolicy policy) {
-        create(pAnimConfig, pLayer, policy);
-        m_Value = value;
-        m_Goal  = value;
-    }
-    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, PHLWORKSPACE pWorkspace, eAVarDamagePolicy policy) {
-        create(pAnimConfig, pWorkspace, policy);
-        m_Value = value;
-        m_Goal  = value;
-    }
-    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, eAVarDamagePolicy policy) {
-        create(pAnimConfig, policy);
-        m_Value = value;
-        m_Goal  = value;
-    }
+template <Animable VarType>
+using PHLANIMVAR = SP<CAnimatedVariable<VarType>>;

-    using CBaseAnimatedVariable::create;
-
-    CAnimatedVariable(const CAnimatedVariable&)            = delete;
-    CAnimatedVariable(CAnimatedVariable&&)                 = delete;
-    CAnimatedVariable& operator=(const CAnimatedVariable&) = delete;
-    CAnimatedVariable& operator=(CAnimatedVariable&&)      = delete;
-
-    ~CAnimatedVariable() = default;
-
-    // gets the current vector value (real time)
-    const VarType& value() const {
-        return m_Value;
-    }
-
-    // gets the goal vector value
-    const VarType& goal() const {
-        return m_Goal;
-    }
-
-    CAnimatedVariable& operator=(const VarType& v) {
-        if (v == m_Goal)
-            return *this;
-
-        m_Goal         = v;
-        animationBegin = std::chrono::steady_clock::now();
-        m_Begun        = m_Value;
-
-        onAnimationBegin();
-
-        return *this;
-    }
-
-    // Sets the actual stored value, without affecting the goal, but resets the timer
-    void setValue(const VarType& v) {
-        if (v == m_Value)
-            return;
-
-        m_Value        = v;
-        animationBegin = std::chrono::steady_clock::now();
-        m_Begun        = m_Value;
-
-        onAnimationBegin();
-    }
-
-    // Sets the actual value and goal
-    void setValueAndWarp(const VarType& v) {
-        m_Goal             = v;
-        m_bIsBeingAnimated = true;
-        warp();
-    }
-
-    void warp(bool endCallback = true) override {
-        if (!m_bIsBeingAnimated)
-            return;
-
-        m_Value = m_Goal;
-
-        m_bIsBeingAnimated = false;
-
-        if (m_fUpdateCallback)
-            m_fUpdateCallback(this);
-
-        if (endCallback)
-            onAnimationEnd();
-    }
-
-  private:
-    VarType m_Value{};
-    VarType m_Goal{};
-    VarType m_Begun{};
-
-    // owners
-
-    friend class CAnimationManager;
-    friend class CWorkspace;
-    friend class CLayerSurface;
-    friend class CHyprRenderer;
-};
+template <Animable VarType>
+using PHLANIMVARREF = WP<CAnimatedVariable<VarType>>;
--- a/src/helpers/BezierCurve.cpp
+++ b/src/helpers/BezierCurve.cpp
@@ -1,90 +0,0 @@
-#include "BezierCurve.hpp"
-#include "../debug/Log.hpp"
-#include "../macros.hpp"
-
-#include <chrono>
-#include <algorithm>
-
-void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
-    const auto BEGIN = std::chrono::high_resolution_clock::now();
-
-    // Avoid reallocations by reserving enough memory upfront
-    m_vPoints.resize(pVec->size() + 2);
-    m_vPoints[0] = Vector2D(0, 0); // Start point
-    size_t index = 1;              // Start after the first element
-    for (const auto& vec : *pVec) {
-        if (index < m_vPoints.size() - 1) { // Bounds check to ensure safety
-            m_vPoints[index] = vec;
-            ++index;
-        }
-    }
-    m_vPoints.back() = Vector2D(1, 1); // End point
-
-    RASSERT(m_vPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: {})", m_vPoints.size());
-
-    // bake BAKEDPOINTS points for faster lookups
-    // T -> X ( / BAKEDPOINTS )
-    for (int i = 0; i < BAKEDPOINTS; ++i) {
-        float const t     = (i + 1) / (float)BAKEDPOINTS;
-        m_aPointsBaked[i] = Vector2D(getXForT(t), getYForT(t));
-    }
-
-    const auto ELAPSEDUS  = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - BEGIN).count() / 1000.f;
-    const auto POINTSSIZE = m_aPointsBaked.size() * sizeof(m_aPointsBaked[0]) / 1000.f;
-
-    const auto BEGINCALC = std::chrono::high_resolution_clock::now();
-    for (int j = 1; j < 10; ++j) {
-        float i = j / 10.0f;
-        getYForPoint(i);
-    }
-    const auto ELAPSEDCALCAVG = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - BEGINCALC).count() / 1000.f / 10.f;
-
-    Debug::log(LOG, "Created a bezier curve, baked {} points, mem usage: {:.2f}kB, time to bake: {:.2f}µs. Estimated average calc time: {:.2f}µs.", BAKEDPOINTS, POINTSSIZE,
-               ELAPSEDUS, ELAPSEDCALCAVG);
-}
-
-float CBezierCurve::getXForT(float const& t) const {
-    float t2 = t * t;
-    float t3 = t2 * t;
-
-    return 3 * t * (1 - t) * (1 - t) * m_vPoints[1].x + 3 * t2 * (1 - t) * m_vPoints[2].x + t3 * m_vPoints[3].x;
-}
-
-float CBezierCurve::getYForT(float const& t) const {
-    float t2 = t * t;
-    float t3 = t2 * t;
-
-    return 3 * t * (1 - t) * (1 - t) * m_vPoints[1].y + 3 * t2 * (1 - t) * m_vPoints[2].y + t3 * m_vPoints[3].y;
-}
-
-// Todo: this probably can be done better and faster
-float CBezierCurve::getYForPoint(float const& x) const {
-    if (x >= 1.f)
-        return 1.f;
-    if (x <= 0.f)
-        return 0.f;
-
-    int  index = 0;
-    bool below = true;
-    for (int step = (BAKEDPOINTS + 1) / 2; step > 0; step /= 2) {
-        if (below)
-            index += step;
-        else
-            index -= step;
-
-        below = m_aPointsBaked[index].x < x;
-    }
-
-    int lowerIndex = index - (!below || index == BAKEDPOINTS - 1);
-
-    // in the name of performance i shall make a hack
-    const auto LOWERPOINT = &m_aPointsBaked[lowerIndex];
-    const auto UPPERPOINT = &m_aPointsBaked[lowerIndex + 1];
-
-    const auto PERCINDELTA = (x - LOWERPOINT->x) / (UPPERPOINT->x - LOWERPOINT->x);
-
-    if (std::isnan(PERCINDELTA) || std::isinf(PERCINDELTA)) // can sometimes happen for VERY small x
-        return 0.f;
-
-    return LOWERPOINT->y + (UPPERPOINT->y - LOWERPOINT->y) * PERCINDELTA;
-}
--- a/src/helpers/BezierCurve.hpp
+++ b/src/helpers/BezierCurve.hpp
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <array>
-#include <vector>
-#include "math/Math.hpp"
-
-constexpr int   BAKEDPOINTS    = 255;
-constexpr float INVBAKEDPOINTS = 1.f / BAKEDPOINTS;
-
-// an implementation of a cubic bezier curve
-// might do better later
-class CBezierCurve {
-  public:
-    // sets up the bezier curve.
-    // this EXCLUDES the 0,0 and 1,1 points,
-    void  setup(std::vector<Vector2D>* points);
-
-    float getYForT(float const& t) const;
-    float getXForT(float const& t) const;
-    float getYForPoint(float const& x) const;
-
-  private:
-    // this INCLUDES the 0,0 and 1,1 points.
-    std::vector<Vector2D>             m_vPoints;
-
-    std::array<Vector2D, BAKEDPOINTS> m_aPointsBaked;
-};
--- a/src/helpers/Color.cpp
+++ b/src/helpers/Color.cpp
@@ -43,3 +43,7 @@ Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const {
 CHyprColor CHyprColor::stripA() const {
    return {r, g, b, 1.F};
 }
+
+CHyprColor CHyprColor::modifyA(float newa) const {
+    return {r, g, b, newa};
+}
--- a/src/helpers/Color.hpp
+++ b/src/helpers/Color.hpp
@@ -2,7 +2,6 @@

 #include <cstdint>
 #include <hyprgraphics/color/Color.hpp>
-#include "../debug/Log.hpp"
 #include "../macros.hpp"

 class CHyprColor {
@@ -18,6 +17,7 @@ class CHyprColor {
    Hyprgraphics::CColor::SOkLab asOkLab() const;
    Hyprgraphics::CColor::SHSL   asHSL() const;
    CHyprColor                   stripA() const;
+    CHyprColor                   modifyA(float newa) const;

    //
    bool operator==(const CHyprColor& c2) const {
@@ -45,3 +45,18 @@ class CHyprColor {
  private:
    Hyprgraphics::CColor::SOkLab okLab; // cache for the OkLab representation
 };
+
+//NOLINTNEXTLINE
+namespace Colors {
+    static const CHyprColor WHITE      = CHyprColor(1.F, 1.F, 1.F, 1.F);
+    static const CHyprColor GREEN      = CHyprColor(0.F, 1.F, 0.F, 1.F);
+    static const CHyprColor BLUE       = CHyprColor(0.F, 0.F, 1.F, 1.F);
+    static const CHyprColor RED        = CHyprColor(1.F, 0.F, 0.F, 1.F);
+    static const CHyprColor ORANGE     = CHyprColor(1.F, 0.5F, 0.F, 1.F);
+    static const CHyprColor YELLOW     = CHyprColor(1.F, 1.F, 0.F, 1.F);
+    static const CHyprColor MAGENTA    = CHyprColor(1.F, 0.F, 1.F, 1.F);
+    static const CHyprColor PURPLE     = CHyprColor(0.5F, 0.F, 0.5F, 1.F);
+    static const CHyprColor LIME       = CHyprColor(0.5F, 1.F, 0.1F, 1.F);
+    static const CHyprColor LIGHT_BLUE = CHyprColor(0.1F, 1.F, 1.F, 1.F);
+    static const CHyprColor BLACK      = CHyprColor(0.F, 0.F, 0.F, 1.F);
+};
--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -3,6 +3,9 @@
 #include <algorithm>
 #include "../Compositor.hpp"
 #include "../managers/TokenManager.hpp"
+#include "Monitor.hpp"
+#include "../config/ConfigManager.hpp"
+#include "fs/FsUtils.hpp"
 #include <optional>
 #include <cstring>
 #include <cmath>
@@ -161,26 +164,6 @@ std::string absolutePath(const std::string& rawpath, const std::string& currentP
    return value;
 }

-void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, const std::string& ownerString) {
-    ASSERT(pSignal);
-    ASSERT(pListener);
-
-    wl_signal_add(pSignal, pListener);
-
-    Debug::log(LOG, "Registered signal for owner {:x}: {:x} -> {:x} (owner: {})", (uintptr_t)pOwner, (uintptr_t)pSignal, (uintptr_t)pListener, ownerString);
-}
-
-void removeWLSignal(wl_listener* pListener) {
-    wl_list_remove(&pListener->link);
-    wl_list_init(&pListener->link);
-
-    Debug::log(LOG, "Removed listener {:x}", (uintptr_t)pListener);
-}
-
-void handleNoop(struct wl_listener* listener, void* data) {
-    // Do nothing
-}
-
 std::string escapeJSONStrings(const std::string& str) {
    std::ostringstream oss;
    for (auto const& c : str) {
@@ -278,7 +261,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
        if (!valid(PWORKSPACE))
            return {WORKSPACE_INVALID};

-        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PWORKSPACE->m_sPrevWorkspace.id);
+        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PWORKSPACE->getPrevWorkspaceIDName().id);

        if (!PLASTWORKSPACE)
            return {WORKSPACE_INVALID};
@@ -628,7 +611,7 @@ void logSystemInfo() {
        }
    } catch (...) { GPUINFO = "error"; }
 #else
-    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
+    const std::string GPUINFO = execAndGet("lspci -vnn | grep -E '(VGA|Display|3D)'");
 #endif
    Debug::log(LOG, "GPU information:\n{}\n", GPUINFO);

@@ -639,7 +622,7 @@ void logSystemInfo() {
    // log etc
    Debug::log(LOG, "os-release:");

-    Debug::log(NONE, "{}", execAndGet("cat /etc/os-release"));
+    Debug::log(NONE, "{}", NFsUtils::readFileAsString("/etc/os-release").value_or("error"));
 }

 int64_t getPPIDof(int64_t pid) {
@@ -931,30 +914,3 @@ float stringToPercentage(const std::string& VALUE, const float REL) {
    else
        return std::stof(VALUE);
 }
-
-bool executableExistsInPath(const std::string& exe) {
-    if (!getenv("PATH"))
-        return false;
-
-    static CVarList paths(getenv("PATH"), 0, ':', true);
-
-    for (auto& p : paths) {
-        std::string     path = p + std::string{"/"} + exe;
-        std::error_code ec;
-        if (!std::filesystem::exists(path, ec) || ec)
-            continue;
-
-        if (!std::filesystem::is_regular_file(path, ec) || ec)
-            continue;
-
-        auto stat = std::filesystem::status(path, ec);
-        if (ec)
-            continue;
-
-        auto perms = stat.permissions();
-
-        return std::filesystem::perms::none != (perms & std::filesystem::perms::others_exec);
-    }
-
-    return false;
-}
--- a/src/helpers/MiscFunctions.hpp
+++ b/src/helpers/MiscFunctions.hpp
@@ -1,9 +1,7 @@
 #pragma once

 #include <optional>
-#include <string>
 #include <wayland-server.h>
-#include "math/Math.hpp"
 #include <vector>
 #include <format>
 #include <expected>
@@ -21,8 +19,6 @@ struct SWorkspaceIDName {
 };

 std::string                         absolutePath(const std::string&, const std::string&);
-void                                addWLSignal(wl_signal*, wl_listener*, void* pOwner, const std::string& ownerString);
-void                                removeWLSignal(wl_listener*);
 std::string                         escapeJSONStrings(const std::string& str);
 bool                                isDirection(const std::string&);
 bool                                isDirection(const char&);
@@ -42,7 +38,6 @@ bool                                envEnabled(const std::string& env);
 int                                 allocateSHMFile(size_t len);
 bool                                allocateSHMFilePair(size_t size, int* rw_fd_ptr, int* ro_fd_ptr);
 float                               stringToPercentage(const std::string& VALUE, const float REL);
-bool                                executableExistsInPath(const std::string& exe);

 template <typename... Args>
 [[deprecated("use std::format instead")]] std::string getFormat(std::format_string<Args...> fmt, Args&&... args) {
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -1,5 +1,6 @@
 #include "Monitor.hpp"
 #include "MiscFunctions.hpp"
+#include "../macros.hpp"
 #include "math/Math.hpp"
 #include "sync/SyncReleaser.hpp"
 #include "../Compositor.hpp"
@@ -16,15 +17,23 @@
 #include "../managers/PointerManager.hpp"
 #include "../managers/eventLoop/EventLoopManager.hpp"
 #include "../protocols/core/Compositor.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/EventManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "sync/SyncTimeline.hpp"
+#include "../desktop/LayerSurface.hpp"
 #include <aquamarine/output/Output.hpp>
 #include "debug/Log.hpp"
+#include "debug/HyprNotificationOverlay.hpp"
 #include <hyprutils/string/String.hpp>
 #include <hyprutils/utils/ScopeGuard.hpp>
+#include <cstring>
+#include <ranges>
 using namespace Hyprutils::String;
 using namespace Hyprutils::Utils;

-int ratHandler(void* data) {
+static int ratHandler(void* data) {
    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->self.lock());

    return 1;
@@ -42,6 +51,8 @@ void CMonitor::onConnect(bool noRule) {
    EMIT_HOOK_EVENT("preMonitorAdded", self.lock());
    CScopeGuard x = {[]() { g_pCompositor->arrangeMonitors(); }};

+    g_pEventLoopManager->doLater([] { g_pConfigManager->ensurePersistentWorkspacesPresent(); });
+
    if (output->supportsExplicit) {
        inTimeline  = CSyncTimeline::create(output->getBackend()->drmFD());
        outTimeline = CSyncTimeline::create(output->getBackend()->drmFD());
@@ -85,7 +96,7 @@ void CMonitor::onConnect(bool noRule) {
                return;

            Debug::log(LOG, "Reapplying monitor rule for {} from a state request", szName);
-            g_pHyprRenderer->applyMonitorRule(self.lock(), &activeMonitorRule, true);
+            applyMonitorRule(&activeMonitorRule, true);
            return;
        }

@@ -99,7 +110,7 @@ void CMonitor::onConnect(bool noRule) {
        SMonitorRule rule = activeMonitorRule;
        rule.resolution   = SIZE;

-        g_pHyprRenderer->applyMonitorRule(self.lock(), &rule);
+        applyMonitorRule(&rule);
    });

    tearingState.canTear = output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
@@ -172,7 +183,7 @@ void CMonitor::onConnect(bool noRule) {

    // set mode, also applies
    if (!noRule)
-        g_pHyprRenderer->applyMonitorRule(self.lock(), &monitorRule, true);
+        applyMonitorRule(&monitorRule, true);

    if (!state.commit())
        Debug::log(WARN, "state.commit() failed in CMonitor::onCommit");
@@ -361,6 +372,403 @@ void CMonitor::onDisconnect(bool destroy) {
    std::erase_if(g_pCompositor->m_vMonitors, [&](PHLMONITOR& el) { return el.get() == this; });
 }

+bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
+
+    static auto PDISABLESCALECHECKS = CConfigValue<Hyprlang::INT>("debug:disable_scale_checks");
+
+    Debug::log(LOG, "Applying monitor rule for {}", szName);
+
+    activeMonitorRule = *pMonitorRule;
+
+    if (forceSize.has_value())
+        activeMonitorRule.resolution = forceSize.value();
+
+    const auto RULE = &activeMonitorRule;
+
+    // if it's disabled, disable and ignore
+    if (RULE->disabled) {
+        if (m_bEnabled)
+            onDisconnect();
+
+        events.modeChanged.emit();
+
+        return true;
+    }
+
+    // don't touch VR headsets
+    if (output->nonDesktop)
+        return true;
+
+    if (!m_bEnabled) {
+        onConnect(true); // enable it.
+        Debug::log(LOG, "Monitor {} is disabled but is requested to be enabled", szName);
+        force = true;
+    }
+
+    // Check if the rule isn't already applied
+    // TODO: clean this up lol
+    if (!force && DELTALESSTHAN(vecPixelSize.x, RULE->resolution.x, 1) && DELTALESSTHAN(vecPixelSize.y, RULE->resolution.y, 1) &&
+        DELTALESSTHAN(refreshRate, RULE->refreshRate, 1) && setScale == RULE->scale &&
+        ((DELTALESSTHAN(vecPosition.x, RULE->offset.x, 1) && DELTALESSTHAN(vecPosition.y, RULE->offset.y, 1)) || RULE->offset == Vector2D(-INT32_MAX, -INT32_MAX)) &&
+        transform == RULE->transform && RULE->enable10bit == enabled10bit && !std::memcmp(&customDrmMode, &RULE->drmMode, sizeof(customDrmMode))) {
+
+        Debug::log(LOG, "Not applying a new rule to {} because it's already applied!", szName);
+
+        setMirror(RULE->mirrorOf);
+
+        return true;
+    }
+
+    bool autoScale = false;
+
+    if (RULE->scale > 0.1) {
+        scale = RULE->scale;
+    } else {
+        autoScale               = true;
+        const auto DEFAULTSCALE = getDefaultScale();
+        scale                   = DEFAULTSCALE;
+    }
+
+    setScale  = scale;
+    transform = RULE->transform;
+
+    // accumulate requested modes in reverse order (cause inesrting at front is inefficient)
+    std::vector<SP<Aquamarine::SOutputMode>> requestedModes;
+    std::string                              requestedStr = "unknown";
+
+    // use sortFunc, add best 3 to requestedModes in reverse, since we test in reverse
+    auto addBest3Modes = [&](auto const& sortFunc) {
+        auto sortedModes = output->modes;
+        std::ranges::sort(sortedModes, sortFunc);
+        if (sortedModes.size() > 3)
+            sortedModes.erase(sortedModes.begin() + 3, sortedModes.end());
+        requestedModes.insert(requestedModes.end(), sortedModes.rbegin(), sortedModes.rend());
+    };
+
+    // last fallback is always preferred mode
+    if (!output->preferredMode())
+        Debug::log(ERR, "Monitor {} has NO PREFERRED MODE", output->name);
+    else
+        requestedModes.push_back(output->preferredMode());
+
+    if (RULE->resolution == Vector2D()) {
+        requestedStr = "preferred";
+
+        // fallback to first 3 modes if preferred fails/doesn't exist
+        requestedModes = output->modes;
+        if (requestedModes.size() > 3)
+            requestedModes.erase(requestedModes.begin() + 3, requestedModes.end());
+        std::ranges::reverse(requestedModes.begin(), requestedModes.end());
+
+        if (output->preferredMode())
+            requestedModes.push_back(output->preferredMode());
+    } else if (RULE->resolution == Vector2D(-1, -1)) {
+        requestedStr = "highrr";
+
+        // sort prioritizing refresh rate 1st and resolution 2nd, then add best 3
+        addBest3Modes([](auto const& a, auto const& b) {
+            if (std::round(a->refreshRate) > std::round(b->refreshRate))
+                return true;
+            else if (DELTALESSTHAN((float)a->refreshRate, (float)b->refreshRate, 1.F) && a->pixelSize.x > b->pixelSize.x && a->pixelSize.y > b->pixelSize.y)
+                return true;
+            return false;
+        });
+    } else if (RULE->resolution == Vector2D(-1, -2)) {
+        requestedStr = "highres";
+
+        // sort prioritizing resultion 1st and refresh rate 2nd, then add best 3
+        addBest3Modes([](auto const& a, auto const& b) {
+            if (a->pixelSize.x > b->pixelSize.x && a->pixelSize.y > b->pixelSize.y)
+                return true;
+            else if (DELTALESSTHAN(a->pixelSize.x, b->pixelSize.x, 1) && DELTALESSTHAN(a->pixelSize.y, b->pixelSize.y, 1) &&
+                     std::round(a->refreshRate) > std::round(b->refreshRate))
+                return true;
+            return false;
+        });
+    } else if (RULE->resolution != Vector2D()) {
+        // user requested mode
+        requestedStr = std::format("{:X0}@{:.2f}Hz", RULE->resolution, RULE->refreshRate);
+
+        // sort by closeness to requested, then add best 3
+        addBest3Modes([&](auto const& a, auto const& b) {
+            if (abs(a->pixelSize.x - RULE->resolution.x) < abs(b->pixelSize.x - RULE->resolution.x))
+                return true;
+            if (a->pixelSize.x == b->pixelSize.x && abs(a->pixelSize.y - RULE->resolution.y) < abs(b->pixelSize.y - RULE->resolution.y))
+                return true;
+            if (a->pixelSize == b->pixelSize && abs((a->refreshRate / 1000.f) - RULE->refreshRate) < abs((b->refreshRate / 1000.f) - RULE->refreshRate))
+                return true;
+            return false;
+        });
+
+        // if the best mode isnt close to requested, then try requested as custom mode first
+        if (!requestedModes.empty()) {
+            auto bestMode = requestedModes.back();
+            if (!DELTALESSTHAN(bestMode->pixelSize.x, RULE->resolution.x, 1) || !DELTALESSTHAN(bestMode->pixelSize.y, RULE->resolution.y, 1) ||
+                !DELTALESSTHAN(bestMode->refreshRate / 1000.f, RULE->refreshRate, 1))
+                requestedModes.push_back(makeShared<Aquamarine::SOutputMode>(Aquamarine::SOutputMode{.pixelSize = RULE->resolution, .refreshRate = RULE->refreshRate * 1000.f}));
+        }
+
+        // then if requested is custom, try custom mode first
+        if (RULE->drmMode.type == DRM_MODE_TYPE_USERDEF) {
+            if (output->getBackend()->type() != Aquamarine::eBackendType::AQ_BACKEND_DRM)
+                Debug::log(ERR, "Tried to set custom modeline on non-DRM output");
+            else
+                requestedModes.push_back(makeShared<Aquamarine::SOutputMode>(
+                    Aquamarine::SOutputMode{.pixelSize = {RULE->drmMode.hdisplay, RULE->drmMode.vdisplay}, .refreshRate = RULE->drmMode.vrefresh, .modeInfo = RULE->drmMode}));
+        }
+    }
+
+    const auto WAS10B  = enabled10bit;
+    const auto OLDRES  = vecPixelSize;
+    bool       success = false;
+
+    // Needed in case we are switching from a custom modeline to a standard mode
+    customDrmMode = {};
+    currentMode   = nullptr;
+
+    output->state->setFormat(DRM_FORMAT_XRGB8888);
+    prevDrmFormat = drmFormat;
+    drmFormat     = DRM_FORMAT_XRGB8888;
+    output->state->resetExplicitFences();
+
+    if (Debug::trace) {
+        Debug::log(TRACE, "Monitor {} requested modes:", szName);
+        if (requestedModes.empty())
+            Debug::log(TRACE, "| None");
+        else {
+            for (auto const& mode : requestedModes | std::views::reverse) {
+                Debug::log(TRACE, "| {:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
+            }
+        }
+    }
+
+    for (auto const& mode : requestedModes | std::views::reverse) {
+        std::string modeStr = std::format("{:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
+
+        if (mode->modeInfo.has_value() && mode->modeInfo->type == DRM_MODE_TYPE_USERDEF) {
+            output->state->setCustomMode(mode);
+
+            if (!state.test()) {
+                Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", szName, modeStr);
+                continue;
+            }
+
+            customDrmMode = mode->modeInfo.value();
+        } else {
+            output->state->setMode(mode);
+
+            if (!state.test()) {
+                Debug::log(ERR, "Monitor {}: REJECTED available mode {}!", szName, modeStr);
+                if (mode->preferred)
+                    Debug::log(ERR, "Monitor {}: REJECTED preferred mode!!!", szName);
+                continue;
+            }
+
+            customDrmMode = {};
+        }
+
+        refreshRate = mode->refreshRate / 1000.f;
+        vecSize     = mode->pixelSize;
+        currentMode = mode;
+
+        success = true;
+
+        if (mode->preferred)
+            Debug::log(LOG, "Monitor {}: requested {}, using preferred mode {}", szName, requestedStr, modeStr);
+        else if (mode->modeInfo.has_value() && mode->modeInfo->type == DRM_MODE_TYPE_USERDEF)
+            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", szName, requestedStr, modeStr);
+        else
+            Debug::log(LOG, "Monitor {}: requested {}, using available mode {}", szName, requestedStr, modeStr);
+
+        break;
+    }
+
+    // try requested as custom mode jic it works
+    if (!success && RULE->resolution != Vector2D() && RULE->resolution != Vector2D(-1, -1) && RULE->resolution != Vector2D(-1, -2)) {
+        auto        refreshRate = output->getBackend()->type() == Aquamarine::eBackendType::AQ_BACKEND_DRM ? RULE->refreshRate * 1000 : 0;
+        auto        mode        = makeShared<Aquamarine::SOutputMode>(Aquamarine::SOutputMode{.pixelSize = RULE->resolution, .refreshRate = refreshRate});
+        std::string modeStr     = std::format("{:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
+
+        output->state->setCustomMode(mode);
+
+        if (state.test()) {
+            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", szName, requestedStr, modeStr);
+
+            refreshRate   = mode->refreshRate / 1000.f;
+            vecSize       = mode->pixelSize;
+            currentMode   = mode;
+            customDrmMode = {};
+
+            success = true;
+        } else
+            Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", szName, modeStr);
+    }
+
+    // try any of the modes if none of the above work
+    if (!success) {
+        for (auto const& mode : output->modes) {
+            output->state->setMode(mode);
+
+            if (!state.test())
+                continue;
+
+            auto errorMessage =
+                std::format("Monitor {} failed to set any requested modes, falling back to mode {:X0}@{:.2f}Hz", szName, mode->pixelSize, mode->refreshRate / 1000.f);
+            Debug::log(WARN, errorMessage);
+            g_pHyprNotificationOverlay->addNotification(errorMessage, CHyprColor(0xff0000ff), 5000, ICON_WARNING);
+
+            refreshRate   = mode->refreshRate / 1000.f;
+            vecSize       = mode->pixelSize;
+            currentMode   = mode;
+            customDrmMode = {};
+
+            success = true;
+
+            break;
+        }
+    }
+
+    if (!success) {
+        Debug::log(ERR, "Monitor {} has NO FALLBACK MODES, and an INVALID one was requested: {:X0}@{:.2f}Hz", szName, RULE->resolution, RULE->refreshRate);
+        return true;
+    }
+
+    vrrActive = output->state->state().adaptiveSync // disabled here, will be tested in CConfigManager::ensureVRR()
+        || createdByUser;                           // wayland backend doesn't allow for disabling adaptive_sync
+
+    vecPixelSize = vecSize;
+
+    // clang-format off
+    static const std::array<std::vector<std::pair<std::string, uint32_t>>, 2> formats{
+        std::vector<std::pair<std::string, uint32_t>>{ /* 10-bit */
+            {"DRM_FORMAT_XRGB2101010", DRM_FORMAT_XRGB2101010}, {"DRM_FORMAT_XBGR2101010", DRM_FORMAT_XBGR2101010}, {"DRM_FORMAT_XRGB8888", DRM_FORMAT_XRGB8888}, {"DRM_FORMAT_XBGR8888", DRM_FORMAT_XBGR8888}
+        },
+        std::vector<std::pair<std::string, uint32_t>>{ /* 8-bit */
+            {"DRM_FORMAT_XRGB8888", DRM_FORMAT_XRGB8888}, {"DRM_FORMAT_XBGR8888", DRM_FORMAT_XBGR8888}
+        }
+    };
+    // clang-format on
+
+    bool set10bit = false;
+
+    for (auto const& fmt : formats[(int)!RULE->enable10bit]) {
+        output->state->setFormat(fmt.second);
+        prevDrmFormat = drmFormat;
+        drmFormat     = fmt.second;
+
+        if (!state.test()) {
+            Debug::log(ERR, "output {} failed basic test on format {}", szName, fmt.first);
+        } else {
+            Debug::log(LOG, "output {} succeeded basic test on format {}", szName, fmt.first);
+            if (RULE->enable10bit && fmt.first.contains("101010"))
+                set10bit = true;
+            break;
+        }
+    }
+
+    enabled10bit = set10bit;
+
+    Vector2D logicalSize = vecPixelSize / scale;
+    if (!*PDISABLESCALECHECKS && (logicalSize.x != std::round(logicalSize.x) || logicalSize.y != std::round(logicalSize.y))) {
+        // invalid scale, will produce fractional pixels.
+        // find the nearest valid.
+
+        float    searchScale = std::round(scale * 120.0);
+        bool     found       = false;
+
+        double   scaleZero = searchScale / 120.0;
+
+        Vector2D logicalZero = vecPixelSize / scaleZero;
+        if (logicalZero == logicalZero.round())
+            scale = scaleZero;
+        else {
+            for (size_t i = 1; i < 90; ++i) {
+                double   scaleUp   = (searchScale + i) / 120.0;
+                double   scaleDown = (searchScale - i) / 120.0;
+
+                Vector2D logicalUp   = vecPixelSize / scaleUp;
+                Vector2D logicalDown = vecPixelSize / scaleDown;
+
+                if (logicalUp == logicalUp.round()) {
+                    found       = true;
+                    searchScale = scaleUp;
+                    break;
+                }
+                if (logicalDown == logicalDown.round()) {
+                    found       = true;
+                    searchScale = scaleDown;
+                    break;
+                }
+            }
+
+            if (!found) {
+                if (autoScale)
+                    scale = std::round(scaleZero);
+                else {
+                    Debug::log(ERR, "Invalid scale passed to monitor, {} failed to find a clean divisor", scale);
+                    g_pConfigManager->addParseError("Invalid scale passed to monitor " + szName + ", failed to find a clean divisor");
+                    scale = getDefaultScale();
+                }
+            } else {
+                if (!autoScale) {
+                    Debug::log(ERR, "Invalid scale passed to monitor, {} found suggestion {}", scale, searchScale);
+                    g_pConfigManager->addParseError(
+                        std::format("Invalid scale passed to monitor {}, failed to find a clean divisor. Suggested nearest scale: {:5f}", szName, searchScale));
+                    scale = getDefaultScale();
+                } else
+                    scale = searchScale;
+            }
+        }
+    }
+
+    output->scheduleFrame();
+
+    if (!state.commit())
+        Debug::log(ERR, "Couldn't commit output named {}", output->name);
+
+    Vector2D xfmd      = transform % 2 == 1 ? Vector2D{vecPixelSize.y, vecPixelSize.x} : vecPixelSize;
+    vecSize            = (xfmd / scale).round();
+    vecTransformedSize = xfmd;
+
+    if (createdByUser) {
+        CBox transformedBox = {0, 0, vecTransformedSize.x, vecTransformedSize.y};
+        transformedBox.transform(wlTransformToHyprutils(invertTransform(transform)), vecTransformedSize.x, vecTransformedSize.y);
+
+        vecPixelSize = Vector2D(transformedBox.width, transformedBox.height);
+    }
+
+    updateMatrix();
+
+    if (WAS10B != enabled10bit || OLDRES != vecPixelSize)
+        g_pHyprOpenGL->destroyMonitorResources(self.lock());
+
+    g_pCompositor->arrangeMonitors();
+
+    damage.setSize(vecTransformedSize);
+
+    // Set scale for all surfaces on this monitor, needed for some clients
+    // but not on unsafe state to avoid crashes
+    if (!g_pCompositor->m_bUnsafeState) {
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            w->updateSurfaceScaleTransformDetails();
+        }
+    }
+    // updato us
+    g_pHyprRenderer->arrangeLayersForMonitor(ID);
+
+    // reload to fix mirrors
+    g_pConfigManager->m_bWantsMonitorReload = true;
+
+    Debug::log(LOG, "Monitor {} data dump: res {:X}@{:.2f}Hz, scale {:.2f}, transform {}, pos {:X}, 10b {}", szName, vecPixelSize, refreshRate, scale, (int)transform, vecPosition,
+               (int)enabled10bit);
+
+    EMIT_HOOK_EVENT("monitorLayoutChanged", nullptr);
+
+    events.modeChanged.emit();
+
+    return true;
+}
+
 void CMonitor::addDamage(const pixman_region32_t* rg) {
    static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
@@ -370,18 +778,18 @@ void CMonitor::addDamage(const pixman_region32_t* rg) {
        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }

-void CMonitor::addDamage(const CRegion* rg) {
-    addDamage(const_cast<CRegion*>(rg)->pixman());
+void CMonitor::addDamage(const CRegion& rg) {
+    addDamage(const_cast<CRegion*>(&rg)->pixman());
 }

-void CMonitor::addDamage(const CBox* box) {
+void CMonitor::addDamage(const CBox& box) {
    static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
        damage.damageEntire();
        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
    }

-    if (damage.damage(*box))
+    if (damage.damage(box))
        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }

@@ -412,7 +820,7 @@ bool CMonitor::matchesStaticSelector(const std::string& selector) const {
        // match by description
        const auto DESCRIPTIONSELECTOR = selector.substr(5);

-        return DESCRIPTIONSELECTOR == szShortDescription || DESCRIPTIONSELECTOR == szDescription;
+        return szDescription.starts_with(DESCRIPTIONSELECTOR) || szShortDescription.starts_with(DESCRIPTIONSELECTOR);
    } else {
        // match by selector
        return szName == selector;
@@ -530,7 +938,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {

        setupDefaultWS(RULE);

-        g_pHyprRenderer->applyMonitorRule(self.lock(), (SMonitorRule*)&RULE, true); // will apply the offset and stuff
+        applyMonitorRule((SMonitorRule*)&RULE, true); // will apply the offset and stuff
    } else {
        PHLMONITOR BACKUPMON = nullptr;
        for (auto const& m : g_pCompositor->m_vMonitors) {
@@ -740,16 +1148,16 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
            if (w->m_bIsFloating && !VECINRECT(MIDDLE, vecPosition.x, vecPosition.y, vecPosition.x + vecSize.x, vecPosition.y + vecSize.y) && !w->isX11OverrideRedirect()) {
                // if it's floating and the middle isnt on the current mon, move it to the center
                const auto PMONFROMMIDDLE = g_pCompositor->getMonitorFromVector(MIDDLE);
-                Vector2D   pos            = w->m_vRealPosition.goal();
+                Vector2D   pos            = w->m_vRealPosition->goal();
                if (!VECINRECT(MIDDLE, PMONFROMMIDDLE->vecPosition.x, PMONFROMMIDDLE->vecPosition.y, PMONFROMMIDDLE->vecPosition.x + PMONFROMMIDDLE->vecSize.x,
                               PMONFROMMIDDLE->vecPosition.y + PMONFROMMIDDLE->vecSize.y)) {
                    // not on any monitor, center
-                    pos = middle() / 2.f - w->m_vRealSize.goal() / 2.f;
+                    pos = middle() / 2.f - w->m_vRealSize->goal() / 2.f;
                } else
                    pos = pos - PMONFROMMIDDLE->vecPosition + vecPosition;

-                w->m_vRealPosition = pos;
-                w->m_vPosition     = pos;
+                *w->m_vRealPosition = pos;
+                w->m_vPosition      = pos;
            }
        }
    }
@@ -782,6 +1190,29 @@ void CMonitor::moveTo(const Vector2D& pos) {
    vecPosition = pos;
 }

+SWorkspaceIDName CMonitor::getPrevWorkspaceIDName(const WORKSPACEID id) {
+    while (!prevWorkSpaces.empty()) {
+        const int PREVID = prevWorkSpaces.top();
+        prevWorkSpaces.pop();
+        if (PREVID == id) // skip same workspace
+            continue;
+
+        // recheck if previous workspace's was moved to another monitor
+        const auto ws = g_pCompositor->getWorkspaceByID(PREVID);
+        if (ws && ws->monitorID() == ID)
+            return {.id = PREVID, .name = ws->m_szName};
+    }
+
+    return {.id = WORKSPACE_INVALID};
+}
+
+void CMonitor::addPrevWorkspaceID(const WORKSPACEID id) {
+    if (!prevWorkSpaces.empty() && prevWorkSpaces.top() == id)
+        return;
+
+    prevWorkSpaces.emplace(id);
+}
+
 Vector2D CMonitor::middle() {
    return vecPosition + vecSize / 2.f;
 }
--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -1,11 +1,14 @@
 #pragma once

 #include "../defines.hpp"
+#include <stack>
 #include <vector>
+#include "../SharedDefs.hpp"
+#include "MiscFunctions.hpp"
 #include "WLClasses.hpp"
 #include <vector>
 #include <array>
-#include <memory>
+
 #include <xf86drmMode.h>
 #include "Timer.hpp"
 #include "math/Math.hpp"
@@ -30,7 +33,7 @@ struct SMonitorRule {
    Vector2D            resolution  = Vector2D(1280, 720);
    Vector2D            offset      = Vector2D(0, 0);
    float               scale       = 1;
-    float               refreshRate = 60;
+    float               refreshRate = 60; // Hz
    bool                disabled    = false;
    wl_output_transform transform   = WL_OUTPUT_TRANSFORM_NORMAL;
    std::string         mirrorOf    = "";
@@ -89,10 +92,8 @@ class CMonitor {
    CDamageRing                 damage;

    SP<Aquamarine::IOutput>     output;
-    float                       refreshRate     = 60;
-    int                         framesToSkip    = 0;
+    float                       refreshRate     = 60; // Hz
    int                         forceFullFrames = 0;
-    bool                        noFrameSchedule = false;
    bool                        scheduledRecalc = false;
    wl_output_transform         transform       = WL_OUTPUT_TRANSFORM_NORMAL;
    float                       xwaylandScale   = 1.f;
@@ -163,9 +164,10 @@ class CMonitor {
    // methods
    void        onConnect(bool noRule);
    void        onDisconnect(bool destroy = false);
+    bool        applyMonitorRule(SMonitorRule* pMonitorRule, bool force = false);
    void        addDamage(const pixman_region32_t* rg);
-    void        addDamage(const CRegion* rg);
-    void        addDamage(const CBox* box);
+    void        addDamage(const CRegion& rg);
+    void        addDamage(const CBox& box);
    bool        shouldSkipScheduleFrameOnMouseEvent();
    void        setMirror(const std::string&);
    bool        isMirror();
@@ -190,6 +192,7 @@ class CMonitor {

    bool        m_bEnabled             = false;
    bool        m_bRenderingInitPassed = false;
+    WP<CWindow> m_previousFSWindow;

    // For the list lookup

@@ -197,11 +200,16 @@ class CMonitor {
        return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName;
    }

-  private:
-    void        setupDefaultWS(const SMonitorRule&);
-    WORKSPACEID findAvailableDefaultWS();
+    // workspace previous per monitor functionality
+    SWorkspaceIDName getPrevWorkspaceIDName(const WORKSPACEID id);
+    void             addPrevWorkspaceID(const WORKSPACEID id);

-    bool        doneScheduled = false;
+  private:
+    void                    setupDefaultWS(const SMonitorRule&);
+    WORKSPACEID             findAvailableDefaultWS();
+
+    bool                    doneScheduled = false;
+    std::stack<WORKSPACEID> prevWorkSpaces;

    struct {
        CHyprSignalListener frame;
--- a/src/helpers/SdDaemon.cpp
+++ b/src/helpers/SdDaemon.cpp
@@ -1,7 +1,7 @@
 #include "SdDaemon.hpp"
+#include "memory/Memory.hpp"

 #include <memory>
-
 #include <fcntl.h>
 #include <unistd.h>
 #include <cerrno>
--- a/src/helpers/WLClasses.hpp
+++ b/src/helpers/WLClasses.hpp
@@ -1,14 +1,13 @@
 #pragma once

-#include "../events/Events.hpp"
 #include "../defines.hpp"
-#include "../desktop/Window.hpp"
 #include "../desktop/Subsurface.hpp"
 #include "../desktop/Popup.hpp"
-#include "AnimatedVariable.hpp"
 #include "../desktop/WLSurface.hpp"
+#include "../macros.hpp"
+#include "../desktop/DesktopTypes.hpp"
+#include "memory/Memory.hpp"
 #include "signal/Signal.hpp"
-#include "math/Math.hpp"

 class CMonitor;
 class IPointer;
@@ -17,47 +16,6 @@ class CWLSurfaceResource;

 AQUAMARINE_FORWARD(ISwitch);

-struct SRenderData {
-    PHLMONITORREF pMonitor;
-    timespec*     when;
-    double        x, y;
-
-    // for iters
-    void*                  data    = nullptr;
-    SP<CWLSurfaceResource> surface = nullptr;
-    double                 w, h;
-
-    // for rounding
-    bool dontRound = true;
-
-    // for fade
-    float fadeAlpha = 1.f;
-
-    // for alpha settings
-    float alpha = 1.f;
-
-    // for decorations (border)
-    bool decorate = false;
-
-    // for custom round values
-    int rounding = -1; // -1 means not set
-
-    // for blurring
-    bool blur                  = false;
-    bool blockBlurOptimization = false;
-
-    // only for windows, not popups
-    bool squishOversized = true;
-
-    // for calculating UV
-    PHLWINDOW pWindow;
-
-    bool      popup = false;
-
-    // counts how many surfaces this pass has rendered
-    int surfaceCounter = 0;
-};
-
 struct SSwipeGesture {
    PHLWORKSPACE  pWorkspaceBegin = nullptr;

--- a/src/helpers/Watchdog.cpp
+++ b/src/helpers/Watchdog.cpp
@@ -14,7 +14,7 @@ CWatchdog::~CWatchdog() {

 CWatchdog::CWatchdog() : m_iMainThreadPID(pthread_self()) {

-    m_pWatchdog = std::make_unique<std::thread>([this] {
+    m_pWatchdog = makeUnique<std::thread>([this] {
        static auto PTIMEOUT = CConfigValue<Hyprlang::INT>("debug:watchdog_timeout");

        m_bWatchdogInitialized = true;
--- a/src/helpers/Watchdog.hpp
+++ b/src/helpers/Watchdog.hpp
@@ -1,6 +1,6 @@
 #pragma once

-#include <memory>
+#include "memory/Memory.hpp"
 #include <chrono>
 #include <thread>
 #include <condition_variable>
@@ -24,11 +24,11 @@ class CWatchdog {
    std::atomic<bool>                              m_bWatching  = false;
    std::atomic<bool>                              m_bWillWatch = false;

-    std::unique_ptr<std::thread>                   m_pWatchdog;
+    UP<std::thread>                                m_pWatchdog;
    std::mutex                                     m_mWatchdogMutex;
    std::atomic<bool>                              m_bNotified   = false;
    std::atomic<bool>                              m_bExitThread = false;
    std::condition_variable                        m_cvWatchdogCondition;
 };

-inline std::unique_ptr<CWatchdog> g_pWatchdog;
+inline UP<CWatchdog> g_pWatchdog;
--- a/src/helpers/fs/FsUtils.cpp
+++ b/src/helpers/fs/FsUtils.cpp
@@ -0,0 +1,107 @@
+#include "FsUtils.hpp"
+#include "../../debug/Log.hpp"
+
+#include <cstdlib>
+#include <filesystem>
+
+#include <hyprutils/string/String.hpp>
+#include <hyprutils/string/VarList.hpp>
+using namespace Hyprutils::String;
+
+std::optional<std::string> NFsUtils::getDataHome() {
+    const auto  DATA_HOME = getenv("XDG_DATA_HOME");
+
+    std::string dataRoot;
+
+    if (!DATA_HOME) {
+        const auto HOME = getenv("HOME");
+
+        if (!HOME) {
+            Debug::log(ERR, "FsUtils::getDataHome: can't get data home: no $HOME or $XDG_DATA_HOME");
+            return std::nullopt;
+        }
+
+        dataRoot = HOME + std::string{"/.local/share/"};
+    } else
+        dataRoot = DATA_HOME + std::string{"/"};
+
+    std::error_code ec;
+    if (!std::filesystem::exists(dataRoot, ec) || ec) {
+        Debug::log(ERR, "FsUtils::getDataHome: can't get data home: inaccessible / missing");
+        return std::nullopt;
+    }
+
+    dataRoot += "hyprland/";
+
+    if (!std::filesystem::exists(dataRoot, ec) || ec) {
+        Debug::log(LOG, "FsUtils::getDataHome: no hyprland data home, creating.");
+        std::filesystem::create_directory(dataRoot, ec);
+        if (ec) {
+            Debug::log(ERR, "FsUtils::getDataHome: can't create new data home for hyprland");
+            return std::nullopt;
+        }
+        std::filesystem::permissions(dataRoot, std::filesystem::perms::owner_read | std::filesystem::perms::owner_write | std::filesystem::perms::owner_exec, ec);
+        if (ec)
+            Debug::log(WARN, "FsUtils::getDataHome: couldn't set perms on hyprland data store. Proceeding anyways.");
+    }
+
+    if (!std::filesystem::exists(dataRoot, ec) || ec) {
+        Debug::log(ERR, "FsUtils::getDataHome: no hyprland data home, failed to create.");
+        return std::nullopt;
+    }
+
+    return dataRoot;
+}
+
+std::optional<std::string> NFsUtils::readFileAsString(const std::string& path) {
+    std::error_code ec;
+
+    if (!std::filesystem::exists(path, ec) || ec)
+        return std::nullopt;
+
+    std::ifstream file(path);
+    if (!file.good())
+        return std::nullopt;
+
+    return trim(std::string((std::istreambuf_iterator<char>(file)), (std::istreambuf_iterator<char>())));
+}
+
+bool NFsUtils::writeToFile(const std::string& path, const std::string& content) {
+    std::ofstream of(path, std::ios::trunc);
+    if (!of.good()) {
+        Debug::log(ERR, "CVersionKeeperManager: couldn't open an ofstream for writing the version file.");
+        return false;
+    }
+
+    of << content;
+    of.close();
+
+    return true;
+}
+
+bool NFsUtils::executableExistsInPath(const std::string& exe) {
+    if (!getenv("PATH"))
+        return false;
+
+    static CVarList paths(getenv("PATH"), 0, ':', true);
+
+    for (auto& p : paths) {
+        std::string     path = p + std::string{"/"} + exe;
+        std::error_code ec;
+        if (!std::filesystem::exists(path, ec) || ec)
+            continue;
+
+        if (!std::filesystem::is_regular_file(path, ec) || ec)
+            continue;
+
+        auto stat = std::filesystem::status(path, ec);
+        if (ec)
+            continue;
+
+        auto perms = stat.permissions();
+
+        return std::filesystem::perms::none != (perms & std::filesystem::perms::others_exec);
+    }
+
+    return false;
+}
--- a/src/helpers/fs/FsUtils.hpp
+++ b/src/helpers/fs/FsUtils.hpp
@@ -0,0 +1,15 @@
+#pragma once
+#include <optional>
+#include <string>
+
+namespace NFsUtils {
+    // Returns the path to the hyprland directory in data home.
+    std::optional<std::string> getDataHome();
+
+    std::optional<std::string> readFileAsString(const std::string& path);
+
+    // overwrites the file if exists
+    bool writeToFile(const std::string& path, const std::string& content);
+
+    bool executableExistsInPath(const std::string& exe);
+};
--- a/src/helpers/memory/Memory.hpp
+++ b/src/helpers/memory/Memory.hpp
@@ -7,4 +7,4 @@ using namespace Hyprutils::Memory;

 #define SP Hyprutils::Memory::CSharedPointer
 #define WP Hyprutils::Memory::CWeakPointer
-#define UP std::unique_ptr
+#define UP Hyprutils::Memory::CUniquePointer
--- a/src/hyprerror/HyprError.cpp
+++ b/src/hyprerror/HyprError.cpp
@@ -2,13 +2,16 @@
 #include "HyprError.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
+#include "../render/pass/TexPassElement.hpp"
+#include "../managers/AnimationManager.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/HookSystemManager.hpp"

 #include <hyprutils/utils/ScopeGuard.hpp>
-using namespace Hyprutils::Utils;
+using namespace Hyprutils::Animation;

 CHyprError::CHyprError() {
-    m_fFadeOpacity.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), AVARDAMAGE_NONE);
-    m_fFadeOpacity.registerVar();
+    g_pAnimationManager->createAnimation(0.f, m_fFadeOpacity, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), AVARDAMAGE_NONE);

    static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
        if (!m_bIsCreated)
@@ -22,16 +25,14 @@ CHyprError::CHyprError() {
        if (!m_bIsCreated)
            return;

-        if (m_fFadeOpacity.isBeingAnimated() || m_bMonitorChanged)
-            g_pHyprRenderer->damageBox(&m_bDamageBox);
+        if (m_fFadeOpacity->isBeingAnimated() || m_bMonitorChanged)
+            g_pHyprRenderer->damageBox(m_bDamageBox);
    });

    m_pTexture = makeShared<CTexture>();
 }

-CHyprError::~CHyprError() {
-    m_fFadeOpacity.unregister();
-}
+CHyprError::~CHyprError() = default;

 void CHyprError::queueCreate(std::string message, const CHyprColor& color) {
    m_szQueued = message;
@@ -42,10 +43,10 @@ void CHyprError::createQueued() {
    if (m_bIsCreated)
        m_pTexture->destroyTexture();

-    m_fFadeOpacity.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
+    m_fFadeOpacity->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));

-    m_fFadeOpacity.setValueAndWarp(0.f);
-    m_fFadeOpacity = 1.f;
+    m_fFadeOpacity->setValueAndWarp(0.f);
+    *m_fFadeOpacity = 1.f;

    const auto PMONITOR = g_pCompositor->m_vMonitors.front();

@@ -175,8 +176,8 @@ void CHyprError::draw() {
    }

    if (m_bQueuedDestroy) {
-        if (!m_fFadeOpacity.isBeingAnimated()) {
-            if (m_fFadeOpacity.value() == 0.f) {
+        if (!m_fFadeOpacity->isBeingAnimated()) {
+            if (m_fFadeOpacity->value() == 0.f) {
                m_bQueuedDestroy = false;
                m_pTexture->destroyTexture();
                m_bIsCreated = false;
@@ -188,8 +189,8 @@ void CHyprError::draw() {

                return;
            } else {
-                m_fFadeOpacity.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
-                m_fFadeOpacity = 0.f;
+                m_fFadeOpacity->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
+                *m_fFadeOpacity = 0.f;
            }
        }
    }
@@ -201,12 +202,17 @@ void CHyprError::draw() {
    m_bDamageBox.x = (int)PMONITOR->vecPosition.x;
    m_bDamageBox.y = (int)PMONITOR->vecPosition.y;

-    if (m_fFadeOpacity.isBeingAnimated() || m_bMonitorChanged)
-        g_pHyprRenderer->damageBox(&m_bDamageBox);
+    if (m_fFadeOpacity->isBeingAnimated() || m_bMonitorChanged)
+        g_pHyprRenderer->damageBox(m_bDamageBox);

    m_bMonitorChanged = false;

-    g_pHyprOpenGL->renderTexture(m_pTexture, &monbox, m_fFadeOpacity.value(), 0);
+    CTexPassElement::SRenderData data;
+    data.tex = m_pTexture;
+    data.box = monbox;
+    data.a   = m_fFadeOpacity->value();
+
+    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }

 void CHyprError::destroy() {
--- a/src/hyprerror/HyprError.hpp
+++ b/src/hyprerror/HyprError.hpp
@@ -19,17 +19,17 @@ class CHyprError {
    float height(); // logical

  private:
-    void                     createQueued();
-    std::string              m_szQueued = "";
-    CHyprColor               m_cQueued;
-    bool                     m_bQueuedDestroy = false;
-    bool                     m_bIsCreated     = false;
-    SP<CTexture>             m_pTexture;
-    CAnimatedVariable<float> m_fFadeOpacity;
-    CBox                     m_bDamageBox  = {0, 0, 0, 0};
-    float                    m_fLastHeight = 0.F;
+    void              createQueued();
+    std::string       m_szQueued = "";
+    CHyprColor        m_cQueued;
+    bool              m_bQueuedDestroy = false;
+    bool              m_bIsCreated     = false;
+    SP<CTexture>      m_pTexture;
+    PHLANIMVAR<float> m_fFadeOpacity;
+    CBox              m_bDamageBox  = {0, 0, 0, 0};
+    float             m_fLastHeight = 0.F;

-    bool                     m_bMonitorChanged = false;
+    bool              m_bMonitorChanged = false;
 };

-inline std::unique_ptr<CHyprError> g_pHyprError; // This is a full-screen error. Treat it with respect, and there can only be one at a time.
+inline UP<CHyprError> g_pHyprError; // This is a full-screen error. Treat it with respect, and there can only be one at a time.
--- a/src/layout/DwindleLayout.cpp
+++ b/src/layout/DwindleLayout.cpp
@@ -2,6 +2,10 @@
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../render/decorations/CHyprGroupBarDecoration.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/EventManager.hpp"

 void SDwindleNodeData::recalcSizePosRecursive(bool force, bool horizontalOverride, bool verticalOverride) {
    if (children[0]) {
@@ -38,14 +42,6 @@ void SDwindleNodeData::recalcSizePosRecursive(bool force, bool horizontalOverrid
    }
 }

-void SDwindleNodeData::getAllChildrenRecursive(std::vector<SDwindleNodeData*>* pVec) {
-    if (children[0]) {
-        children[0]->getAllChildrenRecursive(pVec);
-        children[1]->getAllChildrenRecursive(pVec);
-    } else
-        pVec->push_back(this);
-}
-
 int CHyprDwindleLayout::getNodesOnWorkspace(const WORKSPACEID& id) {
    int no = 0;
    for (auto const& n : m_lDwindleNodesData) {
@@ -109,8 +105,8 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
                break;
            }
        }
-    } else
-        PMONITOR = g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_pMonitor.lock();
+    } else if (const auto WS = g_pCompositor->getWorkspaceByID(pNode->workspaceID); WS)
+        PMONITOR = WS->m_pMonitor.lock();

    if (!PMONITOR) {
        Debug::log(ERR, "Orphaned Node {}!!", pNode);
@@ -200,25 +196,25 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
        CBox        wb = {calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f, calcSize * *PSCALEFACTOR};
        wb.round(); // avoid rounding mess

-        PWINDOW->m_vRealPosition = wb.pos();
-        PWINDOW->m_vRealSize     = wb.size();
+        *PWINDOW->m_vRealPosition = wb.pos();
+        *PWINDOW->m_vRealSize     = wb.size();

-        g_pXWaylandManager->setWindowSize(PWINDOW, wb.size());
+        PWINDOW->sendWindowSize(wb.size());
    } else {
        CBox wb = {calcPos, calcSize};
        wb.round(); // avoid rounding mess

-        PWINDOW->m_vRealSize     = wb.size();
-        PWINDOW->m_vRealPosition = wb.pos();
+        *PWINDOW->m_vRealSize     = wb.size();
+        *PWINDOW->m_vRealPosition = wb.pos();

-        g_pXWaylandManager->setWindowSize(PWINDOW, wb.size());
+        PWINDOW->sendWindowSize(wb.size());
    }

    if (force) {
        g_pHyprRenderer->damageWindow(PWINDOW);

-        PWINDOW->m_vRealPosition.warp();
-        PWINDOW->m_vRealSize.warp();
+        PWINDOW->m_vRealPosition->warp();
+        PWINDOW->m_vRealSize->warp();

        g_pHyprRenderer->damageWindow(PWINDOW);
    }
@@ -516,8 +512,8 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
        const auto PFULLWINDOW = pWorkspace->getFullscreenWindow();

        if (pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) {
-            PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition;
-            PFULLWINDOW->m_vRealSize     = PMONITOR->vecSize;
+            *PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition;
+            *PFULLWINDOW->m_vRealSize     = PMONITOR->vecSize;
        } else if (pWorkspace->m_efFullscreenMode == FSMODE_MAXIMIZED) {
            SDwindleNodeData fakeNode;
            fakeNode.pWindow         = PFULLWINDOW;
@@ -562,8 +558,8 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
    const auto PNODE = getNodeFromWindow(PWINDOW);

    if (!PNODE) {
-        PWINDOW->m_vRealSize =
-            (PWINDOW->m_vRealSize.goal() + pixResize)
+        *PWINDOW->m_vRealSize =
+            (PWINDOW->m_vRealSize->goal() + pixResize)
                .clamp(PWINDOW->m_sWindowData.minSize.valueOr(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), PWINDOW->m_sWindowData.maxSize.valueOr(Vector2D{INFINITY, INFINITY}));
        PWINDOW->updateWindowDecos();
        return;
@@ -583,7 +579,7 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
        if (!m_PseudoDragFlags.started) {
            m_PseudoDragFlags.started = true;

-            const auto pseudoSize  = PWINDOW->m_vRealSize.goal();
+            const auto pseudoSize  = PWINDOW->m_vRealSize->goal();
            const auto mouseOffset = g_pInputManager->getMouseCoordsInternal() - (PNODE->box.pos() + ((PNODE->box.size() / 2) - (pseudoSize / 2)));

            if (mouseOffset.x > 0 && mouseOffset.x < pseudoSize.x && mouseOffset.y > 0 && mouseOffset.y < pseudoSize.y) {
@@ -751,10 +747,10 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu

    // save position and size if floating
    if (pWindow->m_bIsFloating && CURRENT_EFFECTIVE_MODE == FSMODE_NONE) {
-        pWindow->m_vLastFloatingSize     = pWindow->m_vRealSize.goal();
-        pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition.goal();
-        pWindow->m_vPosition             = pWindow->m_vRealPosition.goal();
-        pWindow->m_vSize                 = pWindow->m_vRealSize.goal();
+        pWindow->m_vLastFloatingSize     = pWindow->m_vRealSize->goal();
+        pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition->goal();
+        pWindow->m_vPosition             = pWindow->m_vRealPosition->goal();
+        pWindow->m_vSize                 = pWindow->m_vRealSize->goal();
    }

    if (EFFECTIVE_MODE == FSMODE_NONE) {
@@ -764,8 +760,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu
            applyNodeDataToWindow(PNODE);
        else {
            // get back its' dimensions from position and size
-            pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
-            pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
+            *pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
+            *pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;

            pWindow->unsetWindowData(PRIORITY_LAYOUT);
            pWindow->updateWindowData();
@@ -773,8 +769,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu
    } else {
        // apply new pos and size being monitors' box
        if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) {
-            pWindow->m_vRealPosition = PMONITOR->vecPosition;
-            pWindow->m_vRealSize     = PMONITOR->vecSize;
+            *pWindow->m_vRealPosition = PMONITOR->vecPosition;
+            *pWindow->m_vRealSize     = PMONITOR->vecSize;
        } else {
            // This is a massive hack.
            // We make a fake "only" node and apply
@@ -804,15 +800,6 @@ void CHyprDwindleLayout::recalculateWindow(PHLWINDOW pWindow) {
    PNODE->recalcSizePosRecursive();
 }

-static void addToVectorRecursive(std::vector<SDwindleNodeData*>* pVec, std::vector<SDwindleNodeData*>* pParents, SDwindleNodeData* node) {
-    if (node->isNode) {
-        pParents->emplace_back(node);
-        addToVectorRecursive(pVec, pParents, node->children[0]);
-        addToVectorRecursive(pVec, pParents, node->children[1]);
-    } else
-        pVec->emplace_back(node);
-}
-
 SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(PHLWINDOW pWindow) {
    // window should be valid, insallah
    SWindowRenderLayoutHints hints;
@@ -860,6 +847,15 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
        pWindow->m_pMonitor = PMONITORFOCAL;
    }

+    pWindow->updateGroupOutputs();
+    if (!pWindow->m_sGroupData.pNextWindow.expired()) {
+        PHLWINDOW next = pWindow->m_sGroupData.pNextWindow.lock();
+        while (next != pWindow) {
+            next->updateToplevel();
+            next = next->m_sGroupData.pNextWindow.lock();
+        }
+    }
+
    onWindowCreatedTiling(pWindow);

    m_vOverrideFocalPoint.reset();
--- a/src/layout/DwindleLayout.hpp
+++ b/src/layout/DwindleLayout.hpp
@@ -39,7 +39,6 @@ struct SDwindleNodeData {
    }

    void                recalcSizePosRecursive(bool force = false, bool horizontalOverride = false, bool verticalOverride = false);
-    void                getAllChildrenRecursive(std::vector<SDwindleNodeData*>*);
    CHyprDwindleLayout* layout = nullptr;
 };

--- a/src/layout/IHyprLayout.cpp
+++ b/src/layout/IHyprLayout.cpp
@@ -7,10 +7,14 @@
 #include "../protocols/XDGShell.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../xwayland/XSurface.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/EventManager.hpp"
+#include "../managers/HookSystemManager.hpp"

 void IHyprLayout::onWindowCreated(PHLWINDOW pWindow, eDirection direction) {
-    CBox desiredGeometry = {};
-    g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
+    CBox desiredGeometry = g_pXWaylandManager->getGeometryForWindow(pWindow);

    if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
        const auto PMONITOR          = pWindow->m_pMonitor.lock();
@@ -86,9 +90,8 @@ void IHyprLayout::onWindowRemovedFloating(PHLWINDOW pWindow) {

 void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {

-    CBox desiredGeometry = {0};
-    g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
-    const auto PMONITOR = pWindow->m_pMonitor.lock();
+    CBox       desiredGeometry = g_pXWaylandManager->getGeometryForWindow(pWindow);
+    const auto PMONITOR        = pWindow->m_pMonitor.lock();

    if (pWindow->m_bIsX11) {
        Vector2D xy       = {desiredGeometry.x, desiredGeometry.y};
@@ -106,7 +109,7 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {

    if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
        const auto PWINDOWSURFACE = pWindow->m_pWLSurface->resource();
-        pWindow->m_vRealSize      = PWINDOWSURFACE->current.size;
+        *pWindow->m_vRealSize     = PWINDOWSURFACE->current.size;

        if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_bIsX11 &&
            pWindow->isX11OverrideRedirect()) { // XDG windows should be fine. TODO: check for weird atoms?
@@ -115,23 +118,23 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
        }

        // reject any windows with size <= 5x5
-        if (pWindow->m_vRealSize.goal().x <= 5 || pWindow->m_vRealSize.goal().y <= 5)
-            pWindow->m_vRealSize = PMONITOR->vecSize / 2.f;
+        if (pWindow->m_vRealSize->goal().x <= 5 || pWindow->m_vRealSize->goal().y <= 5)
+            *pWindow->m_vRealSize = PMONITOR->vecSize / 2.f;

        if (pWindow->m_bIsX11 && pWindow->isX11OverrideRedirect()) {

            if (pWindow->m_pXWaylandSurface->geometry.x != 0 && pWindow->m_pXWaylandSurface->geometry.y != 0)
-                pWindow->m_vRealPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_pXWaylandSurface->geometry.pos());
+                *pWindow->m_vRealPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_pXWaylandSurface->geometry.pos());
            else
-                pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goal().x) / 2.f,
-                                                    PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goal().y) / 2.f);
+                *pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize->goal().x) / 2.f,
+                                                     PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize->goal().y) / 2.f);
        } else {
-            pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goal().x) / 2.f,
-                                                PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goal().y) / 2.f);
+            *pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize->goal().x) / 2.f,
+                                                 PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize->goal().y) / 2.f);
        }
    } else {
        // we respect the size.
-        pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
+        *pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);

        // check if it's on the correct monitor!
        Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f;
@@ -150,35 +153,35 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
        if ((desiredGeometry.x == 0 && desiredGeometry.y == 0) || !visible || !pWindow->m_bIsX11) {
            // if the pos isn't set, fall back to the center placement if it's not a child, otherwise middle of parent if available
            if (!pWindow->m_bIsX11 && pWindow->m_pXDGSurface->toplevel->parent && validMapped(pWindow->m_pXDGSurface->toplevel->parent->window))
-                pWindow->m_vRealPosition = pWindow->m_pXDGSurface->toplevel->parent->window->m_vRealPosition.goal() +
-                    pWindow->m_pXDGSurface->toplevel->parent->window->m_vRealSize.goal() / 2.F - desiredGeometry.size() / 2.F;
+                *pWindow->m_vRealPosition = pWindow->m_pXDGSurface->toplevel->parent->window->m_vRealPosition->goal() +
+                    pWindow->m_pXDGSurface->toplevel->parent->window->m_vRealSize->goal() / 2.F - desiredGeometry.size() / 2.F;
            else
-                pWindow->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.F - desiredGeometry.size() / 2.F;
+                *pWindow->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.F - desiredGeometry.size() / 2.F;
        } else {
            // if it is, we respect where it wants to put itself, but apply monitor offset if outside
            // most of these are popups

            if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID)
-                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition;
+                *pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition;
            else
-                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
+                *pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
        }
    }

    if (*PXWLFORCESCALEZERO && pWindow->m_bIsX11)
-        pWindow->m_vRealSize = pWindow->m_vRealSize.goal() / PMONITOR->scale;
+        *pWindow->m_vRealSize = pWindow->m_vRealSize->goal() / PMONITOR->scale;

    if (pWindow->m_bX11DoesntWantBorders || (pWindow->m_bIsX11 && pWindow->isX11OverrideRedirect())) {
-        pWindow->m_vRealPosition.warp();
-        pWindow->m_vRealSize.warp();
+        pWindow->m_vRealPosition->warp();
+        pWindow->m_vRealSize->warp();
    }

    if (!pWindow->isX11OverrideRedirect()) {
-        g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goal());
+        pWindow->sendWindowSize(pWindow->m_vRealSize->goal());

        g_pCompositor->changeWindowZOrder(pWindow, true);
    } else {
-        pWindow->m_vPendingReportedSize = pWindow->m_vRealSize.goal();
+        pWindow->m_vPendingReportedSize = pWindow->m_vRealSize->goal();
        pWindow->m_vReportedSize        = pWindow->m_vPendingReportedSize;
    }
 }
@@ -205,11 +208,12 @@ bool IHyprLayout::onWindowCreatedAutoGroup(PHLWINDOW pWindow) {
        (*USECURRPOS ? OPENINGON : OPENINGON->getGroupTail())->insertWindowToGroup(pWindow);

        OPENINGON->setGroupCurrent(pWindow);
+        pWindow->applyGroupRules();
        pWindow->updateWindowDecos();
        recalculateWindow(pWindow);

        if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
-            pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow));
+            pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));

        return true;
    }
@@ -249,18 +253,18 @@ void IHyprLayout::onBeginDragWindow() {

    if (!DRAGGINGWINDOW->m_bIsFloating) {
        if (g_pInputManager->dragMode == MBIND_MOVE) {
-            DRAGGINGWINDOW->m_vLastFloatingSize = (DRAGGINGWINDOW->m_vRealSize.goal() * 0.8489).clamp(Vector2D{5, 5}, Vector2D{}).floor();
+            DRAGGINGWINDOW->m_vLastFloatingSize = (DRAGGINGWINDOW->m_vRealSize->goal() * 0.8489).clamp(Vector2D{5, 5}, Vector2D{}).floor();
            changeWindowFloatingMode(DRAGGINGWINDOW);
            DRAGGINGWINDOW->m_bIsFloating    = true;
            DRAGGINGWINDOW->m_bDraggingTiled = true;

-            DRAGGINGWINDOW->m_vRealPosition = g_pInputManager->getMouseCoordsInternal() - DRAGGINGWINDOW->m_vRealSize.goal() / 2.f;
+            *DRAGGINGWINDOW->m_vRealPosition = g_pInputManager->getMouseCoordsInternal() - DRAGGINGWINDOW->m_vRealSize->goal() / 2.f;
        }
    }

    m_vBeginDragXY         = g_pInputManager->getMouseCoordsInternal();
-    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition.goal();
-    m_vBeginDragSizeXY     = DRAGGINGWINDOW->m_vRealSize.goal();
+    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition->goal();
+    m_vBeginDragSizeXY     = DRAGGINGWINDOW->m_vRealSize->goal();
    m_vLastDragXY          = m_vBeginDragXY;

    // get the grab corner
@@ -347,10 +351,10 @@ void IHyprLayout::onEndDragWindow() {
                if (DRAGGINGWINDOW->m_sGroupData.pNextWindow) {
                    PHLWINDOW next = DRAGGINGWINDOW->m_sGroupData.pNextWindow.lock();
                    while (next != DRAGGINGWINDOW) {
-                        next->m_bIsFloating   = pWindow->m_bIsFloating;          // match the floating state of group members
-                        next->m_vRealSize     = pWindow->m_vRealSize.goal();     // match the size of group members
-                        next->m_vRealPosition = pWindow->m_vRealPosition.goal(); // match the position of group members
-                        next                  = next->m_sGroupData.pNextWindow.lock();
+                        next->m_bIsFloating    = pWindow->m_bIsFloating;           // match the floating state of group members
+                        *next->m_vRealSize     = pWindow->m_vRealSize->goal();     // match the size of group members
+                        *next->m_vRealPosition = pWindow->m_vRealPosition->goal(); // match the position of group members
+                        next                   = next->m_sGroupData.pNextWindow.lock();
                    }
                }

@@ -359,15 +363,16 @@ void IHyprLayout::onEndDragWindow() {
                DRAGGINGWINDOW->m_bDraggingTiled    = false;

                if (pWindow->m_bIsFloating)
-                    g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, pWindow->m_vRealSize.goal()); // match the size of the window
+                    DRAGGINGWINDOW->sendWindowSize(DRAGGINGWINDOW->m_vRealSize->goal()); // match the size of the window

                static auto USECURRPOS = CConfigValue<Hyprlang::INT>("group:insert_after_current");
                (*USECURRPOS ? pWindow : pWindow->getGroupTail())->insertWindowToGroup(DRAGGINGWINDOW);
                pWindow->setGroupCurrent(DRAGGINGWINDOW);
+                DRAGGINGWINDOW->applyGroupRules();
                DRAGGINGWINDOW->updateWindowDecos();

                if (!DRAGGINGWINDOW->getDecorationByType(DECORATION_GROUPBAR))
-                    DRAGGINGWINDOW->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(DRAGGINGWINDOW));
+                    DRAGGINGWINDOW->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(DRAGGINGWINDOW));
            }
        }
    }
@@ -419,11 +424,13 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA
    SRange sourceY = {sourcePos.y, sourcePos.y + sourceSize.y};

    if (*SNAPWINDOWGAP) {
-        const double GAPSIZE = *SNAPWINDOWGAP;
-        const auto   WSID    = DRAGGINGWINDOW->workspaceID();
+        const double GAPSIZE       = *SNAPWINDOWGAP;
+        const auto   WSID          = DRAGGINGWINDOW->workspaceID();
+        const bool   HASFULLSCREEN = DRAGGINGWINDOW->m_pWorkspace && DRAGGINGWINDOW->m_pWorkspace->m_bHasFullscreenWindow;

        for (auto& other : g_pCompositor->m_vWindows) {
-            if (other == DRAGGINGWINDOW || other->workspaceID() != WSID || !other->m_bIsMapped || other->m_bFadingOut || other->isX11OverrideRedirect())
+            if ((HASFULLSCREEN && !other->m_bCreatedOverFullscreen) || other == DRAGGINGWINDOW || other->workspaceID() != WSID || !other->m_bIsMapped || other->m_bFadingOut ||
+                other->isX11OverrideRedirect())
                continue;

            const int    OTHERBORDERSIZE = other->getRealBorderSize();
@@ -455,22 +462,22 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA

            // corner snapping
            const double BORDERDIFF = OTHERBORDERSIZE - DRAGGINGBORDERSIZE;
-            if (snaps & (SNAP_LEFT | SNAP_RIGHT)) {
+            if (sourceX.start == SURFBX.end || SURFBX.start == sourceX.end) {
                const SRange SURFY = {SURF.y - BORDERDIFF, SURF.y + SURF.h + BORDERDIFF};
-                if (CORNER & (CORNER_TOPLEFT | CORNER_TOPRIGHT) && canSnap(sourceY.start, SURFY.start, GAPSIZE)) {
+                if (CORNER & (CORNER_TOPLEFT | CORNER_TOPRIGHT) && !(snaps & SNAP_UP) && canSnap(sourceY.start, SURFY.start, GAPSIZE)) {
                    SNAP(sourceY.start, sourceY.end, SURFY.start);
                    snaps |= SNAP_UP;
-                } else if (CORNER & (CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT) && canSnap(sourceY.end, SURFY.end, GAPSIZE)) {
+                } else if (CORNER & (CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT) && !(snaps & SNAP_DOWN) && canSnap(sourceY.end, SURFY.end, GAPSIZE)) {
                    SNAP(sourceY.end, sourceY.start, SURFY.end);
                    snaps |= SNAP_DOWN;
                }
            }
-            if (snaps & (SNAP_UP | SNAP_DOWN)) {
+            if (sourceY.start == SURFBY.end || SURFBY.start == sourceY.end) {
                const SRange SURFX = {SURF.x - BORDERDIFF, SURF.x + SURF.w + BORDERDIFF};
-                if (CORNER & (CORNER_TOPLEFT | CORNER_BOTTOMLEFT) && canSnap(sourceX.start, SURFX.start, GAPSIZE)) {
+                if (CORNER & (CORNER_TOPLEFT | CORNER_BOTTOMLEFT) && !(snaps & SNAP_LEFT) && canSnap(sourceX.start, SURFX.start, GAPSIZE)) {
                    SNAP(sourceX.start, sourceX.end, SURFX.start);
                    snaps |= SNAP_LEFT;
-                } else if (CORNER & (CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT) && canSnap(sourceX.end, SURFX.end, GAPSIZE)) {
+                } else if (CORNER & (CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT) && !(snaps & SNAP_RIGHT) && canSnap(sourceX.end, SURFX.end, GAPSIZE)) {
                    SNAP(sourceX.end, sourceX.start, SURFX.end);
                    snaps |= SNAP_RIGHT;
                }
@@ -589,7 +596,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
    if (g_pInputManager->dragMode == MBIND_MOVE) {

        Vector2D newPos  = m_vBeginDragPositionXY + DELTA;
-        Vector2D newSize = DRAGGINGWINDOW->m_vRealSize.goal();
+        Vector2D newSize = DRAGGINGWINDOW->m_vRealSize->goal();

        if (*SNAPENABLED && !DRAGGINGWINDOW->m_bDraggingTiled)
            performSnap(newPos, newSize, DRAGGINGWINDOW, MBIND_MOVE, -1, m_vBeginDragSizeXY);
@@ -598,11 +605,11 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
        wb.round();

        if (*PANIMATEMOUSE)
-            DRAGGINGWINDOW->m_vRealPosition = wb.pos();
+            *DRAGGINGWINDOW->m_vRealPosition = wb.pos();
        else
-            DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(wb.pos());
+            DRAGGINGWINDOW->m_vRealPosition->setValueAndWarp(wb.pos());

-        g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goal());
+        DRAGGINGWINDOW->sendWindowSize(DRAGGINGWINDOW->m_vRealSize->goal());
    } else if (g_pInputManager->dragMode == MBIND_RESIZE || g_pInputManager->dragMode == MBIND_RESIZE_FORCE_RATIO || g_pInputManager->dragMode == MBIND_RESIZE_BLOCK_RATIO) {
        if (DRAGGINGWINDOW->m_bIsFloating) {

@@ -667,21 +674,21 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
            wb.round();

            if (*PANIMATE) {
-                DRAGGINGWINDOW->m_vRealSize     = wb.size();
-                DRAGGINGWINDOW->m_vRealPosition = wb.pos();
+                *DRAGGINGWINDOW->m_vRealSize     = wb.size();
+                *DRAGGINGWINDOW->m_vRealPosition = wb.pos();
            } else {
-                DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(wb.size());
-                DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(wb.pos());
+                DRAGGINGWINDOW->m_vRealSize->setValueAndWarp(wb.size());
+                DRAGGINGWINDOW->m_vRealPosition->setValueAndWarp(wb.pos());
            }

-            g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goal());
+            DRAGGINGWINDOW->sendWindowSize(DRAGGINGWINDOW->m_vRealSize->goal());
        } else {
            resizeActiveWindow(TICKDELTA, m_eGrabbedCorner, DRAGGINGWINDOW);
        }
    }

    // get middle point
-    Vector2D middle = DRAGGINGWINDOW->m_vRealPosition.value() + DRAGGINGWINDOW->m_vRealSize.value() / 2.f;
+    Vector2D middle = DRAGGINGWINDOW->m_vRealPosition->value() + DRAGGINGWINDOW->m_vRealSize->value() / 2.f;

    // and check its monitor
    const auto PMONITOR = g_pCompositor->getMonitorFromVector(middle);
@@ -708,6 +715,8 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {

    pWindow->m_bPinned = false;

+    g_pHyprRenderer->damageWindow(pWindow, true);
+
    const auto TILED = isWindowTiled(pWindow);

    // event
@@ -715,7 +724,7 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
    EMIT_HOOK_EVENT("changeFloatingMode", pWindow);

    if (!TILED) {
-        const auto PNEWMON  = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.value() + pWindow->m_vRealSize.value() / 2.f);
+        const auto PNEWMON  = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition->value() + pWindow->m_vRealSize->value() / 2.f);
        pWindow->m_pMonitor = PNEWMON;
        pWindow->moveToWorkspace(PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace);
        pWindow->updateGroupOutputs();
@@ -726,12 +735,12 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
            g_pCompositor->setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE);

        // save real pos cuz the func applies the default 5,5 mid
-        const auto PSAVEDPOS  = pWindow->m_vRealPosition.goal();
-        const auto PSAVEDSIZE = pWindow->m_vRealSize.goal();
+        const auto PSAVEDPOS  = pWindow->m_vRealPosition->goal();
+        const auto PSAVEDSIZE = pWindow->m_vRealSize->goal();

        // if the window is pseudo, update its size
        if (!pWindow->m_bDraggingTiled)
-            pWindow->m_vPseudoSize = pWindow->m_vRealSize.goal();
+            pWindow->m_vPseudoSize = pWindow->m_vRealSize->goal();

        pWindow->m_vLastFloatingSize = PSAVEDSIZE;

@@ -740,8 +749,8 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {

        onWindowCreatedTiling(pWindow);

-        pWindow->m_vRealPosition.setValue(PSAVEDPOS);
-        pWindow->m_vRealSize.setValue(PSAVEDSIZE);
+        pWindow->m_vRealPosition->setValue(PSAVEDPOS);
+        pWindow->m_vRealSize->setValue(PSAVEDSIZE);

        // fix pseudo leaving artifacts
        g_pHyprRenderer->damageMonitor(pWindow->m_pMonitor.lock());
@@ -753,16 +762,16 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {

        g_pCompositor->changeWindowZOrder(pWindow, true);

-        CBox wb = {pWindow->m_vRealPosition.goal() + (pWindow->m_vRealSize.goal() - pWindow->m_vLastFloatingSize) / 2.f, pWindow->m_vLastFloatingSize};
+        CBox wb = {pWindow->m_vRealPosition->goal() + (pWindow->m_vRealSize->goal() - pWindow->m_vLastFloatingSize) / 2.f, pWindow->m_vLastFloatingSize};
        wb.round();

-        if (!(pWindow->m_bIsFloating && pWindow->m_bIsPseudotiled) && DELTALESSTHAN(pWindow->m_vRealSize.value().x, pWindow->m_vLastFloatingSize.x, 10) &&
-            DELTALESSTHAN(pWindow->m_vRealSize.value().y, pWindow->m_vLastFloatingSize.y, 10)) {
+        if (!(pWindow->m_bIsFloating && pWindow->m_bIsPseudotiled) && DELTALESSTHAN(pWindow->m_vRealSize->value().x, pWindow->m_vLastFloatingSize.x, 10) &&
+            DELTALESSTHAN(pWindow->m_vRealSize->value().y, pWindow->m_vLastFloatingSize.y, 10)) {
            wb = {wb.pos() + Vector2D{10, 10}, wb.size() - Vector2D{20, 20}};
        }

-        pWindow->m_vRealPosition = wb.pos();
-        pWindow->m_vRealSize     = wb.size();
+        *pWindow->m_vRealPosition = wb.pos();
+        *pWindow->m_vRealSize     = wb.size();

        pWindow->m_vSize     = wb.pos();
        pWindow->m_vPosition = wb.size();
@@ -777,8 +786,9 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
    }

    g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
-
    pWindow->updateToplevel();
+    pWindow->sendWindowSize(pWindow->m_vRealSize->goal());
+    g_pHyprRenderer->damageWindow(pWindow);
 }

 void IHyprLayout::moveActiveWindow(const Vector2D& delta, PHLWINDOW pWindow) {
@@ -794,7 +804,7 @@ void IHyprLayout::moveActiveWindow(const Vector2D& delta, PHLWINDOW pWindow) {

    PWINDOW->setAnimationsToMove();

-    PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.goal() + delta;
+    *PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition->goal() + delta;

    g_pHyprRenderer->damageWindow(PWINDOW);
 }
--- a/src/layout/IHyprLayout.hpp
+++ b/src/layout/IHyprLayout.hpp
@@ -8,7 +8,7 @@ class CGradientValueData;

 struct SWindowRenderLayoutHints {
    bool                isBorderGradient = false;
-    CGradientValueData* borderGradient;
+    CGradientValueData* borderGradient   = nullptr;
 };

 struct SLayoutMessageHeader {
--- a/src/layout/MasterLayout.cpp
+++ b/src/layout/MasterLayout.cpp
@@ -4,6 +4,10 @@
 #include "config/ConfigDataValues.hpp"
 #include <ranges>
 #include "../config/ConfigValue.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/LayoutManager.hpp"
+#include "../managers/EventManager.hpp"

 SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(PHLWINDOW pWindow) {
    for (auto& nd : m_lMasterNodesData) {
@@ -301,8 +305,8 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
        const auto PFULLWINDOW = pWorkspace->getFullscreenWindow();

        if (pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) {
-            PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition;
-            PFULLWINDOW->m_vRealSize     = PMONITOR->vecSize;
+            *PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition;
+            *PFULLWINDOW->m_vRealSize     = PMONITOR->vecSize;
        } else if (pWorkspace->m_efFullscreenMode == FSMODE_MAXIMIZED) {
            SMasterNodeData fakeNode;
            fakeNode.pWindow                = PFULLWINDOW;
@@ -325,11 +329,12 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
    if (!PMASTERNODE)
        return;

-    eOrientation orientation        = getDynamicOrientation(pWorkspace);
-    bool         centerMasterWindow = false;
-    static auto  ALWAYSCENTER       = CConfigValue<Hyprlang::INT>("master:always_center_master");
-    static auto  PIGNORERESERVED    = CConfigValue<Hyprlang::INT>("master:center_ignores_reserved");
-    static auto  PSMARTRESIZING     = CConfigValue<Hyprlang::INT>("master:smart_resizing");
+    eOrientation orientation         = getDynamicOrientation(pWorkspace);
+    bool         centerMasterWindow  = false;
+    static auto  SLAVECOUNTFORCENTER = CConfigValue<Hyprlang::INT>("master:slave_count_for_center_master");
+    static auto  CMSLAVESONRIGHT     = CConfigValue<Hyprlang::INT>("master:center_master_slaves_on_right");
+    static auto  PIGNORERESERVED     = CConfigValue<Hyprlang::INT>("master:center_ignores_reserved");
+    static auto  PSMARTRESIZING      = CConfigValue<Hyprlang::INT>("master:smart_resizing");

    const auto   MASTERS      = getMastersOnWorkspace(pWorkspace->m_iID);
    const auto   WINDOWS      = getNodesOnWorkspace(pWorkspace->m_iID);
@@ -338,10 +343,13 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
    const auto   WSPOS        = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;

    if (orientation == ORIENTATION_CENTER) {
-        if (STACKWINDOWS >= 2 || (*ALWAYSCENTER == 1)) {
+        if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) {
            centerMasterWindow = true;
        } else {
-            orientation = ORIENTATION_LEFT;
+            if (*CMSLAVESONRIGHT)
+                orientation = ORIENTATION_LEFT;
+            else
+                orientation = ORIENTATION_RIGHT;
        }
    }

@@ -515,15 +523,20 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
        float       nextY       = 0;
        float       nextYL      = 0;
        float       nextYR      = 0;
-        bool        onRight     = true;
+        bool        onRight     = *CMSLAVESONRIGHT;
+        int         slavesLeftL = 1 + (slavesLeft - 1) / 2;
+        int         slavesLeftR = slavesLeft - slavesLeftL;

-        int         slavesLeftR = 1 + (slavesLeft - 1) / 2;
-        int         slavesLeftL = slavesLeft - slavesLeftR;
+        if (*CMSLAVESONRIGHT) {
+            slavesLeftR = 1 + (slavesLeft - 1) / 2;
+            slavesLeftL = slavesLeft - slavesLeftR;
+        }

        const float slaveAverageHeightL     = WSSIZE.y / slavesLeftL;
        const float slaveAverageHeightR     = WSSIZE.y / slavesLeftR;
        float       slaveAccumulatedHeightL = 0;
        float       slaveAccumulatedHeightR = 0;
+
        if (*PSMARTRESIZING) {
            for (auto const& nd : m_lMasterNodesData) {
                if (nd.workspaceID != pWorkspace->m_iID || nd.isMaster)
@@ -536,7 +549,8 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
                }
                onRight = !onRight;
            }
-            onRight = true;
+
+            onRight = *CMSLAVESONRIGHT;
        }

        for (auto& nd : m_lMasterNodesData) {
@@ -662,25 +676,25 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
        CBox        wb = {calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f, calcSize * *PSCALEFACTOR};
        wb.round(); // avoid rounding mess

-        PWINDOW->m_vRealPosition = wb.pos();
-        PWINDOW->m_vRealSize     = wb.size();
+        *PWINDOW->m_vRealPosition = wb.pos();
+        *PWINDOW->m_vRealSize     = wb.size();

-        g_pXWaylandManager->setWindowSize(PWINDOW, wb.size());
+        PWINDOW->sendWindowSize(wb.size());
    } else {
        CBox wb = {calcPos, calcSize};
        wb.round(); // avoid rounding mess

-        PWINDOW->m_vRealPosition = wb.pos();
-        PWINDOW->m_vRealSize     = wb.size();
+        *PWINDOW->m_vRealPosition = wb.pos();
+        *PWINDOW->m_vRealSize     = wb.size();

-        g_pXWaylandManager->setWindowSize(PWINDOW, wb.size());
+        PWINDOW->sendWindowSize(wb.size());
    }

    if (m_bForceWarps && !*PANIMATE) {
        g_pHyprRenderer->damageWindow(PWINDOW);

-        PWINDOW->m_vRealPosition.warp();
-        PWINDOW->m_vRealSize.warp();
+        PWINDOW->m_vRealPosition->warp();
+        PWINDOW->m_vRealSize->warp();

        g_pHyprRenderer->damageWindow(PWINDOW);
    }
@@ -701,20 +715,16 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
    const auto PNODE = getNodeFromWindow(PWINDOW);

    if (!PNODE) {
-        PWINDOW->m_vRealSize =
-            (PWINDOW->m_vRealSize.goal() + pixResize)
+        *PWINDOW->m_vRealSize =
+            (PWINDOW->m_vRealSize->goal() + pixResize)
                .clamp(PWINDOW->m_sWindowData.minSize.valueOr(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), PWINDOW->m_sWindowData.maxSize.valueOr(Vector2D{INFINITY, INFINITY}));
        PWINDOW->updateWindowDecos();
        return;
    }

-    const auto   PMONITOR       = PWINDOW->m_pMonitor.lock();
-    static auto  ALWAYSCENTER   = CConfigValue<Hyprlang::INT>("master:always_center_master");
-    static auto  PSMARTRESIZING = CConfigValue<Hyprlang::INT>("master:smart_resizing");
-
-    eOrientation orientation = getDynamicOrientation(PWINDOW->m_pWorkspace);
-    bool         centered    = orientation == ORIENTATION_CENTER && (*ALWAYSCENTER == 1);
-    double       delta       = 0;
+    const auto   PMONITOR            = PWINDOW->m_pMonitor.lock();
+    static auto  SLAVECOUNTFORCENTER = CConfigValue<Hyprlang::INT>("master:slave_count_for_center_master");
+    static auto  PSMARTRESIZING      = CConfigValue<Hyprlang::INT>("master:smart_resizing");

    const bool   DISPLAYBOTTOM = STICKS(PWINDOW->m_vPosition.y + PWINDOW->m_vSize.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
    const bool   DISPLAYRIGHT  = STICKS(PWINDOW->m_vPosition.x + PWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
@@ -729,6 +739,10 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
    const auto   WINDOWS      = getNodesOnWorkspace(PNODE->workspaceID);
    const auto   STACKWINDOWS = WINDOWS - MASTERS;

+    eOrientation orientation = getDynamicOrientation(PWINDOW->m_pWorkspace);
+    bool         centered    = orientation == ORIENTATION_CENTER && (STACKWINDOWS >= *SLAVECOUNTFORCENTER);
+    double       delta       = 0;
+
    if (getNodesOnWorkspace(PWINDOW->workspaceID()) == 1 && !centered)
        return;

@@ -741,7 +755,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
        case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->vecSize.y; break;
        case ORIENTATION_CENTER:
            delta = pixResize.x / PMONITOR->vecSize.x;
-            if (WINDOWS > 2 || *ALWAYSCENTER) {
+            if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) {
                if (!NONE || !PNODE->isMaster)
                    delta *= 2;
                if ((!PNODE->isMaster && DISPLAYLEFT) || (PNODE->isMaster && LEFT && *PSMARTRESIZING))
@@ -842,10 +856,10 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul

    // save position and size if floating
    if (pWindow->m_bIsFloating && CURRENT_EFFECTIVE_MODE == FSMODE_NONE) {
-        pWindow->m_vLastFloatingSize     = pWindow->m_vRealSize.goal();
-        pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition.goal();
-        pWindow->m_vPosition             = pWindow->m_vRealPosition.goal();
-        pWindow->m_vSize                 = pWindow->m_vRealSize.goal();
+        pWindow->m_vLastFloatingSize     = pWindow->m_vRealSize->goal();
+        pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition->goal();
+        pWindow->m_vPosition             = pWindow->m_vRealPosition->goal();
+        pWindow->m_vSize                 = pWindow->m_vRealSize->goal();
    }

    if (EFFECTIVE_MODE == FSMODE_NONE) {
@@ -855,8 +869,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul
            applyNodeDataToWindow(PNODE);
        else {
            // get back its' dimensions from position and size
-            pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
-            pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
+            *pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
+            *pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;

            pWindow->unsetWindowData(PRIORITY_LAYOUT);
            pWindow->updateWindowData();
@@ -864,8 +878,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul
    } else {
        // apply new pos and size being monitors' box
        if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) {
-            pWindow->m_vRealPosition = PMONITOR->vecPosition;
-            pWindow->m_vRealSize     = PMONITOR->vecSize;
+            *pWindow->m_vRealPosition = PMONITOR->vecPosition;
+            *pWindow->m_vRealSize     = PMONITOR->vecSize;
        } else {
            // This is a massive hack.
            // We make a fake "only" node and apply
@@ -931,6 +945,15 @@ void CHyprMasterLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
        if (silent)
            g_pCompositor->focusWindow(PWINDOW2);
    }
+
+    pWindow->updateGroupOutputs();
+    if (!pWindow->m_sGroupData.pNextWindow.expired()) {
+        PHLWINDOW next = pWindow->m_sGroupData.pNextWindow.lock();
+        while (next != pWindow) {
+            next->updateToplevel();
+            next = next->m_sGroupData.pNextWindow.lock();
+        }
+    }
 }

 void CHyprMasterLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) {
@@ -978,7 +1001,7 @@ void CHyprMasterLayout::alterSplitRatio(PHLWINDOW pWindow, float ratio, bool exa
    recalculateMonitor(pWindow->monitorID());
 }

-PHLWINDOW CHyprMasterLayout::getNextWindow(PHLWINDOW pWindow, bool next) {
+PHLWINDOW CHyprMasterLayout::getNextWindow(PHLWINDOW pWindow, bool next, bool loop) {
    if (!isWindowTiled(pWindow))
        return nullptr;

@@ -997,6 +1020,13 @@ PHLWINDOW CHyprMasterLayout::getNextWindow(PHLWINDOW pWindow, bool next) {
        CANDIDATE =
            std::find_if(nodes.begin(), nodes.end(), [&](const auto& other) { return other != *PNODE && ISMASTER != other.isMaster && other.workspaceID == PNODE->workspaceID; });

+    if (CANDIDATE != nodes.end() && !loop) {
+        if (CANDIDATE->isMaster && next)
+            return nullptr;
+        if (!CANDIDATE->isMaster && ISMASTER && !next)
+            return nullptr;
+    }
+
    return CANDIDATE == nodes.end() ? nullptr : CANDIDATE->pWindow.lock();
 }

@@ -1110,7 +1140,8 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
        if (!PWINDOW)
            return 0;

-        const auto PNEXTWINDOW = getNextWindow(PWINDOW, true);
+        const bool NOLOOP      = vars.size() >= 2 && vars[1] == "noloop";
+        const auto PNEXTWINDOW = getNextWindow(PWINDOW, true, !NOLOOP);
        switchToWindow(PNEXTWINDOW);
    } else if (command == "cycleprev") {
        const auto PWINDOW = header.pWindow;
@@ -1118,7 +1149,8 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
        if (!PWINDOW)
            return 0;

-        const auto PPREVWINDOW = getNextWindow(PWINDOW, false);
+        const bool NOLOOP      = vars.size() >= 2 && vars[1] == "noloop";
+        const auto PPREVWINDOW = getNextWindow(PWINDOW, false, !NOLOOP);
        switchToWindow(PPREVWINDOW);
    } else if (command == "swapnext") {
        if (!validMapped(header.pWindow))
@@ -1129,7 +1161,8 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
            return 0;
        }

-        const auto PWINDOWTOSWAPWITH = getNextWindow(header.pWindow, true);
+        const bool NOLOOP            = vars.size() >= 2 && vars[1] == "noloop";
+        const auto PWINDOWTOSWAPWITH = getNextWindow(header.pWindow, true, !NOLOOP);

        if (PWINDOWTOSWAPWITH) {
            g_pCompositor->setWindowFullscreenInternal(header.pWindow, FSMODE_NONE);
@@ -1145,7 +1178,8 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
            return 0;
        }

-        const auto PWINDOWTOSWAPWITH = getNextWindow(header.pWindow, false);
+        const bool NOLOOP            = vars.size() >= 2 && vars[1] == "noloop";
+        const auto PWINDOWTOSWAPWITH = getNextWindow(header.pWindow, false, !NOLOOP);

        if (PWINDOWTOSWAPWITH) {
            g_pCompositor->setWindowFullscreenClient(header.pWindow, FSMODE_NONE);
--- a/src/layout/MasterLayout.hpp
+++ b/src/layout/MasterLayout.hpp
@@ -2,7 +2,7 @@

 #include "IHyprLayout.hpp"
 #include "../desktop/DesktopTypes.hpp"
-#include "../config/ConfigManager.hpp"
+#include "../helpers/varlist/VarList.hpp"
 #include <vector>
 #include <list>
 #include <vector>
@@ -87,7 +87,7 @@ class CHyprMasterLayout : public IHyprLayout {
    SMasterNodeData*                  getMasterNodeOnWorkspace(const WORKSPACEID&);
    SMasterWorkspaceData*             getMasterWorkspaceData(const WORKSPACEID&);
    void                              calculateWorkspace(PHLWORKSPACE);
-    PHLWINDOW                         getNextWindow(PHLWINDOW, bool);
+    PHLWINDOW                         getNextWindow(PHLWINDOW, bool, bool);
    int                               getMastersOnWorkspace(const WORKSPACEID&);

    friend struct SMasterNodeData;
--- a/src/macros.hpp
+++ b/src/macros.hpp
@@ -2,9 +2,11 @@

 #include <cmath>
 #include <csignal>
+#include <print>
 #include <utility>

 #include "helpers/memory/Memory.hpp"
+#include "debug/Log.hpp"

 #ifndef NDEBUG
 #ifdef HYPRLAND_DEBUG
@@ -49,7 +51,7 @@
        Debug::log(CRIT, "\n==========================================================================================\nASSERTION FAILED! \n\n{}\n\nat: line {} in {}",            \
                   std::format(reason, ##__VA_ARGS__), __LINE__,                                                                                                                   \
                   ([]() constexpr -> std::string { return std::string(__FILE__).substr(std::string(__FILE__).find_last_of('/') + 1); })());                                       \
-        printf("Assertion failed! See the log in /tmp/hypr/hyprland.log for more info.");                                                                                          \
+        std::print("Assertion failed! See the log in /tmp/hypr/hyprland.log for more info.");                                                                                      \
        raise(SIGABRT);                                                                                                                                                            \
    }

@@ -112,3 +114,6 @@
    namespace Aquamarine {                                                                                                                                                         \
        class name;                                                                                                                                                                \
    }
+
+#define UNLIKELY(expr) (expr) [[unlikely]]
+#define LIKELY(expr)   (expr) [[likely]]
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -18,7 +18,7 @@ using namespace Hyprutils::String;
 #include <string>
 #include <filesystem>

-void help() {
+static void help() {
    std::println("usage: Hyprland [arg [...]].\n");
    std::println(R"(Arguments:
    --help              -h       - Show this message again
@@ -27,6 +27,7 @@ void help() {
    --wayland-fd FD              - Sets the Wayland socket fd (for Wayland socket handover)
    --systeminfo                 - Prints system infos
    --i-am-really-stupid         - Omits root user privileges check (why would you do that?)
+    --verify-config              - Do not run Hyprland, only print if the config has any errors
    --version           -v       - Print this binary's version)");
 }

@@ -49,7 +50,7 @@ int main(int argc, char** argv) {
    std::string              configPath;
    std::string              socketName;
    int                      socketFd   = -1;
-    bool                     ignoreSudo = false;
+    bool                     ignoreSudo = false, verifyConfig = false;

    std::vector<std::string> args{argv + 1, argv + argc};

@@ -124,6 +125,9 @@ int main(int argc, char** argv) {
        } else if (*it == "--systeminfo") {
            std::println("{}", systemInfoRequest(eHyprCtlOutputFormat::FORMAT_NORMAL, ""));
            return 0;
+        } else if (*it == "--verify-config") {
+            verifyConfig = true;
+            continue;
        } else {
            std::println(stderr, "[ ERROR ] Unknown option '{}' !", *it);
            help();
@@ -138,9 +142,8 @@ int main(int argc, char** argv) {
                     "          Hint: Use the --i-am-really-stupid flag to omit that check.");

        return 1;
-    } else if (ignoreSudo && NInit::isSudo()) {
+    } else if (ignoreSudo && NInit::isSudo())
        std::println("Superuser privileges check is omitted. I hope you know what you're doing.");
-    }

    if (socketName.empty() ^ (socketFd == -1)) {
        std::println(stderr,
@@ -150,12 +153,13 @@ int main(int argc, char** argv) {
        return 1;
    }

-    std::println("Welcome to Hyprland!");
+    if (!verifyConfig)
+        std::println("Welcome to Hyprland!");

    // let's init the compositor.
    // it initializes basic Wayland stuff in the constructor.
    try {
-        g_pCompositor                     = std::make_unique<CCompositor>();
+        g_pCompositor                     = makeUnique<CCompositor>(verifyConfig);
        g_pCompositor->explicitConfigPath = configPath;
    } catch (const std::exception& e) {
        std::println(stderr, "Hyprland threw in ctor: {}\nCannot continue.", e.what());
@@ -164,6 +168,9 @@ int main(int argc, char** argv) {

    g_pCompositor->initServer(socketName, socketFd);

+    if (verifyConfig)
+        return !g_pConfigManager->m_bLastConfigVerificationWasSuccessful;
+
    if (!envEnabled("HYPRLAND_NO_RT"))
        NInit::gainRealTime();

@@ -174,6 +181,8 @@ int main(int argc, char** argv) {

    g_pCompositor->cleanup();

+    g_pCompositor.reset();
+
    Debug::log(LOG, "Hyprland has reached the end.");

    return EXIT_SUCCESS;
--- a/src/managers/AnimationManager.cpp
+++ b/src/managers/AnimationManager.cpp
@@ -1,16 +1,22 @@
 #include "AnimationManager.hpp"
 #include "../Compositor.hpp"
 #include "HookSystemManager.hpp"
-#include "macros.hpp"
+#include "../config/ConfigManager.hpp"
+#include "../desktop/DesktopTypes.hpp"
+#include "../helpers/AnimatedVariable.hpp"
+#include "../macros.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../desktop/Window.hpp"
 #include "../desktop/LayerSurface.hpp"
 #include "eventLoop/EventLoopManager.hpp"
 #include "../helpers/varlist/VarList.hpp"
+#include "../render/Renderer.hpp"

 #include <hyprgraphics/color/Color.hpp>
+#include <hyprutils/animation/AnimatedVariable.hpp>
+#include <hyprutils/animation/AnimationManager.hpp>

-int wlTick(SP<CEventLoopTimer> self, void* data) {
+static int wlTick(SP<CEventLoopTimer> self, void* data) {
    if (g_pAnimationManager)
        g_pAnimationManager->onTicked();

@@ -26,318 +32,247 @@ int wlTick(SP<CEventLoopTimer> self, void* data) {
    return 0;
 }

-CAnimationManager::CAnimationManager() {
-    std::vector<Vector2D> points = {Vector2D(0.0, 0.75), Vector2D(0.15, 1.0)};
-    m_mBezierCurves["default"].setup(&points);
-
+CHyprAnimationManager::CHyprAnimationManager() {
    m_pAnimationTimer = SP<CEventLoopTimer>(new CEventLoopTimer(std::chrono::microseconds(500), wlTick, nullptr));
-    g_pEventLoopManager->addTimer(m_pAnimationTimer);
+    if (g_pEventLoopManager) // null in --verify-config mode
+        g_pEventLoopManager->addTimer(m_pAnimationTimer);
+
+    addBezierWithName("linear", Vector2D(0.0, 0.0), Vector2D(1.0, 1.0));
 }

-void CAnimationManager::removeAllBeziers() {
-    m_mBezierCurves.clear();
+template <Animable VarType>
+static void updateVariable(CAnimatedVariable<VarType>& av, const float POINTY, bool warp = false) {
+    if (warp || av.value() == av.goal()) {
+        av.warp(true, false);
+        return;
+    }

-    // add the default one
-    std::vector<Vector2D> points = {Vector2D(0.0, 0.75), Vector2D(0.15, 1.0)};
-    m_mBezierCurves["default"].setup(&points);
+    const auto DELTA = av.goal() - av.begun();
+    av.value()       = av.begun() + DELTA * POINTY;
 }

-void CAnimationManager::addBezierWithName(std::string name, const Vector2D& p1, const Vector2D& p2) {
-    std::vector points = {p1, p2};
-    m_mBezierCurves[name].setup(&points);
+static void updateColorVariable(CAnimatedVariable<CHyprColor>& av, const float POINTY, bool warp) {
+    if (warp || av.value() == av.goal()) {
+        av.warp(true, false);
+        return;
+    }
+
+    // convert both to OkLab, then lerp that, and convert back.
+    // This is not as fast as just lerping rgb, but it's WAY more precise...
+    // Use the CHyprColor cache for OkLab
+
+    const auto&                L1 = av.begun().asOkLab();
+    const auto&                L2 = av.goal().asOkLab();
+
+    static const auto          lerp = [](const float one, const float two, const float progress) -> float { return one + (two - one) * progress; };
+
+    const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{
+        .l = lerp(L1.l, L2.l, POINTY),
+        .a = lerp(L1.a, L2.a, POINTY),
+        .b = lerp(L1.b, L2.b, POINTY),
+    };
+
+    av.value() = {lerped, lerp(av.begun().a, av.goal().a, POINTY)};
 }

-void CAnimationManager::onTicked() {
-    m_bTickScheduled = false;
+template <Animable VarType>
+static void handleUpdate(CAnimatedVariable<VarType>& av, bool warp) {
+    PHLWINDOW    PWINDOW            = av.m_Context.pWindow.lock();
+    PHLWORKSPACE PWORKSPACE         = av.m_Context.pWorkspace.lock();
+    PHLLS        PLAYER             = av.m_Context.pLayer.lock();
+    PHLMONITOR   PMONITOR           = nullptr;
+    bool         animationsDisabled = warp;
+
+    if (PWINDOW) {
+        if (av.m_Context.eDamagePolicy == AVARDAMAGE_ENTIRE)
+            g_pHyprRenderer->damageWindow(PWINDOW);
+        else if (av.m_Context.eDamagePolicy == AVARDAMAGE_BORDER) {
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
+            PDECO->damageEntire();
+        } else if (av.m_Context.eDamagePolicy == AVARDAMAGE_SHADOW) {
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
+            PDECO->damageEntire();
+        }
+
+        PMONITOR = PWINDOW->m_pMonitor.lock();
+        if (!PMONITOR)
+            return;
+
+        animationsDisabled = PWINDOW->m_sWindowData.noAnim.valueOr(animationsDisabled);
+    } else if (PWORKSPACE) {
+        PMONITOR = PWORKSPACE->m_pMonitor.lock();
+        if (!PMONITOR)
+            return;
+
+        // dont damage the whole monitor on workspace change, unless it's a special workspace, because dim/blur etc
+        if (PWORKSPACE->m_bIsSpecialWorkspace)
+            g_pHyprRenderer->damageMonitor(PMONITOR);
+
+        // TODO: just make this into a damn callback already vax...
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped || w->isHidden() || w->m_pWorkspace != PWORKSPACE)
+                continue;
+
+            if (w->m_bIsFloating && !w->m_bPinned) {
+                // still doing the full damage hack for floating because sometimes when the window
+                // goes through multiple monitors the last rendered frame is missing damage somehow??
+                const CBox windowBoxNoOffset = w->getFullWindowBoundingBox();
+                const CBox monitorBox        = {PMONITOR->vecPosition, PMONITOR->vecSize};
+                if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors
+                    g_pHyprRenderer->damageWindow(w, true);
+            }
+
+            if (PWORKSPACE->m_bIsSpecialWorkspace)
+                g_pHyprRenderer->damageWindow(w, true); // hack for special too because it can cross multiple monitors
+        }
+
+        // damage any workspace window that is on any monitor
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE || w->m_bPinned)
+                continue;
+
+            g_pHyprRenderer->damageWindow(w);
+        }
+    } else if (PLAYER) {
+        // "some fucking layers miss 1 pixel???" -- vaxry
+        CBox expandBox = CBox{PLAYER->realPosition->value(), PLAYER->realSize->value()};
+        expandBox.expand(5);
+        g_pHyprRenderer->damageBox(expandBox);
+
+        PMONITOR = g_pCompositor->getMonitorFromVector(PLAYER->realPosition->goal() + PLAYER->realSize->goal() / 2.F);
+        if (!PMONITOR)
+            return;
+        animationsDisabled = animationsDisabled || PLAYER->noAnimations;
+    }
+
+    const auto SPENT   = av.getPercent();
+    const auto PBEZIER = g_pAnimationManager->getBezier(av.getBezierName());
+    const auto POINTY  = PBEZIER->getYForPoint(SPENT);
+    const bool WARP    = animationsDisabled || SPENT >= 1.f;
+
+    if constexpr (std::same_as<VarType, CHyprColor>)
+        updateColorVariable(av, POINTY, WARP);
+    else
+        updateVariable<VarType>(av, POINTY, WARP);
+
+    av.onUpdate();
+
+    switch (av.m_Context.eDamagePolicy) {
+        case AVARDAMAGE_ENTIRE: {
+            if (PWINDOW) {
+                PWINDOW->updateWindowDecos();
+                g_pHyprRenderer->damageWindow(PWINDOW);
+            } else if (PWORKSPACE) {
+                for (auto const& w : g_pCompositor->m_vWindows) {
+                    if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE)
+                        continue;
+
+                    w->updateWindowDecos();
+
+                    // damage any workspace window that is on any monitor
+                    if (!w->m_bPinned)
+                        g_pHyprRenderer->damageWindow(w);
+                }
+            } else if (PLAYER) {
+                if (PLAYER->layer <= 1)
+                    g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);
+
+                // some fucking layers miss 1 pixel???
+                CBox expandBox = CBox{PLAYER->realPosition->value(), PLAYER->realSize->value()};
+                expandBox.expand(5);
+                g_pHyprRenderer->damageBox(expandBox);
+            }
+            break;
+        }
+        case AVARDAMAGE_BORDER: {
+            RASSERT(PWINDOW, "Tried to AVARDAMAGE_BORDER a non-window AVAR!");
+
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
+            PDECO->damageEntire();
+
+            break;
+        }
+        case AVARDAMAGE_SHADOW: {
+            RASSERT(PWINDOW, "Tried to AVARDAMAGE_SHADOW a non-window AVAR!");
+
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
+
+            PDECO->damageEntire();
+
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    // manually schedule a frame
+    if (PMONITOR)
+        g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_ANIMATION);
 }

-void CAnimationManager::tick() {
+void CHyprAnimationManager::tick() {
    static std::chrono::time_point lastTick = std::chrono::high_resolution_clock::now();
    m_fLastTickTime                         = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - lastTick).count() / 1000.0;
    lastTick                                = std::chrono::high_resolution_clock::now();

-    if (m_vActiveAnimatedVariables.empty())
-        return;
-
-    bool        animGlobalDisabled = false;
-
    static auto PANIMENABLED = CConfigValue<Hyprlang::INT>("animations:enabled");

-    if (!*PANIMENABLED)
-        animGlobalDisabled = true;
-
-    static auto* const                  PSHADOWSENABLED = (Hyprlang::INT* const*)g_pConfigManager->getConfigValuePtr("decoration:shadow:enabled");
-
-    const auto                          DEFAULTBEZIER = m_mBezierCurves.find("default");
-
-    std::vector<CBaseAnimatedVariable*> animationEndedVars;
-
-    for (auto const& av : m_vActiveAnimatedVariables) {
-
-        if (av->m_eDamagePolicy == AVARDAMAGE_SHADOW && !*PSHADOWSENABLED) {
-            av->warp(false);
-            animationEndedVars.push_back(av);
+    for (size_t i = 0; i < m_vActiveAnimatedVariables.size(); i++) {
+        const auto PAV = m_vActiveAnimatedVariables[i].lock();
+        if (!PAV)
            continue;
-        }

-        // get the spent % (0 - 1)
-        const float SPENT = av->getPercent();
+        // for disabled anims just warp
+        bool warp = !*PANIMENABLED || !PAV->enabled();

-        // window stuff
-        PHLWINDOW    PWINDOW            = av->m_pWindow.lock();
-        PHLWORKSPACE PWORKSPACE         = av->m_pWorkspace.lock();
-        PHLLS        PLAYER             = av->m_pLayer.lock();
-        PHLMONITOR   PMONITOR           = nullptr;
-        bool         animationsDisabled = animGlobalDisabled;
-
-        if (PWINDOW) {
-            if (av->m_eDamagePolicy == AVARDAMAGE_ENTIRE) {
-                g_pHyprRenderer->damageWindow(PWINDOW);
-            } else if (av->m_eDamagePolicy == AVARDAMAGE_BORDER) {
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
-                PDECO->damageEntire();
-            } else if (av->m_eDamagePolicy == AVARDAMAGE_SHADOW) {
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
-                PDECO->damageEntire();
-            }
-
-            PMONITOR = PWINDOW->m_pMonitor.lock();
-            if (!PMONITOR)
-                continue;
-            animationsDisabled = PWINDOW->m_sWindowData.noAnim.valueOr(animationsDisabled);
-        } else if (PWORKSPACE) {
-            PMONITOR = PWORKSPACE->m_pMonitor.lock();
-            if (!PMONITOR)
-                continue;
-
-            // dont damage the whole monitor on workspace change, unless it's a special workspace, because dim/blur etc
-            if (PWORKSPACE->m_bIsSpecialWorkspace)
-                g_pHyprRenderer->damageMonitor(PMONITOR);
-
-            // TODO: just make this into a damn callback already vax...
-            for (auto const& w : g_pCompositor->m_vWindows) {
-                if (!w->m_bIsMapped || w->isHidden() || w->m_pWorkspace != PWORKSPACE)
-                    continue;
-
-                if (w->m_bIsFloating && !w->m_bPinned) {
-                    // still doing the full damage hack for floating because sometimes when the window
-                    // goes through multiple monitors the last rendered frame is missing damage somehow??
-                    const CBox windowBoxNoOffset = w->getFullWindowBoundingBox();
-                    const CBox monitorBox        = {PMONITOR->vecPosition, PMONITOR->vecSize};
-                    if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors
-                        g_pHyprRenderer->damageWindow(w, true);
-                }
-
-                if (PWORKSPACE->m_bIsSpecialWorkspace)
-                    g_pHyprRenderer->damageWindow(w, true); // hack for special too because it can cross multiple monitors
-            }
-
-            // damage any workspace window that is on any monitor
-            for (auto const& w : g_pCompositor->m_vWindows) {
-                if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE || w->m_bPinned)
-                    continue;
-
-                g_pHyprRenderer->damageWindow(w);
-            }
-        } else if (PLAYER) {
-            // "some fucking layers miss 1 pixel???" -- vaxry
-            CBox expandBox = CBox{PLAYER->realPosition.value(), PLAYER->realSize.value()};
-            expandBox.expand(5);
-            g_pHyprRenderer->damageBox(&expandBox);
-
-            PMONITOR = g_pCompositor->getMonitorFromVector(PLAYER->realPosition.goal() + PLAYER->realSize.goal() / 2.F);
-            if (!PMONITOR)
-                continue;
-            animationsDisabled = animationsDisabled || PLAYER->noAnimations;
-        }
-
-        const bool VISIBLE = PWINDOW && PWINDOW->m_pWorkspace ? PWINDOW->m_pWorkspace->isVisible() : true;
-
-        // beziers are with a switch unforto
-        // TODO: maybe do something cleaner
-
-        static const auto updateVariable = [this]<Animable T>(CAnimatedVariable<T>& av, const float SPENT, const CBezierCurve& DEFAULTBEZIER, const bool DISABLED) {
-            // for disabled anims just warp
-            if (av.m_pConfig->pValues->internalEnabled == 0 || DISABLED) {
-                av.warp(false);
-                return;
-            }
-
-            if (SPENT >= 1.f || av.m_Begun == av.m_Goal) {
-                av.warp(false);
-                return;
-            }
-
-            const auto BEZIER = m_mBezierCurves.find(av.m_pConfig->pValues->internalBezier);
-            const auto POINTY = BEZIER != m_mBezierCurves.end() ? BEZIER->second.getYForPoint(SPENT) : DEFAULTBEZIER.getYForPoint(SPENT);
-
-            const auto DELTA = av.m_Goal - av.m_Begun;
-
-            if (BEZIER != m_mBezierCurves.end())
-                av.m_Value = av.m_Begun + DELTA * POINTY;
-            else
-                av.m_Value = av.m_Begun + DELTA * POINTY;
-        };
-
-        static const auto updateColorVariable = [this](CAnimatedVariable<CHyprColor>& av, const float SPENT, const CBezierCurve& DEFAULTBEZIER, const bool DISABLED) {
-            // for disabled anims just warp
-            if (av.m_pConfig->pValues->internalEnabled == 0 || DISABLED) {
-                av.warp(false);
-                return;
-            }
-
-            if (SPENT >= 1.f || av.m_Begun == av.m_Goal) {
-                av.warp(false);
-                return;
-            }
-
-            const auto BEZIER = m_mBezierCurves.find(av.m_pConfig->pValues->internalBezier);
-            const auto POINTY = BEZIER != m_mBezierCurves.end() ? BEZIER->second.getYForPoint(SPENT) : DEFAULTBEZIER.getYForPoint(SPENT);
-
-            // convert both to OkLab, then lerp that, and convert back.
-            // This is not as fast as just lerping rgb, but it's WAY more precise...
-            // Use the CHyprColor cache for OkLab
-
-            const auto&                L1 = av.m_Begun.asOkLab();
-            const auto&                L2 = av.m_Goal.asOkLab();
-
-            static const auto          lerp = [](const float one, const float two, const float progress) -> float { return one + (two - one) * progress; };
-
-            const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{
-                .l = lerp(L1.l, L2.l, POINTY),
-                .a = lerp(L1.a, L2.a, POINTY),
-                .b = lerp(L1.b, L2.b, POINTY),
-            };
-
-            av.m_Value = {lerped, lerp(av.m_Begun.a, av.m_Goal.a, POINTY)};
-
-            return;
-        };
-
-        switch (av->m_Type) {
+        switch (PAV->m_Type) {
            case AVARTYPE_FLOAT: {
-                auto typedAv = dynamic_cast<CAnimatedVariable<float>*>(av);
-                updateVariable(*typedAv, SPENT, DEFAULTBEZIER->second, animationsDisabled);
-                break;
-            }
+                auto pTypedAV = dynamic_cast<CAnimatedVariable<float>*>(PAV.get());
+                RASSERT(pTypedAV, "Failed to upcast animated float");
+                handleUpdate(*pTypedAV, warp);
+            } break;
            case AVARTYPE_VECTOR: {
-                auto typedAv = dynamic_cast<CAnimatedVariable<Vector2D>*>(av);
-                updateVariable(*typedAv, SPENT, DEFAULTBEZIER->second, animationsDisabled);
-                break;
-            }
+                auto pTypedAV = dynamic_cast<CAnimatedVariable<Vector2D>*>(PAV.get());
+                RASSERT(pTypedAV, "Failed to upcast animated Vector2D");
+                handleUpdate(*pTypedAV, warp);
+            } break;
            case AVARTYPE_COLOR: {
-                auto typedAv = dynamic_cast<CAnimatedVariable<CHyprColor>*>(av);
-                updateColorVariable(*typedAv, SPENT, DEFAULTBEZIER->second, animationsDisabled);
-                break;
-            }
+                auto pTypedAV = dynamic_cast<CAnimatedVariable<CHyprColor>*>(PAV.get());
+                RASSERT(pTypedAV, "Failed to upcast animated CHyprColor");
+                handleUpdate(*pTypedAV, warp);
+            } break;
            default: UNREACHABLE();
        }
-        // set size and pos if valid, but only if damage policy entire (dont if border for example)
-        if (validMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE && !PWINDOW->isX11OverrideRedirect())
-            g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal());
-
-        // check if we did not finish animating. If so, trigger onAnimationEnd.
-        if (!av->isBeingAnimated())
-            animationEndedVars.push_back(av);
-
-        // lastly, handle damage, but only if whatever we are animating is visible.
-        if (!VISIBLE)
-            continue;
-
-        if (av->m_fUpdateCallback)
-            av->m_fUpdateCallback(av);
-
-        switch (av->m_eDamagePolicy) {
-            case AVARDAMAGE_ENTIRE: {
-                if (PWINDOW) {
-                    PWINDOW->updateWindowDecos();
-                    g_pHyprRenderer->damageWindow(PWINDOW);
-                } else if (PWORKSPACE) {
-                    for (auto const& w : g_pCompositor->m_vWindows) {
-                        if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE)
-                            continue;
-
-                        w->updateWindowDecos();
-
-                        // damage any workspace window that is on any monitor
-                        if (!w->m_bPinned)
-                            g_pHyprRenderer->damageWindow(w);
-                    }
-                } else if (PLAYER) {
-                    if (PLAYER->layer <= 1)
-                        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);
-
-                    // some fucking layers miss 1 pixel???
-                    CBox expandBox = CBox{PLAYER->realPosition.value(), PLAYER->realSize.value()};
-                    expandBox.expand(5);
-                    g_pHyprRenderer->damageBox(&expandBox);
-                }
-                break;
-            }
-            case AVARDAMAGE_BORDER: {
-                RASSERT(PWINDOW, "Tried to AVARDAMAGE_BORDER a non-window AVAR!");
-
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
-                PDECO->damageEntire();
-
-                break;
-            }
-            case AVARDAMAGE_SHADOW: {
-                RASSERT(PWINDOW, "Tried to AVARDAMAGE_SHADOW a non-window AVAR!");
-
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
-
-                PDECO->damageEntire();
-
-                break;
-            }
-            default: {
-                break;
-            }
-        }
-
-        // manually schedule a frame
-        if (PMONITOR)
-            g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_ANIMATION);
    }

-    // do it here, because if this alters the animation vars vec we would be in trouble above.
-    for (auto const& ave : animationEndedVars) {
-        ave->onAnimationEnd();
-    }
+    tickDone();
 }

-bool CAnimationManager::deltaSmallToFlip(const Vector2D& a, const Vector2D& b) {
-    return std::abs(a.x - b.x) < 0.5f && std::abs(a.y - b.y) < 0.5f;
-}
+void CHyprAnimationManager::scheduleTick() {
+    if (m_bTickScheduled)
+        return;

-bool CAnimationManager::deltaSmallToFlip(const CHyprColor& a, const CHyprColor& b) {
-    return std::abs(a.r - b.r) < 0.5f && std::abs(a.g - b.g) < 0.5f && std::abs(a.b - b.b) < 0.5f && std::abs(a.a - b.a) < 0.5f;
-}
+    m_bTickScheduled = true;

-bool CAnimationManager::deltaSmallToFlip(const float& a, const float& b) {
-    return std::abs(a - b) < 0.5f;
-}
+    const auto PMOSTHZ = g_pHyprRenderer->m_pMostHzMonitor;

-bool CAnimationManager::deltazero(const Vector2D& a, const Vector2D& b) {
-    return a.x == b.x && a.y == b.y;
-}
-
-bool CAnimationManager::deltazero(const float& a, const float& b) {
-    return a == b;
-}
-
-bool CAnimationManager::deltazero(const CHyprColor& a, const CHyprColor& b) {
-    return a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a;
-}
-
-bool CAnimationManager::bezierExists(const std::string& bezier) {
-    for (auto const& [bc, bz] : m_mBezierCurves) {
-        if (bc == bezier)
-            return true;
+    if (!PMOSTHZ) {
+        m_pAnimationTimer->updateTimeout(std::chrono::milliseconds(16));
+        return;
    }

-    return false;
+    float       refreshDelayMs = std::floor(1000.f / PMOSTHZ->refreshRate);
+
+    const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - PMOSTHZ->lastPresentationTimer.chrono()).count() / 1000.f;
+
+    const auto  TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it
+
+    m_pAnimationTimer->updateTimeout(std::chrono::milliseconds((int)std::floor(TOPRES)));
+}
+
+void CHyprAnimationManager::onTicked() {
+    m_bTickScheduled = false;
 }

 //
@@ -345,24 +280,24 @@ bool CAnimationManager::bezierExists(const std::string& bezier) {
 //
 //

-void CAnimationManager::animationPopin(PHLWINDOW pWindow, bool close, float minPerc) {
-    const auto GOALPOS  = pWindow->m_vRealPosition.goal();
-    const auto GOALSIZE = pWindow->m_vRealSize.goal();
+void CHyprAnimationManager::animationPopin(PHLWINDOW pWindow, bool close, float minPerc) {
+    const auto GOALPOS  = pWindow->m_vRealPosition->goal();
+    const auto GOALSIZE = pWindow->m_vRealSize->goal();

    if (!close) {
-        pWindow->m_vRealSize.setValue((GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y}));
-        pWindow->m_vRealPosition.setValue(GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize.m_Value / 2.f);
+        pWindow->m_vRealSize->setValue((GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y}));
+        pWindow->m_vRealPosition->setValue(GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize->value() / 2.f);
    } else {
-        pWindow->m_vRealSize     = (GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y});
-        pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize.m_Goal / 2.f;
+        *pWindow->m_vRealSize     = (GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y});
+        *pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize->goal() / 2.f;
    }
 }

-void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, bool close) {
-    pWindow->m_vRealSize.warp(false); // size we preserve in slide
+void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, bool close) {
+    pWindow->m_vRealSize->warp(false); // size we preserve in slide

-    const auto GOALPOS  = pWindow->m_vRealPosition.goal();
-    const auto GOALSIZE = pWindow->m_vRealSize.goal();
+    const auto GOALPOS  = pWindow->m_vRealPosition->goal();
+    const auto GOALSIZE = pWindow->m_vRealSize->goal();

    const auto PMONITOR = pWindow->m_pMonitor.lock();

@@ -382,9 +317,9 @@ void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, boo
            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y);

        if (!close)
-            pWindow->m_vRealPosition.setValue(posOffset);
+            pWindow->m_vRealPosition->setValue(posOffset);
        else
-            pWindow->m_vRealPosition = posOffset;
+            *pWindow->m_vRealPosition = posOffset;

        return;
    }
@@ -417,33 +352,33 @@ void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, boo
    }

    if (!close)
-        pWindow->m_vRealPosition.setValue(posOffset);
+        pWindow->m_vRealPosition->setValue(posOffset);
    else
-        pWindow->m_vRealPosition = posOffset;
+        *pWindow->m_vRealPosition = posOffset;
 }

-void CAnimationManager::onWindowPostCreateClose(PHLWINDOW pWindow, bool close) {
+void CHyprAnimationManager::onWindowPostCreateClose(PHLWINDOW pWindow, bool close) {
    if (!close) {
-        pWindow->m_vRealPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsIn");
-        pWindow->m_vRealSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("windowsIn");
-        pWindow->m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeIn");
+        pWindow->m_vRealPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsIn"));
+        pWindow->m_vRealSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsIn"));
+        pWindow->m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
    } else {
-        pWindow->m_vRealPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsOut");
-        pWindow->m_vRealSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("windowsOut");
-        pWindow->m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeOut");
+        pWindow->m_vRealPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsOut"));
+        pWindow->m_vRealSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsOut"));
+        pWindow->m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
    }

-    auto ANIMSTYLE = pWindow->m_vRealPosition.m_pConfig->pValues->internalStyle;
+    std::string ANIMSTYLE = pWindow->m_vRealPosition->getStyle();
    transform(ANIMSTYLE.begin(), ANIMSTYLE.end(), ANIMSTYLE.begin(), ::tolower);

    CVarList animList(ANIMSTYLE, 0, 's');

    // if the window is not being animated, that means the layout set a fixed size for it, don't animate.
-    if (!pWindow->m_vRealPosition.isBeingAnimated() && !pWindow->m_vRealSize.isBeingAnimated())
+    if (!pWindow->m_vRealPosition->isBeingAnimated() && !pWindow->m_vRealSize->isBeingAnimated())
        return;

    // if the animation is disabled and we are leaving, ignore the anim to prevent the snapshot being fucked
-    if (!pWindow->m_vRealPosition.m_pConfig->pValues->internalEnabled)
+    if (!pWindow->m_vRealPosition->enabled())
        return;

    if (pWindow->m_sWindowData.animationStyle.hasValue()) {
@@ -488,7 +423,7 @@ void CAnimationManager::onWindowPostCreateClose(PHLWINDOW pWindow, bool close) {
    }
 }

-std::string CAnimationManager::styleValidInConfigVar(const std::string& config, const std::string& style) {
+std::string CHyprAnimationManager::styleValidInConfigVar(const std::string& config, const std::string& style) {
    if (config.starts_with("window")) {
        if (style.starts_with("slide"))
            return "";
@@ -562,39 +497,3 @@ std::string CAnimationManager::styleValidInConfigVar(const std::string& config,

    return "";
 }
-
-CBezierCurve* CAnimationManager::getBezier(const std::string& name) {
-    const auto BEZIER = std::find_if(m_mBezierCurves.begin(), m_mBezierCurves.end(), [&](const auto& other) { return other.first == name; });
-
-    return BEZIER == m_mBezierCurves.end() ? &m_mBezierCurves["default"] : &BEZIER->second;
-}
-
-std::unordered_map<std::string, CBezierCurve> CAnimationManager::getAllBeziers() {
-    return m_mBezierCurves;
-}
-
-bool CAnimationManager::shouldTickForNext() {
-    return !m_vActiveAnimatedVariables.empty();
-}
-
-void CAnimationManager::scheduleTick() {
-    if (m_bTickScheduled)
-        return;
-
-    m_bTickScheduled = true;
-
-    const auto PMOSTHZ = g_pHyprRenderer->m_pMostHzMonitor;
-
-    if (!PMOSTHZ) {
-        m_pAnimationTimer->updateTimeout(std::chrono::milliseconds(16));
-        return;
-    }
-
-    float       refreshDelayMs = std::floor(1000.f / PMOSTHZ->refreshRate);
-
-    const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - PMOSTHZ->lastPresentationTimer.chrono()).count() / 1000.f;
-
-    const auto  TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it
-
-    m_pAnimationTimer->updateTimeout(std::chrono::milliseconds((int)std::floor(TOPRES)));
-}
--- a/src/managers/AnimationManager.hpp
+++ b/src/managers/AnimationManager.hpp
@@ -1,57 +1,64 @@
 #pragma once

+#include <hyprutils/animation/AnimationManager.hpp>
+#include <hyprutils/animation/AnimatedVariable.hpp>
+
 #include "../defines.hpp"
-#include <list>
-#include <unordered_map>
 #include "../helpers/AnimatedVariable.hpp"
-#include "../helpers/BezierCurve.hpp"
-#include "../helpers/Timer.hpp"
+#include "../desktop/DesktopTypes.hpp"
 #include "eventLoop/EventLoopTimer.hpp"

-class CWindow;
-
-class CAnimationManager {
+class CHyprAnimationManager : public Hyprutils::Animation::CAnimationManager {
  public:
-    CAnimationManager();
+    CHyprAnimationManager();

-    void                                          tick();
-    bool                                          shouldTickForNext();
-    void                                          onTicked();
-    void                                          scheduleTick();
-    void                                          addBezierWithName(std::string, const Vector2D&, const Vector2D&);
-    void                                          removeAllBeziers();
+    void         tick();
+    virtual void scheduleTick();
+    virtual void onTicked();

-    void                                          onWindowPostCreateClose(PHLWINDOW, bool close = false);
+    using SAnimationPropertyConfig = Hyprutils::Animation::SAnimationPropertyConfig;
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, eAVarDamagePolicy policy) {
+        constexpr const eAnimatedVarType EAVTYPE = typeToeAnimatedVarType<VarType>;
+        const auto                       PAV     = makeShared<CAnimatedVariable<VarType>>();

-    bool                                          bezierExists(const std::string&);
-    CBezierCurve*                                 getBezier(const std::string&);
+        PAV->create(EAVTYPE, static_cast<Hyprutils::Animation::CAnimationManager*>(this), PAV, v);
+        PAV->setConfig(pConfig);
+        PAV->m_Context.eDamagePolicy = policy;

-    std::string                                   styleValidInConfigVar(const std::string&, const std::string&);
+        pav = std::move(PAV);
+    }

-    std::unordered_map<std::string, CBezierCurve> getAllBeziers();
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, PHLWINDOW pWindow, eAVarDamagePolicy policy) {
+        createAnimation(v, pav, pConfig, policy);
+        pav->m_Context.pWindow = pWindow;
+    }
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, PHLWORKSPACE pWorkspace, eAVarDamagePolicy policy) {
+        createAnimation(v, pav, pConfig, policy);
+        pav->m_Context.pWorkspace = pWorkspace;
+    }
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, PHLLS pLayer, eAVarDamagePolicy policy) {
+        createAnimation(v, pav, pConfig, policy);
+        pav->m_Context.pLayer = pLayer;
+    }

-    std::vector<CBaseAnimatedVariable*>           m_vAnimatedVariables;
-    std::vector<CBaseAnimatedVariable*>           m_vActiveAnimatedVariables;
+    void                onWindowPostCreateClose(PHLWINDOW, bool close = false);

-    SP<CEventLoopTimer>                           m_pAnimationTimer;
+    std::string         styleValidInConfigVar(const std::string&, const std::string&);

-    float                                         m_fLastTickTime; // in ms
+    SP<CEventLoopTimer> m_pAnimationTimer;
+
+    float               m_fLastTickTime; // in ms

  private:
-    bool                                          deltaSmallToFlip(const Vector2D& a, const Vector2D& b);
-    bool                                          deltaSmallToFlip(const CHyprColor& a, const CHyprColor& b);
-    bool                                          deltaSmallToFlip(const float& a, const float& b);
-    bool                                          deltazero(const Vector2D& a, const Vector2D& b);
-    bool                                          deltazero(const CHyprColor& a, const CHyprColor& b);
-    bool                                          deltazero(const float& a, const float& b);
-
-    std::unordered_map<std::string, CBezierCurve> m_mBezierCurves;
-
-    bool                                          m_bTickScheduled = false;
+    bool m_bTickScheduled = false;

    // Anim stuff
    void animationPopin(PHLWINDOW, bool close = false, float minPerc = 0.f);
    void animationSlide(PHLWINDOW, std::string force = "", bool close = false);
 };

-inline std::unique_ptr<CAnimationManager> g_pAnimationManager;
+inline UP<CHyprAnimationManager> g_pAnimationManager;
--- a/src/managers/CursorManager.cpp
+++ b/src/managers/CursorManager.cpp
@@ -3,6 +3,7 @@
 #include "../config/ConfigValue.hpp"
 #include "PointerManager.hpp"
 #include "../xwayland/XWayland.hpp"
+#include "../managers/HookSystemManager.hpp"

 static int cursorAnimTimer(SP<CEventLoopTimer> self, void* data) {
    const auto cursorMgr = reinterpret_cast<CCursorManager*>(data);
@@ -63,8 +64,8 @@ void CCursorBuffer::endDataPtr() {
 }

 CCursorManager::CCursorManager() {
-    m_pHyprcursor              = std::make_unique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), hcLogger);
-    m_pXcursor                 = std::make_unique<CXCursorManager>();
+    m_pHyprcursor              = makeUnique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), hcLogger);
+    m_pXcursor                 = makeUnique<CXCursorManager>();
    static auto PUSEHYPRCURSOR = CConfigValue<Hyprlang::INT>("cursor:enable_hyprcursor");

    if (m_pHyprcursor->valid() && *PUSEHYPRCURSOR) {
@@ -322,7 +323,7 @@ bool CCursorManager::changeTheme(const std::string& name, const int size) {
        m_szTheme                    = name.empty() ? "" : name;
        m_iSize                      = size;

-        m_pHyprcursor = std::make_unique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), options);
+        m_pHyprcursor = makeUnique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), options);
        if (!m_pHyprcursor->valid()) {
            Debug::log(ERR, "Hyprcursor failed loading theme \"{}\", falling back to XCursor.", m_szTheme);
            m_pXcursor->loadTheme(m_szTheme.empty() ? xcursor_theme : m_szTheme, m_iSize, m_fCursorScale);
--- a/src/managers/CursorManager.hpp
+++ b/src/managers/CursorManager.hpp
@@ -2,7 +2,6 @@

 #include <string>
 #include <hyprcursor/hyprcursor.hpp>
-#include <memory>
 #include "../includes.hpp"
 #include "../helpers/math/Math.hpp"
 #include "../helpers/memory/Memory.hpp"
@@ -58,22 +57,22 @@ class CCursorManager {
    void                    tickAnimatedCursor();

  private:
-    bool                                            m_bOurBufferConnected = false;
-    std::vector<SP<CCursorBuffer>>                  m_vCursorBuffers;
+    bool                               m_bOurBufferConnected = false;
+    std::vector<SP<CCursorBuffer>>     m_vCursorBuffers;

-    std::unique_ptr<Hyprcursor::CHyprcursorManager> m_pHyprcursor;
-    std::unique_ptr<CXCursorManager>                m_pXcursor;
-    SP<SXCursors>                                   m_currentXcursor;
+    UP<Hyprcursor::CHyprcursorManager> m_pHyprcursor;
+    UP<CXCursorManager>                m_pXcursor;
+    SP<SXCursors>                      m_currentXcursor;

-    std::string                                     m_szTheme      = "";
-    int                                             m_iSize        = 0;
-    float                                           m_fCursorScale = 1.0;
+    std::string                        m_szTheme      = "";
+    int                                m_iSize        = 0;
+    float                              m_fCursorScale = 1.0;

-    Hyprcursor::SCursorStyleInfo                    m_sCurrentStyleInfo;
+    Hyprcursor::SCursorStyleInfo       m_sCurrentStyleInfo;

-    SP<CEventLoopTimer>                             m_pAnimationTimer;
-    int                                             m_iCurrentAnimationFrame = 0;
-    Hyprcursor::SCursorShapeData                    m_sCurrentCursorShapeData;
+    SP<CEventLoopTimer>                m_pAnimationTimer;
+    int                                m_iCurrentAnimationFrame = 0;
+    Hyprcursor::SCursorShapeData       m_sCurrentCursorShapeData;
 };

-inline std::unique_ptr<CCursorManager> g_pCursorManager;
+inline UP<CCursorManager> g_pCursorManager;
--- a/src/managers/DonationNagManager.cpp
+++ b/src/managers/DonationNagManager.cpp
@@ -0,0 +1,114 @@
+#include "DonationNagManager.hpp"
+#include "../debug/Log.hpp"
+#include "VersionKeeperManager.hpp"
+#include "eventLoop/EventLoopManager.hpp"
+#include "../config/ConfigValue.hpp"
+
+#include <chrono>
+#include <format>
+
+#include "../helpers/fs/FsUtils.hpp"
+
+#include <hyprutils/os/Process.hpp>
+using namespace Hyprutils::OS;
+
+constexpr const char* LAST_NAG_FILE_NAME = "lastNag";
+constexpr uint64_t    DAY_IN_SECONDS     = 3600ULL * 24;
+constexpr uint64_t    MONTH_IN_SECONDS   = DAY_IN_SECONDS * 30;
+
+struct SNagDatePoint {
+    // Counted from 1, as in Jan 1st is 1, 1
+    // No month-boundaries because I am lazy
+    uint8_t month = 0, dayStart = 0, dayEnd = 0;
+};
+
+// clang-format off
+const std::vector<SNagDatePoint> NAG_DATE_POINTS = {
+    SNagDatePoint {
+        7, 20, 31,
+    },
+    SNagDatePoint {
+        12, 1, 28
+    },
+};
+// clang-format on
+
+CDonationNagManager::CDonationNagManager() {
+    static auto PNONAG = CConfigValue<Hyprlang::INT>("ecosystem:no_donation_nag");
+
+    if (g_pVersionKeeperMgr->fired() || *PNONAG)
+        return;
+
+    const auto DATAROOT = NFsUtils::getDataHome();
+
+    if (!DATAROOT)
+        return;
+
+    const auto EPOCH = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+
+    const auto LASTNAGSTR = NFsUtils::readFileAsString(*DATAROOT + "/" + LAST_NAG_FILE_NAME);
+
+    if (!LASTNAGSTR) {
+        const auto EPOCHSTR = std::format("{}", EPOCH);
+        NFsUtils::writeToFile(*DATAROOT + "/" + LAST_NAG_FILE_NAME, EPOCHSTR);
+        return;
+    }
+
+    uint64_t LAST_EPOCH = 0;
+
+    try {
+        LAST_EPOCH = std::stoull(*LASTNAGSTR);
+    } catch (std::exception& e) {
+        Debug::log(ERR, "DonationNag: Last epoch invalid? Failed to parse \"{}\". Setting to today.", *LASTNAGSTR);
+        const auto EPOCHSTR = std::format("{}", EPOCH);
+        NFsUtils::writeToFile(*DATAROOT + "/" + LAST_NAG_FILE_NAME, EPOCHSTR);
+        return;
+    }
+
+    // don't nag if the last nag was less than a month ago. This is
+    // mostly for first-time nags, as other nags happen in specific time frames shorter than a month
+    if (EPOCH - LAST_EPOCH < MONTH_IN_SECONDS) {
+        Debug::log(LOG, "DonationNag: last nag was {} days ago, too early for a nag.", (int)std::round((EPOCH - LAST_EPOCH) / (double)MONTH_IN_SECONDS));
+        return;
+    }
+
+    if (!NFsUtils::executableExistsInPath("hyprland-donate-screen")) {
+        Debug::log(ERR, "DonationNag: executable doesn't exist, skipping.");
+        return;
+    }
+
+    auto       tt    = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+    auto       local = *localtime(&tt);
+
+    const auto MONTH = local.tm_mon + 1;
+    const auto DAY   = local.tm_mday;
+
+    for (const auto& nagPoint : NAG_DATE_POINTS) {
+        if (MONTH != nagPoint.month)
+            continue;
+
+        if (DAY < nagPoint.dayStart || DAY > nagPoint.dayEnd)
+            continue;
+
+        Debug::log(LOG, "DonationNag: hit nag month {} days {}-{}, it's {} today, nagging", MONTH, nagPoint.dayStart, nagPoint.dayEnd, DAY);
+
+        m_bFired = true;
+
+        const auto EPOCHSTR = std::format("{}", EPOCH);
+        NFsUtils::writeToFile(*DATAROOT + "/" + LAST_NAG_FILE_NAME, EPOCHSTR);
+
+        g_pEventLoopManager->doLater([] {
+            CProcess proc("hyprland-donate-screen", {});
+            proc.runAsync();
+        });
+
+        break;
+    }
+
+    if (!m_bFired)
+        Debug::log(LOG, "DonationNag: didn't hit any nagging periods");
+}
+
+bool CDonationNagManager::fired() {
+    return m_bFired;
+}
--- a/src/managers/DonationNagManager.hpp
+++ b/src/managers/DonationNagManager.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../helpers/memory/Memory.hpp"
+
+class CDonationNagManager {
+  public:
+    CDonationNagManager();
+
+    // whether the donation nag was shown this boot.
+    bool fired();
+
+  private:
+    bool m_bFired = false;
+};
+
+inline UP<CDonationNagManager> g_pDonationNagManager;
--- a/src/managers/EventManager.hpp
+++ b/src/managers/EventManager.hpp
@@ -42,4 +42,4 @@ class CEventManager {
    std::vector<SClient> m_vClients;
 };

-inline std::unique_ptr<CEventManager> g_pEventManager;
+inline UP<CEventManager> g_pEventManager;
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .46.2
 .47.2