[gha] Nix: update inputs

version: bump to 0.45.2
xdg-shell: don't report invalid min/max sizes on unset
2025-08-19 14:03:47 -07:00 · 2024-11-19 21:47:18 +00:00 · 2024-11-19 21:45:40 +00:00 · 2024-11-19 21:45:20 +00:00 · 2024-11-19 21:45:20 +00:00 · 2024-11-18 14:27:21 +00:00
380 changed files with 9750 additions and 20747 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,101 +0,0 @@
-WarningsAsErrors: '*'
-HeaderFilterRegex: '.*\.hpp'
-FormatStyle: file
-Checks: >
-  -*,
-  bugprone-*,
-  -bugprone-easily-swappable-parameters,
-  -bugprone-forward-declararion-namespace,
-  -bugprone-forward-declararion-namespace,
-  -bugprone-macro-parentheses,
-  -bugprone-narrowing-conversions,
-  -bugprone-branch-clone,
-  -bugprone-assignment-in-if-condition,
-  concurrency-*,
-  -concurrency-mt-unsafe,
-  cppcoreguidelines-*,
-  -cppcoreguidelines-owning-memory,
-  -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-pro-bounds-constant-array-index,
-  -cppcoreguidelines-avoid-const-or-ref-data-members,
-  -cppcoreguidelines-non-private-member-variables-in-classes,
-  -cppcoreguidelines-avoid-goto,
-  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-  -cppcoreguidelines-avoid-do-while,
-  -cppcoreguidelines-avoid-non-const-global-variables,
-  -cppcoreguidelines-special-member-functions,
-  -cppcoreguidelines-explicit-virtual-functions,
-  -cppcoreguidelines-avoid-c-arrays,
-  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-  -cppcoreguidelines-narrowing-conversions,
-  -cppcoreguidelines-pro-type-union-access,
-  -cppcoreguidelines-pro-type-member-init,
-  -cppcoreguidelines-macro-usage,
-  -cppcoreguidelines-macro-to-enum,
-  -cppcoreguidelines-init-variables,
-  -cppcoreguidelines-pro-type-cstyle-cast,
-  -cppcoreguidelines-pro-type-vararg,
-  -cppcoreguidelines-pro-type-reinterpret-cast,
-  google-global-names-in-headers,
-  -google-readability-casting,
-  google-runtime-operator,
-  misc-*,
-  -misc-unused-parameters,
-  -misc-no-recursion,
-  -misc-non-private-member-variables-in-classes,
-  -misc-include-cleaner,
-  -misc-use-anonymous-namespace,
-  -misc-const-correctness,
-  modernize-*,
-  -modernize-return-braced-init-list,
-  -modernize-use-trailing-return-type,
-  -modernize-use-using,
-  -modernize-use-override,
-  -modernize-avoid-c-arrays,
-  -modernize-macro-to-enum,
-  -modernize-loop-convert,
-  -modernize-use-nodiscard,
-  -modernize-pass-by-value,
-  -modernize-use-auto,
-  performance-*,
-  -performance-avoid-endl,
-  -performance-unnecessary-value-param,
-  portability-std-allocator-const,
-  readability-*,
-  -readability-function-cognitive-complexity,
-  -readability-function-size,
-  -readability-identifier-length,
-  -readability-magic-numbers,
-  -readability-uppercase-literal-suffix,
-  -readability-braces-around-statements,
-  -readability-redundant-access-specifiers,
-  -readability-else-after-return,
-  -readability-container-data-pointer,
-  -readability-implicit-bool-conversion,
-  -readability-avoid-nested-conditional-operator,
-  -readability-redundant-member-init,
-  -readability-redundant-string-init,
-  -readability-avoid-const-params-in-decls,
-  -readability-named-parameter,
-  -readability-convert-member-functions-to-static,
-  -readability-qualified-auto,
-  -readability-make-member-function-const,
-  -readability-isolate-declaration,
-  -readability-inconsistent-declaration-parameter-name,
-  -clang-diagnostic-error,
-
-CheckOptions:
-  performance-for-range-copy.WarnOnAllAutoCopies: true
-  performance-inefficient-string-concatenation.StrictMode: true
-  readability-braces-around-statements.ShortStatementLines: 0
-  readability-identifier-naming.ClassCase: CamelCase
-  readability-identifier-naming.ClassIgnoredRegexp: I.*
-  readability-identifier-naming.ClassPrefix: C # We can't use regex here?!?!?!?
-  readability-identifier-naming.EnumCase: CamelCase
-  readability-identifier-naming.EnumPrefix: e
-  readability-identifier-naming.EnumConstantCase: UPPER_CASE
-  readability-identifier-naming.FunctionCase: camelBack
-  readability-identifier-naming.NamespaceCase: CamelCase
-  readability-identifier-naming.NamespacePrefix: N
-  readability-identifier-naming.StructPrefix: S
-  readability-identifier-naming.StructCase: CamelCase
--- 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 issues. If the same bug is already reported, don't open new issue - instead go upvote/comment on an existing one.
+      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.
      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,28 +19,27 @@ 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:
-        - "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"
+        - "Yes"
+        - "No"
    validations:
      required: true

  - type: textarea
    id: ver
    attributes:
-      label: System Info and Hyprland Version
+      label: System Info and Version
      description: |
-        Paste the output of `hyprctl systeminfo` here. If you can't
+        Paste the output of `hyprctl systeminfo -c` 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>


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

        ```

@@ -62,56 +61,15 @@ 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: Additional info & File uploads
+      label: Crash reports, logs, images, videos
      description: |
-        Tip: You can attach files by clicking this area to highlight it and then dragging files in.
+        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
+
--- a/.github/actions/setup_base/action.yml
+++ b/.github/actions/setup_base/action.yml
@@ -33,10 +33,7 @@ runs:
          libfontenc \
          libglvnd \
          libinput \
-          libjxl \
          libliftoff \
-          libspng \
-          libwebp \
          libxcursor \
          libxcvt \
          libxfont2 \
@@ -61,17 +58,7 @@ runs:
          xcb-util \
          xcb-util-image \
          libzip \
-          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
+          librsvg

    - name: Get hyprwayland-scanner-git
      shell: bash
@@ -82,11 +69,6 @@ runs:
        cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
        cmake --install build

-    - name: Get hyprgraphics-git
-      shell: bash
-      run: |
-        git clone https://github.com/hyprwm/hyprgraphics && cd hyprgraphics && cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -B build && cmake --build build --target hyprgraphics && cmake --install build
-
    - name: Get hyprutils-git
      shell: bash
      run: |
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,9 +1,3 @@
-<!--
-BEFORE you submit your PR, please check out the PR guidelines
-on our wiki: https://wiki.hyprland.org/Contributing-and-Debugging/PR-Guidelines/
-->
-
-
 #### Describe your PR, what does it fix/add?


--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -21,7 +21,7 @@ jobs:

      - name: Build Hyprland
        run: |
-          CFLAGS=-Werror CXXFLAGS=-Werror make all
+          make all

      - name: Compress and package artifacts
        run: |
@@ -107,7 +107,6 @@ 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
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -1,48 +0,0 @@
-name: clang-format
-on: pull_request_target
-jobs:
-  clang-format:
-    permissions: write-all
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
-    name: "Code Style (Arch)"
-    runs-on: ubuntu-latest
-    container:
-      image: archlinux
-    steps:
-      - name: Checkout repository actions
-        uses: actions/checkout@v4
-        with:
-          sparse-checkout: .github/actions
-
-      - name: Setup base
-        uses: ./.github/actions/setup_base
-
-      - name: Configure
-        run: meson setup build -Ddefault_library=static
-
-      - 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/.github/workflows/nix-build.yml
+++ b/.github/workflows/nix-build.yml
@@ -12,13 +12,13 @@ jobs:
      matrix:
        package:
          - hyprland
-          # - hyprland-cross # cross compiling fails due to qt
-          # failure chain: hyprland-qtutils -> qt6.qtsvg -> qt6.qtbase -> psqlodbc & qt6.qttranslations
+          - hyprland-cross
          - xdg-desktop-portal-hyprland

    runs-on: ubuntu-latest
    steps:
      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main

      - uses: cachix/cachix-action@v15
        with:
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -77,7 +77,6 @@ add_compile_definitions(HYPRLAND_VERSION="${HYPRLAND_VERSION}")
 include_directories(. "src/" "protocols/")

 set(CMAKE_CXX_STANDARD 26)
-set(CXX_STANDARD_REQUIRED ON)
 add_compile_options(
  -Wall
  -Wextra
@@ -102,25 +101,11 @@ else()
 endif()
 find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})

-pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.8.0)
-pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2)
-pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7)
-pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.5.1)
-pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
+pkg_check_modules(hyprctl_deps REQUIRED IMPORTED_TARGET hyprutils>=0.2.1)

-string(REPLACE "." ";" AQ_VERSION_LIST ${aquamarine_dep_VERSION})
-list(GET AQ_VERSION_LIST 0 AQ_VERSION_MAJOR)
-list(GET AQ_VERSION_LIST 1 AQ_VERSION_MINOR)
-list(GET AQ_VERSION_LIST 2 AQ_VERSION_PATCH)
+pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.4.2)

 add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}")
-add_compile_definitions(AQUAMARINE_VERSION_MAJOR=${AQ_VERSION_MAJOR})
-add_compile_definitions(AQUAMARINE_VERSION_MINOR=${AQ_VERSION_MINOR})
-add_compile_definitions(AQUAMARINE_VERSION_PATCH=${AQ_VERSION_PATCH})
-add_compile_definitions(HYPRLANG_VERSION="${hyprlang_dep_VERSION}")
-add_compile_definitions(HYPRUTILS_VERSION="${hyprutils_dep_VERSION}")
-add_compile_definitions(HYPRCURSOR_VERSION="${hyprcursor_dep_VERSION}")
-add_compile_definitions(HYPRGRAPHICS_VERSION="${hyprgraphics_dep_VERSION}")

 pkg_check_modules(
  deps
@@ -129,7 +114,7 @@ pkg_check_modules(
  xkbcommon
  uuid
  wayland-server>=1.22.90
-  wayland-protocols>=1.41
+  wayland-protocols
  cairo
  pango
  pangocairo
@@ -139,7 +124,9 @@ pkg_check_modules(
  libinput
  gbm
  gio-2.0
-  re2)
+  hyprlang>=0.3.2
+  hyprcursor>=0.1.7
+  hyprutils>=0.2.3)

 find_package(hyprwayland-scanner 0.3.10 REQUIRED)

@@ -206,12 +193,6 @@ 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)
@@ -241,15 +222,16 @@ if(NO_SYSTEMD)
 else()
  message(STATUS "SYSTEMD support is requested (NO_SYSTEMD not defined)...")
  add_compile_definitions(USES_SYSTEMD)
+  configure_file(systemd/hyprland-session.service.in
+                 systemd/hyprland-session.service @ONLY)

-  # session file -uwsm
-  if(NO_UWSM)
-    message(STATUS "UWSM support is disabled...")
-  else()
-    message(STATUS "UWSM support is enabled (NO_UWSM not defined)...")
-    install(FILES ${CMAKE_SOURCE_DIR}/systemd/hyprland-uwsm.desktop
-            DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/wayland-sessions)
-  endif()
+  # session file -systemd
+  install(FILES ${CMAKE_SOURCE_DIR}/systemd/hyprland-systemd.desktop
+          DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/wayland-sessions)
+
+  # install systemd service
+  install(FILES ${CMAKE_BINARY_DIR}/systemd/hyprland-session.service
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}/systemd/user)
 endif()

 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
@@ -263,15 +245,7 @@ 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::deps)
 if(udis_dep_FOUND)
  target_link_libraries(Hyprland PkgConfig::udis_dep)
 else()
@@ -313,7 +287,7 @@ endfunction()

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

-pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.2)
+pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.4.0)
 if(hyprland_protocols_dep_FOUND)
  pkg_get_variable(HYPRLAND_PROTOCOLS hyprland-protocols pkgdatadir)
  message(STATUS "hyprland-protocols dependency set to ${HYPRLAND_PROTOCOLS}")
@@ -339,12 +313,8 @@ 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)
@@ -377,20 +347,12 @@ protocolnew("staging/linux-drm-syncobj" "linux-drm-syncobj-v1" false)
 protocolnew("staging/xdg-dialog" "xdg-dialog-v1" false)
 protocolnew("staging/single-pixel-buffer" "single-pixel-buffer-v1" false)
 protocolnew("staging/security-context" "security-context-v1" false)
-protocolnew("staging/content-type" "content-type-v1" false)
-protocolnew("staging/color-management" "color-management-v1" false)

 protocolwayland()

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

 # binary and symlink
 install(TARGETS Hyprland)
@@ -401,6 +363,7 @@ 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)
@@ -444,5 +407,4 @@ install(
  DIRECTORY ${HEADERS_SRC}
  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hyprland
  FILES_MATCHING
-  PATTERN "*.h*"
-  PATTERN "*.frag")
+  PATTERN "*.h*")
--- a/2
+++ b/2
@@ -1 +1 @@
-0.48.0
+0.45.2
--- a/example/hyprland.conf
+++ b/example/hyprland.conf
@@ -81,7 +81,6 @@ 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
@@ -139,10 +138,10 @@ animations {
 # uncomment all if you wish to use that.
 # workspace = w[tv1], gapsout:0, gapsin:0
 # workspace = f[1], gapsout:0, gapsin:0
-# windowrule = bordersize 0, floating:0, onworkspace:w[tv1]
-# windowrule = rounding 0, floating:0, onworkspace:w[tv1]
-# windowrule = bordersize 0, floating:0, onworkspace:f[1]
-# windowrule = rounding 0, floating:0, onworkspace:f[1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:f[1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:f[1]

 # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
 dwindle {
@@ -276,11 +275,14 @@ bindl = , XF86AudioPrev, exec, playerctl previous
 # See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
 # See https://wiki.hyprland.org/Configuring/Workspace-Rules/ for workspace rules

-# Example windowrule
-# windowrule = float,class:^(kitty)$,title:^(kitty)$
+# Example windowrule v1
+# windowrule = float, ^(kitty)$
+
+# Example windowrule v2
+# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$

 # Ignore maximize requests from apps. You'll probably like this.
-windowrule = suppressevent maximize, class:.*
+windowrulev2 = suppressevent maximize, class:.*

 # Fix some dragging issues with XWayland
-windowrule = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0
+windowrulev2 = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0
--- a/example/launch.json
+++ b/example/launch.json
@@ -22,6 +22,5 @@
                }
            ]
        },
-        
    ]
 }
--- a/flake.lock
+++ b/flake.lock
@@ -16,11 +16,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1742213273,
-        "narHash": "sha256-0l0vDb4anfsBu1rOs94bC73Hub+xEivgBAo6QXl2MmU=",
+        "lastModified": 1731959031,
+        "narHash": "sha256-TGcvIjftziC1CjuiHCzrYDwmOoSFYIhdiKmLetzB5L0=",
        "owner": "hyprwm",
        "repo": "aquamarine",
-        "rev": "484b732195cc53f4536ce4bd59a5c6402b1e7ccf",
+        "rev": "4468981c1c50999f315baa1508f0e53c4ee70c52",
        "type": "github"
      },
      "original": {
@@ -79,11 +79,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1742215578,
-        "narHash": "sha256-zfs71PXVVPEe56WEyNi2TJQPs0wabU4WAlq0XV7GcdE=",
+        "lastModified": 1728669738,
+        "narHash": "sha256-EDNAU9AYcx8OupUzbTbWE1d3HYdeG0wO6Msg3iL1muk=",
        "owner": "hyprwm",
        "repo": "hyprcursor",
-        "rev": "2fd36421c21aa87e2fe3bee11067540ae612f719",
+        "rev": "0264e698149fcb857a66a53018157b41f8d97bb0",
        "type": "github"
      },
      "original": {
@@ -92,32 +92,6 @@
        "type": "github"
      }
    },
-    "hyprgraphics": {
-      "inputs": {
-        "hyprutils": [
-          "hyprutils"
-        ],
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "systems": [
-          "systems"
-        ]
-      },
-      "locked": {
-        "lastModified": 1739049071,
-        "narHash": "sha256-3+7TpXMrbsUXSwgr5VAKAnmkzMb6JO+Rvc9XRb5NMg4=",
-        "owner": "hyprwm",
-        "repo": "hyprgraphics",
-        "rev": "175c6b29b6ff82100539e7c4363a35a02c74dd73",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hyprwm",
-        "repo": "hyprgraphics",
-        "type": "github"
-      }
-    },
    "hyprland-protocols": {
      "inputs": {
        "nixpkgs": [
@@ -128,11 +102,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1738422629,
-        "narHash": "sha256-5v+bv75wJWvahyM2xcMTSNNxmV8a7hb01Eey5zYnBJw=",
+        "lastModified": 1728345020,
+        "narHash": "sha256-xGbkc7U/Roe0/Cv3iKlzijIaFBNguasI31ynL2IlEoM=",
        "owner": "hyprwm",
        "repo": "hyprland-protocols",
-        "rev": "755aef8dab49d0fc4663c715fa4ad221b2aedaed",
+        "rev": "a7c183800e74f337753de186522b9017a07a8cee",
        "type": "github"
      },
      "original": {
@@ -141,67 +115,6 @@
        "type": "github"
      }
    },
-    "hyprland-qt-support": {
-      "inputs": {
-        "hyprlang": [
-          "hyprland-qtutils",
-          "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",
-        "hyprlang": [
-          "hyprlang"
-        ],
-        "hyprutils": [
-          "hyprland-qtutils",
-          "hyprlang",
-          "hyprutils"
-        ],
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "systems": [
-          "systems"
-        ]
-      },
-      "locked": {
-        "lastModified": 1739048983,
-        "narHash": "sha256-REhTcXq4qs3B3cCDtLlYDz0GZvmsBSh947Ub6pQWGTQ=",
-        "owner": "hyprwm",
-        "repo": "hyprland-qtutils",
-        "rev": "3504a293c8f8db4127cb0f7cfc1a318ffb4316f8",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hyprwm",
-        "repo": "hyprland-qtutils",
-        "type": "github"
-      }
-    },
    "hyprlang": {
      "inputs": {
        "hyprutils": [
@@ -215,11 +128,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1741191527,
-        "narHash": "sha256-kM+11Nch47Xwfgtw2EpRitJuORy4miwoMuRi5tyMBDY=",
+        "lastModified": 1728168612,
+        "narHash": "sha256-AnB1KfiXINmuiW7BALYrKqcjCnsLZPifhb/7BsfPbns=",
        "owner": "hyprwm",
        "repo": "hyprlang",
-        "rev": "72df3861f1197e41b078faa3e38eedd60e00018d",
+        "rev": "f054f2e44d6a0b74607a6bc0f52dba337a3db38e",
        "type": "github"
      },
      "original": {
@@ -238,11 +151,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1741534688,
-        "narHash": "sha256-EV3945SnjOCuRVbGRghsWx/9D89FyshnSO1Q6/TuQ14=",
+        "lastModified": 1731702627,
+        "narHash": "sha256-+JeO9gevnXannQxMfR5xzZtF4sYmSlWkX/BPmPx0mWk=",
        "owner": "hyprwm",
        "repo": "hyprutils",
-        "rev": "dd1f720cbc2dbb3c71167c9598045dd3261d27b3",
+        "rev": "e911361a687753bbbdfe3b6a9eab755ecaf1d9e1",
        "type": "github"
      },
      "original": {
@@ -261,11 +174,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1739870480,
-        "narHash": "sha256-SiDN5BGxa/1hAsqhgJsS03C3t2QrLgBT8u+ENJ0Qzwc=",
+        "lastModified": 1726874836,
+        "narHash": "sha256-VKR0sf0PSNCB0wPHVKSAn41mCNVCnegWmgkrneKDhHM=",
        "owner": "hyprwm",
        "repo": "hyprwayland-scanner",
-        "rev": "206367a08dc5ac4ba7ad31bdca391d098082e64b",
+        "rev": "500c81a9e1a76760371049a8d99e008ea77aa59e",
        "type": "github"
      },
      "original": {
@@ -276,11 +189,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1742069588,
-        "narHash": "sha256-C7jVfohcGzdZRF6DO+ybyG/sqpo1h6bZi9T56sxLy+k=",
+        "lastModified": 1731676054,
+        "narHash": "sha256-OZiZ3m8SCMfh3B6bfGC/Bm4x3qc1m2SVEAlkV6iY7Yg=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "c80f6a7e10b39afcc1894e02ef785b1ad0b0d7e5",
+        "rev": "5e4fbfb6b3de1aa2872b76d49fafc942626e2add",
        "type": "github"
      },
      "original": {
@@ -290,20 +203,37 @@
        "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": 1742058297,
-        "narHash": "sha256-b4SZc6TkKw8WQQssbN5O2DaCEzmFfvSTPYHlx/SFW9Y=",
+        "lastModified": 1732021966,
+        "narHash": "sha256-mnTbjpdqF0luOkou8ZFi2asa1N3AA2CchR/RqCNmsGE=",
        "owner": "cachix",
        "repo": "git-hooks.nix",
-        "rev": "59f17850021620cd348ad2e9c0c64f4e6325ce2a",
+        "rev": "3308484d1a443fc5bc92012435d79e80458fe43c",
        "type": "github"
      },
      "original": {
@@ -316,9 +246,7 @@
      "inputs": {
        "aquamarine": "aquamarine",
        "hyprcursor": "hyprcursor",
-        "hyprgraphics": "hyprgraphics",
        "hyprland-protocols": "hyprland-protocols",
-        "hyprland-qtutils": "hyprland-qtutils",
        "hyprlang": "hyprlang",
        "hyprutils": "hyprutils",
        "hyprwayland-scanner": "hyprwayland-scanner",
@@ -365,11 +293,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1741934139,
-        "narHash": "sha256-ZhTcTH9FoeAtbPfWGrhkH7RjLJZ7GeF18nygLAMR+WE=",
+        "lastModified": 1731703417,
+        "narHash": "sha256-rheDc/7C+yI+QspYr9J2z9kQ5P9F4ATapI7qyFAe1XA=",
        "owner": "hyprwm",
        "repo": "xdg-desktop-portal-hyprland",
-        "rev": "150b0b6f52bb422a1b232a53698606fe0320dde0",
+        "rev": "8070f36deec723de71e7557441acb17e478204d3",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@@ -22,26 +22,12 @@
      inputs.hyprlang.follows = "hyprlang";
    };

-    hyprgraphics = {
-      url = "github:hyprwm/hyprgraphics";
-      inputs.nixpkgs.follows = "nixpkgs";
-      inputs.systems.follows = "systems";
-      inputs.hyprutils.follows = "hyprutils";
-    };
-
    hyprland-protocols = {
      url = "github:hyprwm/hyprland-protocols";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.systems.follows = "systems";
    };

-    hyprland-qtutils = {
-      url = "github:hyprwm/hyprland-qtutils";
-      inputs.nixpkgs.follows = "nixpkgs";
-      inputs.systems.follows = "systems";
-      inputs.hyprlang.follows = "hyprlang";
-    };
-
    hyprlang = {
      url = "github:hyprwm/hyprlang";
      inputs.nixpkgs.follows = "nixpkgs";
@@ -130,11 +116,13 @@
      inherit
        (pkgsFor.${system})
        # hyprland-packages
+
        hyprland
        hyprland-debug
        hyprland-legacy-renderer
        hyprland-unwrapped
        # hyprland-extras
+
        xdg-desktop-portal-hyprland
        ;
      hyprland-cross = (pkgsCrossFor.${system} "aarch64-linux").hyprland;
@@ -157,11 +145,5 @@

    nixosModules.default = import ./nix/module.nix inputs;
    homeManagerModules.default = import ./nix/hm-module.nix self;
-
-    # Hydra build jobs
-    # Recent versions of Hydra can aggregate jobsets from 'hydraJobs' intead of a release.nix
-    # or similar. Remember to filter large or incompatible attributes here. More eval jobs can
-    # be added by merging, e.g., self.packages // self.devShells.
-    hydraJobs = self.packages;
  };
 }
--- a/hyprctl/CMakeLists.txt
+++ b/hyprctl/CMakeLists.txt
@@ -5,7 +5,7 @@ project(
    DESCRIPTION "Control utility for Hyprland"
 )

-pkg_check_modules(hyprctl_deps REQUIRED IMPORTED_TARGET hyprutils>=0.2.4 re2)
+pkg_check_modules(deps REQUIRED IMPORTED_TARGET hyprutils>=0.1.1)

 add_executable(hyprctl "main.cpp")

--- a/hyprctl/Strings.hpp
+++ b/hyprctl/Strings.hpp
@@ -22,7 +22,6 @@ commands:
    getoption <option>  → Gets the config option status (values)
    globalshortcuts     → Lists all global shortcuts
    hyprpaper ...       → Issue a hyprpaper request
-    hyprsunset ...      → Issue a hyprsunset request
    instances           → Lists all running instances of Hyprland with
                          their info
    keyword <name> <value> → Issue a keyword to call a config keyword
@@ -82,16 +81,6 @@ requests:
 flags:
    See 'hyprctl --help')#";

-const std::string_view HYPRSUNSET_HELP = R"#(usage: hyprctl [flags] hyprsunset <request>
-
-requests:
-    temperature <temp> → Enable blue-light filter
-    identity           → Disable blue-light filter
-    gamma <gamma>      → Enable gamma filter
-
-flags:
-    See 'hyprctl --help')#";
-
 const std::string_view NOTIFY_HELP = R"#(usage: hyprctl [flags] notify <icon> <time_ms> <color> <message...>

 icon:
--- a/hyprctl/main.cpp
+++ b/hyprctl/main.cpp
@@ -1,5 +1,3 @@
-#include <re2/re2.h>
-
 #include <cctype>
 #include <netdb.h>
 #include <netinet/in.h>
@@ -12,17 +10,24 @@
 #include <sys/un.h>
 #include <pwd.h>
 #include <unistd.h>
+#include <ranges>
 #include <algorithm>
 #include <csignal>
+#include <format>

 #include <iostream>
 #include <string>
 #include <print>
 #include <fstream>
+#include <string>
 #include <vector>
+#include <deque>
 #include <filesystem>
 #include <cstdarg>
+#include <regex>
+#include <sys/socket.h>
 #include <hyprutils/string/String.hpp>
+#include <cstring>
 using namespace Hyprutils::String;

 #include "Strings.hpp"
@@ -47,17 +52,11 @@ void log(const std::string& str) {
    std::println("{}", str);
 }

-static int getUID() {
-    const auto UID   = getuid();
-    const auto PWUID = getpwuid(UID);
-    return PWUID ? PWUID->pw_uid : UID;
-}
-
 std::string getRuntimeDir() {
    const auto XDG = getenv("XDG_RUNTIME_DIR");

    if (!XDG) {
-        const std::string USERID = std::to_string(getUID());
+        const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
        return "/run/user/" + USERID + "/hypr";
    }

@@ -67,11 +66,6 @@ std::string getRuntimeDir() {
 std::vector<SInstanceData> instances() {
    std::vector<SInstanceData> result;

-    try {
-        if (!std::filesystem::exists(getRuntimeDir()))
-            return {};
-    } catch (std::exception& e) { return {}; }
-
    for (const auto& el : std::filesystem::directory_iterator(getRuntimeDir())) {
        if (!el.is_directory() || !std::filesystem::exists(el.path().string() + "/hyprland.lock"))
            continue;
@@ -149,16 +143,8 @@ int rollingRead(const int socket) {
 int request(std::string arg, int minArgs = 0, bool needRoll = false) {
    const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);

-    if (SERVERSOCKET < 0) {
-        log("Couldn't open a socket (1)");
-        return 1;
-    }
-
-    auto t = timeval{.tv_sec = 5, .tv_usec = 0};
-    if (setsockopt(SERVERSOCKET, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0) {
-        log("Couldn't set socket timeout (2)");
-        return 2;
-    }
+    auto       t = timeval{.tv_sec = 5, .tv_usec = 0};
+    setsockopt(SERVERSOCKET, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval));

    const auto ARGS = std::count(arg.begin(), arg.end(), ' ');

@@ -167,12 +153,17 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
        return -1;
    }

-    if (instanceSignature.empty()) {
-        log("HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?) (3)");
-        return 3;
+    if (SERVERSOCKET < 0) {
+        log("Couldn't open a socket (1)");
+        return 1;
    }

-    const std::string USERID = std::to_string(getUID());
+    if (instanceSignature.empty()) {
+        log("HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)");
+        return 2;
+    }
+
+    const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);

    sockaddr_un       serverAddress = {0};
    serverAddress.sun_family        = AF_UNIX;
@@ -182,40 +173,39 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
    strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);

    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
-        log("Couldn't connect to " + socketPath + ". (4)");
-        return 4;
+        log("Couldn't connect to " + socketPath + ". (3)");
+        return 3;
    }

    auto sizeWritten = write(SERVERSOCKET, arg.c_str(), arg.length());

    if (sizeWritten < 0) {
-        log("Couldn't write (5)");
-        return 5;
+        log("Couldn't write (4)");
+        return 4;
    }

    if (needRoll)
        return rollingRead(SERVERSOCKET);

-    std::string      reply               = "";
-    constexpr size_t BUFFER_SIZE         = 8192;
-    char             buffer[BUFFER_SIZE] = {0};
+    std::string reply        = "";
+    char        buffer[8192] = {0};

-    sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+    sizeWritten = read(SERVERSOCKET, buffer, 8192);

    if (sizeWritten < 0) {
        if (errno == EWOULDBLOCK)
            log("Hyprland IPC didn't respond in time\n");
-        log("Couldn't read (6)");
-        return 6;
+        log("Couldn't read (5)");
+        return 5;
    }

    reply += std::string(buffer, sizeWritten);

-    while (sizeWritten == BUFFER_SIZE) {
-        sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+    while (sizeWritten == 8192) {
+        sizeWritten = read(SERVERSOCKET, buffer, 8192);
        if (sizeWritten < 0) {
-            log("Couldn't read (6)");
-            return 6;
+            log("Couldn't read (5)");
+            return 5;
        }
        reply += std::string(buffer, sizeWritten);
    }
@@ -227,7 +217,7 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
    return 0;
 }

-int requestIPC(std::string filename, std::string arg) {
+int requestHyprpaper(std::string arg) {
    const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);

    if (SERVERSOCKET < 0) {
@@ -243,9 +233,9 @@ int requestIPC(std::string filename, std::string arg) {
    sockaddr_un serverAddress = {0};
    serverAddress.sun_family  = AF_UNIX;

-    const std::string USERID = std::to_string(getUID());
+    const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);

-    std::string       socketPath = getRuntimeDir() + "/" + instanceSignature + "/" + filename;
+    std::string       socketPath = getRuntimeDir() + "/" + instanceSignature + "/.hyprpaper.sock";

    strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);

@@ -263,10 +253,10 @@ int requestIPC(std::string filename, std::string arg) {
        log("Couldn't write (4)");
        return 4;
    }
-    constexpr size_t BUFFER_SIZE         = 8192;
-    char             buffer[BUFFER_SIZE] = {0};

-    sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+    char buffer[8192] = {0};
+
+    sizeWritten = read(SERVERSOCKET, buffer, 8192);

    if (sizeWritten < 0) {
        log("Couldn't read (5)");
@@ -280,20 +270,11 @@ int requestIPC(std::string filename, std::string arg) {
    return 0;
 }

-int requestHyprpaper(std::string arg) {
-    return requestIPC(".hyprpaper.sock", arg);
-}
-
-int requestHyprsunset(std::string arg) {
-    return requestIPC(".hyprsunset.sock", arg);
-}
-
 void batchRequest(std::string arg, bool json) {
-    std::string commands = arg.substr(arg.find_first_of(' ') + 1);
+    std::string commands = arg.substr(arg.find_first_of(" ") + 1);

    if (json) {
-        RE2::GlobalReplace(&commands, ";\\s*", ";j/");
-        commands.insert(0, "j/");
+        commands = "j/" + std::regex_replace(commands, std::regex(";\\s*"), ";j/");
    }

    std::string rq = "[[BATCH]]" + commands;
@@ -330,11 +311,11 @@ void instancesRequest(bool json) {
    log(result + "\n");
 }

-std::vector<std::string> splitArgs(int argc, char** argv) {
-    std::vector<std::string> result;
+std::deque<std::string> splitArgs(int argc, char** argv) {
+    std::deque<std::string> result;

    for (auto i = 1 /* skip the executable */; i < argc; ++i)
-        result.emplace_back(argv[i]);
+        result.push_back(std::string(argv[i]));

    return result;
 }
@@ -392,8 +373,6 @@ int main(int argc, char** argv) {

                if (cmd == "hyprpaper") {
                    std::println("{}", HYPRPAPER_HELP);
-                } else if (cmd == "hyprsunset") {
-                    std::println("{}", HYPRSUNSET_HELP);
                } else if (cmd == "notify") {
                    std::println("{}", NOTIFY_HELP);
                } else if (cmd == "output") {
@@ -475,8 +454,6 @@ int main(int argc, char** argv) {
        batchRequest(fullRequest, json);
    else if (fullRequest.contains("/hyprpaper"))
        exitStatus = requestHyprpaper(fullRequest);
-    else if (fullRequest.contains("/hyprsunset"))
-        exitStatus = requestHyprsunset(fullRequest);
    else if (fullRequest.contains("/switchxkblayout"))
        exitStatus = request(fullRequest, 2);
    else if (fullRequest.contains("/seterror"))
--- a/hyprctl/meson.build
+++ b/hyprctl/meson.build
@@ -3,7 +3,6 @@ executable(
  'main.cpp',
  dependencies: [
    dependency('hyprutils', version: '>= 0.1.1'),
-    dependency('re2', required: true)
  ],
  install: true,
 )
--- a/hyprpm/CMakeLists.txt
+++ b/hyprpm/CMakeLists.txt
@@ -9,25 +9,11 @@ file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")

 set(CMAKE_CXX_STANDARD 23)

-pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.2.4)
-
-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()
+pkg_check_modules(deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.1.1)

 add_executable(hyprpm ${SRCFILES})

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

 # 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 plugins to match the enabled/disabled state. Use -f to force reload."
+        |   (reload)                    "Reload all plugins"
        ;

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

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

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

 std::string DataState::getHeadersPath() {
-    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;
+    return getDataStatePath() + "/headersRoot";
 }

 void DataState::ensureStateStoreExists() {
@@ -53,7 +37,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
@@ -66,21 +50,19 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
        }}
    };
    for (auto const& p : repo.plugins) {
-        const auto filename = p.name + ".so";
-
        // copy .so to the good place
        if (std::filesystem::exists(p.filename))
-            std::filesystem::copy_file(p.filename, PATH / filename);
+            std::filesystem::copy_file(p.filename, PATH + "/" + p.name + ".so");

        DATA.emplace(p.name, toml::table{
-            {"filename", filename},
+            {"filename", p.name + ".so"},
            {"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();
 }
@@ -90,10 +72,17 @@ bool DataState::pluginRepoExists(const std::string& urlOrName) {

    const auto PATH = getDataStatePath();

-    for (const auto& stateFile : getPluginStates()) {
-        const auto STATE = toml::parse_file(stateFile.c_str());
-        const auto NAME  = STATE["repository"]["name"].value_or("");
-        const auto URL   = STATE["repository"]["url"].value_or("");
+    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("");

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

    const auto PATH = getDataStatePath();

-    for (const auto& stateFile : getPluginStates()) {
-        const auto STATE = toml::parse_file(stateFile.c_str());
-        const auto NAME  = STATE["repository"]["name"].value_or("");
-        const auto URL   = STATE["repository"]["url"].value_or("");
+    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("");

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

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

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

-            std::filesystem::remove_all(stateFile.parent_path());
+            std::filesystem::remove_all(entry.path());
            return;
        }
    }
@@ -143,7 +139,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();
 }
@@ -151,12 +147,12 @@ void DataState::updateGlobalState(const SGlobalState& state) {
 SGlobalState DataState::getGlobalState() {
    ensureStateStoreExists();

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

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

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

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

    std::vector<SPluginRepository> repos;
-    for (const auto& stateFile : getPluginStates()) {
-        const auto        STATE = toml::parse_file(stateFile.c_str());
+
+    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("");
@@ -207,8 +210,15 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {

    const auto PATH = getDataStatePath();

-    for (const auto& stateFile : getPluginStates()) {
-        const auto STATE = toml::parse_file(stateFile.c_str());
+    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& [key, val] : STATE) {
            if (key == "repository")
                continue;
@@ -221,11 +231,10 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
            if (FAILED)
                return false;

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

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

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

 namespace DataState {
-    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();
+    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();
 };
--- a/hyprpm/src/core/PluginManager.cpp
+++ b/hyprpm/src/core/PluginManager.cpp
@@ -7,8 +7,10 @@

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

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

 #include <hyprutils/string/String.hpp>
-#include <hyprutils/os/Process.hpp>
 using namespace Hyprutils::String;
-using namespace Hyprutils::OS;

 static std::string execAndGet(std::string cmd) {
    cmd += " 2>&1";
+    std::array<char, 128> buffer;
+    std::string           result;
+    using PcloseType = int (*)(FILE*);
+    const std::unique_ptr<FILE, PcloseType> pipe(popen(cmd.c_str(), "r"), static_cast<PcloseType>(pclose));
+    if (!pipe)
+        return "";

-    CProcess proc("/bin/sh", {"-c", cmd});
-
-    if (!proc.runSync())
-        return "error";
-
-    return proc.stdOut();
-}
-
-static std::string getTempRoot() {
-    static auto ENV = getenv("XDG_RUNTIME_DIR");
-    if (!ENV) {
-        std::cerr << "\nERROR: XDG_RUNTIME_DIR not set!\n";
-        exit(1);
+    result.reserve(buffer.size());
+    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
+        result += buffer.data();
    }
-
-    const auto STR = ENV + std::string{"/hyprpm/"};
-
-    return STR;
+    return result;
 }

-SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
-    static bool             onceRunning   = false;
-    static bool             onceInstalled = false;
-    static SHyprlandVersion verRunning;
-    static SHyprlandVersion verInstalled;
+SHyprlandVersion CPluginManager::getHyprlandVersion() {
+    static SHyprlandVersion ver;
+    static bool             once = false;

-    if (onceRunning && running)
-        return verRunning;
+    if (once)
+        return ver;

-    if (onceInstalled && !running)
-        return verInstalled;
-
-    if (running)
-        onceRunning = true;
-    else
-        onceInstalled = true;
-
-    const auto HLVERCALL = running ? execAndGet("hyprctl version") : execAndGet("Hyprland --version");
+    once                 = true;
+    const auto HLVERCALL = execAndGet("hyprctl version");
    if (m_bVerbose)
-        std::println("{}", verboseString("{} version returned: {}", running ? "running" : "installed", HLVERCALL));
+        std::println("{}", verboseString("version returned: {}", HLVERCALL));

    if (!HLVERCALL.contains("Tag:")) {
        std::println(stderr, "\n{}", failureString("You don't seem to be running Hyprland."));
@@ -82,13 +65,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;
@@ -99,18 +82,12 @@ SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
    if (m_bVerbose)
        std::println("{}", verboseString("parsed commit {} at branch {} on {}, commits {}", hlcommit, hlbranch, hldate, commits));

-    auto ver = SHyprlandVersion{hlbranch, hlcommit, hldate, commits};
-
-    if (running)
-        verRunning = ver;
-    else
-        verInstalled = ver;
-
+    ver = SHyprlandVersion{hlbranch, hlcommit, hldate, commits};
    return ver;
 }

 bool CPluginManager::createSafeDirectory(const std::string& path) {
-    if (path.empty() || !path.starts_with(getTempRoot()))
+    if (path.empty() || !path.starts_with("/tmp"))
        return false;

    if (std::filesystem::exists(path))
@@ -129,7 +106,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
    const auto HLVER = getHyprlandVersion();

    if (!hasDeps()) {
-        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
+        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio"));
        return false;
    }

@@ -168,17 +145,17 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&

    progress.print();

-    if (!std::filesystem::exists(getTempRoot())) {
-        std::filesystem::create_directory(getTempRoot());
-        std::filesystem::permissions(getTempRoot(), std::filesystem::perms::owner_all, std::filesystem::perm_options::replace);
-    } else if (!std::filesystem::is_directory(getTempRoot())) {
+    if (!std::filesystem::exists("/tmp/hyprpm")) {
+        std::filesystem::create_directory("/tmp/hyprpm");
+        std::filesystem::permissions("/tmp/hyprpm", std::filesystem::perms::all, std::filesystem::perm_options::replace);
+    } else if (!std::filesystem::is_directory("/tmp/hyprpm")) {
        std::println(stderr, "\n{}", failureString("Could not prepare working dir for hyprpm"));
        return false;
    }

    const std::string USERNAME = getpwuid(getuid())->pw_name;

-    m_szWorkingPluginDirectory = getTempRoot() + USERNAME;
+    m_szWorkingPluginDirectory = "/tmp/hyprpm/" + USERNAME;

    if (!createSafeDirectory(m_szWorkingPluginDirectory)) {
        std::println(stderr, "\n{}", failureString("Could not prepare working dir for repo"));
@@ -187,7 +164,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&

    progress.printMessageAbove(infoString("Cloning {}", url));

-    std::string ret = execAndGet(std::format("cd {} && git clone --recursive {} {}", getTempRoot(), url, USERNAME));
+    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + url + " " + USERNAME);

    if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/.git")) {
        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. shell returned:\n{}", ret));
@@ -370,14 +347,14 @@ bool CPluginManager::removePluginRepo(const std::string& urlOrName) {
 }

 eHeadersErrors CPluginManager::headersValid() {
-    const auto HLVER = getHyprlandVersion(false);
+    const auto HLVER = getHyprlandVersion();

    if (!std::filesystem::exists(DataState::getHeadersPath() + "/share/pkgconfig/hyprland.pc"))
        return HEADERS_MISSING;

    // 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);
+    auto               headers = execAndGet(cmd.c_str());

    if (!headers.contains("-I/"))
        return HEADERS_MISSING;
@@ -432,16 +409,16 @@ bool CPluginManager::updateHeaders(bool force) {

    DataState::ensureStateStoreExists();

-    const auto HLVER = getHyprlandVersion(false);
+    const auto HLVER = getHyprlandVersion();

    if (!hasDeps()) {
-        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
+        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio"));
        return false;
    }

-    if (!std::filesystem::exists(getTempRoot())) {
-        std::filesystem::create_directory(getTempRoot());
-        std::filesystem::permissions(getTempRoot(), std::filesystem::perms::owner_all, std::filesystem::perm_options::replace);
+    if (!std::filesystem::exists("/tmp/hyprpm")) {
+        std::filesystem::create_directory("/tmp/hyprpm");
+        std::filesystem::permissions("/tmp/hyprpm", std::filesystem::perms::all, std::filesystem::perm_options::replace);
    }

    if (!force && headersValid() == HEADERS_OK) {
@@ -456,16 +433,14 @@ bool CPluginManager::updateHeaders(bool force) {
    progress.print();

    const std::string USERNAME   = getpwuid(getuid())->pw_name;
-    const auto        WORKINGDIR = getTempRoot() + "hyprland-" + USERNAME;
+    const auto        WORKINGDIR = "/tmp/hyprpm/hyprland-" + USERNAME;

    if (!createSafeDirectory(WORKINGDIR)) {
        std::println("\n{}", failureString("Could not prepare working dir for hl"));
        return false;
    }

-    const auto& HL_URL = m_szCustomHlUrl.empty() ? "https://github.com/hyprwm/Hyprland" : m_szCustomHlUrl;
-
-    progress.printMessageAbove(statusString("!", Colors::YELLOW, "Cloning {}, this might take a moment.", HL_URL));
+    progress.printMessageAbove(statusString("!", Colors::YELLOW, "Cloning https://github.com/hyprwm/Hyprland, this might take a moment."));

    const bool bShallow = (HLVER.branch == "main") && !m_bNoShallow;

@@ -477,11 +452,11 @@ bool CPluginManager::updateHeaders(bool force) {
        progress.printMessageAbove(verboseString("will shallow since: {}", SHALLOW_DATE));

    std::string ret =
-        execAndGet(std::format("cd {} && git clone --recursive {} hyprland-{}{}", getTempRoot(), HL_URL, USERNAME, (bShallow ? " --shallow-since='" + SHALLOW_DATE + "'" : "")));
+        execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/Hyprland hyprland-" + USERNAME + (bShallow ? " --shallow-since='" + SHALLOW_DATE + "'" : ""));

    if (!std::filesystem::exists(WORKINGDIR)) {
        progress.printMessageAbove(failureString("Clone failed. Retrying without shallow."));
-        ret = execAndGet(std::format("cd {} && git clone --recursive {} hyprland-{}", getTempRoot(), HL_URL, USERNAME));
+        ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland-" + USERNAME);
    }

    if (!std::filesystem::exists(WORKINGDIR + "/.git")) {
@@ -596,7 +571,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
        return true;
    }

-    const auto   HLVER = getHyprlandVersion(false);
+    const auto   HLVER = getHyprlandVersion();

    CProgressBar progress;
    progress.m_iMaxSteps        = REPOS.size() * 2 + 2;
@@ -605,7 +580,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
    progress.print();

    const std::string USERNAME = getpwuid(getuid())->pw_name;
-    m_szWorkingPluginDirectory = getTempRoot() + USERNAME;
+    m_szWorkingPluginDirectory = "/tmp/hyprpm/" + USERNAME;

    for (auto const& repo : REPOS) {
        bool update = forceUpdateAll;
@@ -620,7 +595,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {

        progress.printMessageAbove(infoString("Cloning {}", repo.url));

-        std::string ret = execAndGet(std::format("cd {} && git clone --recursive {} {}", getTempRoot(), repo.url, USERNAME));
+        std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + repo.url + " " + USERNAME);

        if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/.git")) {
            std::println("{}", failureString("could not clone repo: shell returned: {}", ret));
@@ -782,7 +757,7 @@ bool CPluginManager::disablePlugin(const std::string& name) {
    return ret;
 }

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

-    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;
-    }
+    auto                     pluginLines = execAndGet("hyprctl plugins list | grep Plugin");

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

@@ -838,20 +820,12 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload)
        return "";
    };

-    // if any of the loadUnloadPlugin calls return false, this is true
-    // bcs that means the header version doesn't match the running version
-    // (and Hyprland needs to restart)
-    bool hyprlandVersionMismatch = false;
-
-    // unload disabled plugins (or all if forceReload is true)
+    // unload disabled plugins
    for (auto const& p : loadedPlugins) {
-        if (forceReload || !enabled(p)) {
+        if (!enabled(p)) {
            // unload
-            if (!loadUnloadPlugin(HYPRPMPATH / repoForName(p) / (p + ".so"), false)) {
-                std::println("{}", infoString("{} will be unloaded after restarting Hyprland", p));
-                hyprlandVersionMismatch = true;
-            } else
-                std::println("{}", successString("Unloaded {}", p));
+            loadUnloadPlugin(HYPRPMPATH + repoForName(p) + "/" + p + ".so", false);
+            std::println("{}", successString("Unloaded {}", p));
        }
    }

@@ -861,31 +835,20 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload)
            if (!p.enabled)
                continue;

-            if (!forceReload && std::find_if(loadedPlugins.begin(), loadedPlugins.end(), [&](const auto& other) { return other == p.name; }) != loadedPlugins.end())
+            if (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)) {
-                std::println("{}", infoString("{} will be loaded after restarting Hyprland", p.name));
-                hyprlandVersionMismatch = true;
-            } else
-                std::println("{}", successString("Loaded {}", p.name));
+            loadUnloadPlugin(HYPRPMPATH + repoForName(p.name) + "/" + p.filename, true);
+            std::println("{}", successString("Loaded {}", p.name));
        }
    }

    std::println("{}", successString("Plugin load state ensured"));

-    return hyprlandVersionMismatch ? LOADSTATE_HYPRLAND_UPDATED : LOADSTATE_OK;
+    return LOADSTATE_OK;
 }

 bool CPluginManager::loadUnloadPlugin(const std::string& path, bool load) {
-    auto state = DataState::getGlobalState();
-    auto HLVER = getHyprlandVersion(true);
-
-    if (state.headersHashCompiled != HLVER.hash) {
-        std::println("{}", infoString("Running Hyprland version differs from plugin state, please restart Hyprland."));
-        return false;
-    }
-
    if (load)
        execAndGet("hyprctl plugin load " + path);
    else
--- a/hyprpm/src/core/PluginManager.hpp
+++ b/hyprpm/src/core/PluginManager.hpp
@@ -27,8 +27,7 @@ enum ePluginLoadStateReturn {
    LOADSTATE_OK = 0,
    LOADSTATE_FAIL,
    LOADSTATE_PARTIAL_FAIL,
-    LOADSTATE_HEADERS_OUTDATED,
-    LOADSTATE_HYPRLAND_UPDATED
+    LOADSTATE_HEADERS_OUTDATED
 };

 struct SHyprlandVersion {
@@ -51,10 +50,10 @@ class CPluginManager {

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

    bool                   loadUnloadPlugin(const std::string& path, bool load);
-    SHyprlandVersion       getHyprlandVersion(bool running = true);
+    SHyprlandVersion       getHyprlandVersion();

    void                   notify(const eNotifyIcons icon, uint32_t color, int durationMs, const std::string& message);

@@ -62,7 +61,6 @@ class CPluginManager {

    bool                   m_bVerbose   = false;
    bool                   m_bNoShallow = false;
-    std::string            m_szCustomHlUrl;

    // will delete recursively if exists!!
    bool createSafeDirectory(const std::string& path);
--- a/hyprpm/src/main.cpp
+++ b/hyprpm/src/main.cpp
@@ -29,7 +29,6 @@ constexpr std::string_view HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┣ --verbose      | -v    → Enable too much logging
 ┣ --force        | -f    → Force an operation ignoring checks (e.g. update -f)
 ┣ --no-shallow   | -s    → Disable shallow cloning of Hyprland sources
-┣ --hl-url       |       → Pass a custom hyprland source url
 ┗
 )#";

@@ -46,7 +45,6 @@ int                        main(int argc, char** argv, char** envp) {

    std::vector<std::string> command;
    bool                     notify = false, notifyFail = false, verbose = false, force = false, noShallow = false;
-    std::string              customHlUrl;

    for (int i = 1; i < argc; ++i) {
        if (ARGS[i].starts_with("-")) {
@@ -61,13 +59,6 @@ int                        main(int argc, char** argv, char** envp) {
                verbose = true;
            } else if (ARGS[i] == "--no-shallow" || ARGS[i] == "-s") {
                noShallow = true;
-            } else if (ARGS[i] == "--hl-url") {
-                if (i + 1 >= argc) {
-                    std::println(stderr, "Missing argument for --hl-url");
-                    return 1;
-                }
-                customHlUrl = ARGS[i + 1];
-                i++;
            } else if (ARGS[i] == "--force" || ARGS[i] == "-f") {
                force = true;
                std::println("{}", statusString("!", Colors::RED, "Using --force, I hope you know what you are doing."));
@@ -75,19 +66,19 @@ int                        main(int argc, char** argv, char** envp) {
                std::println(stderr, "Unrecognized option {}", ARGS[i]);
                return 1;
            }
-        } else
+        } else {
            command.push_back(ARGS[i]);
+        }
    }

    if (command.empty()) {
        std::println(stderr, "{}", HELP);
-        return 1;
+        return 0;
    }

-    g_pPluginManager                  = std::make_unique<CPluginManager>();
-    g_pPluginManager->m_bVerbose      = verbose;
-    g_pPluginManager->m_bNoShallow    = noShallow;
-    g_pPluginManager->m_szCustomHlUrl = customHlUrl;
+    g_pPluginManager               = std::make_unique<CPluginManager>();
+    g_pPluginManager->m_bVerbose   = verbose;
+    g_pPluginManager->m_bNoShallow = noShallow;

    if (command[0] == "add") {
        if (command.size() < 2) {
@@ -112,7 +103,7 @@ int                        main(int argc, char** argv, char** envp) {
        bool headersValid = g_pPluginManager->headersValid() == HEADERS_OK;
        bool headers      = g_pPluginManager->updateHeaders(force);
        if (headers) {
-            const auto HLVER            = g_pPluginManager->getHyprlandVersion(false);
+            const auto HLVER            = g_pPluginManager->getHyprlandVersion();
            auto       GLOBALSTATE      = DataState::getGlobalState();
            const auto COMPILEDOUTDATED = HLVER.hash != GLOBALSTATE.headersHashCompiled;

@@ -123,9 +114,6 @@ int                        main(int argc, char** argv, char** envp) {

            auto ret2 = g_pPluginManager->ensurePluginsLoadState();

-            if (ret2 == LOADSTATE_HYPRLAND_UPDATED)
-                g_pPluginManager->notify(ICON_INFO, 0, 10000, "[hyprpm] Updated plugins, but Hyprland was updated. Please restart Hyprland.");
-
            if (ret2 != LOADSTATE_OK)
                return 1;
        } else if (notify)
@@ -142,10 +130,6 @@ int                        main(int argc, char** argv, char** envp) {
        }

        auto ret = g_pPluginManager->ensurePluginsLoadState();
-
-        if (ret == LOADSTATE_HYPRLAND_UPDATED)
-            g_pPluginManager->notify(ICON_INFO, 0, 10000, "[hyprpm] Enabled plugin, but Hyprland was updated. Please restart Hyprland.");
-
        if (ret != LOADSTATE_OK)
            return 1;
    } else if (command[0] == "disable") {
@@ -163,21 +147,17 @@ int                        main(int argc, char** argv, char** envp) {
        if (ret != LOADSTATE_OK)
            return 1;
    } else if (command[0] == "reload") {
-        auto ret = g_pPluginManager->ensurePluginsLoadState(force);
+        auto ret = g_pPluginManager->ensurePluginsLoadState();

-        if (ret != LOADSTATE_OK) {
-            if (notify) {
-                switch (ret) {
-                    case LOADSTATE_FAIL:
-                    case LOADSTATE_PARTIAL_FAIL: g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Failed to load plugins"); break;
-                    case LOADSTATE_HEADERS_OUTDATED:
-                        g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Failed to load plugins: Outdated headers. Please run hyprpm update manually.");
-                        break;
-                    default: break;
-                }
+        if (ret != LOADSTATE_OK && notify) {
+            switch (ret) {
+                case LOADSTATE_FAIL:
+                case LOADSTATE_PARTIAL_FAIL: g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Failed to load plugins"); break;
+                case LOADSTATE_HEADERS_OUTDATED:
+                    g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Failed to load plugins: Outdated headers. Please run hyprpm update manually.");
+                    break;
+                default: break;
            }
-
-            return 1;
        } else if (notify && !notifyFail) {
            g_pPluginManager->notify(ICON_OK, 0, 4000, "[hyprpm] Loaded plugins");
        }
--- a/hyprpm/src/meson.build
+++ b/hyprpm/src/meson.build
@@ -8,7 +8,6 @@ executable(
    dependency('hyprutils', version: '>= 0.1.1'),
    dependency('threads'),
    dependency('tomlplusplus'),
-    dependency('glaze', method: 'cmake'),
  ],
  install: true,
 )
--- a/meson.build
+++ b/meson.build
@@ -31,20 +31,8 @@ if cpp_compiler.check_header('execinfo.h')
  add_project_arguments('-DHAS_EXECINFO', language: 'cpp')
 endif

-aquamarine = dependency('aquamarine', version: '>=0.8.0')
-hyprcursor = dependency('hyprcursor', version: '>=0.1.7')
-hyprgraphics = dependency('hyprgraphics', version: '>= 0.1.1')
-hyprlang = dependency('hyprlang', version: '>= 0.3.2')
-hyprutils = dependency('hyprutils', version: '>= 0.2.3')
-aquamarine_version_list = aquamarine.version().split('.')
+aquamarine = dependency('aquamarine', version: '>=0.4.2')
 add_project_arguments(['-DAQUAMARINE_VERSION="@0@"'.format(aquamarine.version())], language: 'cpp')
-add_project_arguments(['-DAQUAMARINE_VERSION_MAJOR=@0@'.format(aquamarine_version_list.get(0))], language: 'cpp')
-add_project_arguments(['-DAQUAMARINE_VERSION_MINOR=@0@'.format(aquamarine_version_list.get(1))], language: 'cpp')
-add_project_arguments(['-DAQUAMARINE_VERSION_PATCH=@0@'.format(aquamarine_version_list.get(2))], language: 'cpp')
-add_project_arguments(['-DHYPRCURSOR_VERSION="@0@"'.format(hyprcursor.version())], language: 'cpp')
-add_project_arguments(['-DHYPRGRAPHICS_VERSION="@0@"'.format(hyprgraphics.version())], language: 'cpp')
-add_project_arguments(['-DHYPRLANG_VERSION="@0@"'.format(hyprlang.version())], language: 'cpp')
-add_project_arguments(['-DHYPRUTILS_VERSION="@0@"'.format(hyprutils.version())], language: 'cpp')

 xcb_dep = dependency('xcb', required: get_option('xwayland'))
 xcb_composite_dep = dependency('xcb-composite', required: get_option('xwayland'))
@@ -62,17 +50,10 @@ 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)

 # Handle options
-systemd_option = get_option('systemd')
-systemd = dependency('systemd', required: systemd_option)
-systemd_option.enable_auto_if(systemd.found())
-
-if (systemd_option.enabled())
-  message('Enabling systemd integration')
+if get_option('systemd').enabled()
+  systemd = dependency('systemd')
  add_project_arguments('-DUSES_SYSTEMD', language: 'cpp')
  subdir('systemd')
 endif
@@ -89,7 +70,7 @@ endif
 run_command('sh', '-c', 'scripts/generateVersion.sh', check: true)

 # Install headers
-globber = run_command('find', 'src', '-name', '*.h*', '-o', '-name', '*.frag', check: true)
+globber = run_command('find', 'src', '-name', '*.h*', check: true)
 headers = globber.stdout().strip().split('\n')
 foreach file : headers
  install_headers(file, subdir: 'hyprland', preserve_path: true)
@@ -106,14 +87,11 @@ 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
@@ -1,6 +1,4 @@
 option('xwayland', type: 'feature', value: 'auto', description: 'Enable support for X11 applications')
 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,18 +5,14 @@
  pkg-config,
  pkgconf,
  makeWrapper,
-  cmake,
  meson,
  ninja,
  aquamarine,
  binutils,
  cairo,
  git,
-  glaze,
  hyprcursor,
-  hyprgraphics,
  hyprland-protocols,
-  hyprland-qtutils,
  hyprlang,
  hyprutils,
  hyprwayland-scanner,
@@ -26,10 +22,9 @@
  libinput,
  libxkbcommon,
  libuuid,
-  libgbm,
+  mesa,
  pango,
  pciutils,
-  re2,
  systemd,
  tomlplusplus,
  udis86-hyprland,
@@ -52,12 +47,12 @@
  nvidiaPatches ? false,
  hidpiXWayland ? false,
 }: let
-  inherit (builtins) baseNameOf foldl' readFile;
+  inherit (builtins) baseNameOf foldl';
  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 trim;
+  inherit (lib.strings) hasSuffix makeBinPath optionalString mesonBool mesonEnable;

  adapters = flatten [
    stdenvAdapters.useMoldLinker
@@ -69,7 +64,7 @@ in
  assert assertMsg (!nvidiaPatches) "The option `nvidiaPatches` has been removed.";
  assert assertMsg (!enableNvidiaPatches) "The option `enableNvidiaPatches` has been removed.";
  assert assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been removed. Please refer https://wiki.hyprland.org/Configuring/XWayland";
-    customStdenv.mkDerivation (finalAttrs: {
+    customStdenv.mkDerivation {
      pname = "hyprland${optionalString debug "-debug"}";
      inherit version;

@@ -93,7 +88,6 @@ in
      DATE = date;
      DIRTY = optionalString (commit == "") "dirty";
      HASH = commit;
-      TAG = "v${trim (readFile "${finalAttrs.src}/VERSION")}";

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

@@ -119,9 +112,7 @@ in
          aquamarine
          cairo
          git
-          glaze
          hyprcursor
-          hyprgraphics
          hyprland-protocols
          hyprlang
          hyprutils
@@ -130,10 +121,9 @@ in
          libinput
          libuuid
          libxkbcommon
-          libgbm
+          mesa
          pango
          pciutils
-          re2
          tomlplusplus
          udis86-hyprland
          wayland
@@ -155,15 +145,14 @@ in

      mesonBuildType =
        if debug
-        then "debug"
+        then "debugoptimized"
        else "release";

      mesonFlags = flatten [
        (mapAttrsToList mesonEnable {
          "xwayland" = enableXWayland;
          "legacy_renderer" = legacyRenderer;
-          "uwsm" = false;
-          "hyprpm" = false;
+          "systemd" = withSystemd;
        })
        (mapAttrsToList mesonBool {
          "b_pch" = false;
@@ -176,7 +165,6 @@ in
          wrapProgram $out/bin/Hyprland \
            --suffix PATH : ${makeBinPath [
            binutils
-            hyprland-qtutils
            pciutils
            pkgconf
          ]}
@@ -192,4 +180,4 @@ in
        platforms = lib.platforms.linux;
        mainProgram = "Hyprland";
      };
-    })
+    }
--- a/nix/lib.nix
+++ b/nix/lib.nix
@@ -1,201 +0,0 @@
-lib: let
-  inherit (lib)
-    attrNames
-    filterAttrs
-    foldl
-    generators
-    partition
-    ;
-
-  inherit (lib.strings)
-    concatMapStrings
-    hasPrefix
-    ;
-
-  /**
-    Convert a structured Nix attribute set into Hyprland's configuration format.
-
-    This function takes a nested attribute set and converts it into Hyprland-compatible
-    configuration syntax, supporting top, bottom, and regular command sections.
-    
-    Commands are flattened using the `flattenAttrs` function, and attributes are formatted as
-    `key = value` pairs. Lists are expanded as duplicate keys to match Hyprland's expected format.
-
-    Configuration:
-
-    * `topCommandsPrefixes` - A list of prefixes to define **top** commands (default: `["$"]`).
-    * `bottomCommandsPrefixes` - A list of prefixes to define **bottom** commands (default: `[]`).
-
-    Attention:
-
-    - The function ensures top commands appear **first** and bottom commands **last**.
-    - The generated configuration is a **single string**, suitable for writing to a config file.
-    - Lists are converted into multiple entries, ensuring compatibility with Hyprland.
-
-    # Inputs
-
-    Structured function argument:
-
-    : topCommandsPrefixes (optional, default: `["$"]`)
-      : A list of prefixes that define **top** commands. Any key starting with one of these
-        prefixes will be placed at the beginning of the configuration.
-    : bottomCommandsPrefixes (optional, default: `[]`)
-      : A list of prefixes that define **bottom** commands. Any key starting with one of these
-        prefixes will be placed at the end of the configuration.
-
-    Value:
-
-    : The attribute set to be converted to Hyprland configuration format.
-
-    # Type
-
-    ```
-    toHyprlang :: AttrSet -> AttrSet -> String
-    ```
-
-    # Examples
-    :::{.example}
-
-    ```nix
-    let
-      config = {
-        "$mod" = "SUPER";
-        monitor = {
-          "HDMI-A-1" = "1920x1080@60,0x0,1";
-        };
-        exec = [
-          "waybar"
-          "dunst"
-        ];
-      };
-    in lib.toHyprlang {} config
-    ```
-
-    **Output:**
-    ```nix
-    "$mod = SUPER"
-    "monitor:HDMI-A-1 = 1920x1080@60,0x0,1"
-    "exec = waybar"
-    "exec = dunst"
-    ```
-
-    :::
-  */
-  toHyprlang = {
-    topCommandsPrefixes ? ["$"],
-    bottomCommandsPrefixes ? [],
-  }: attrs: let
-    toHyprlang' = attrs: let
-      # Specially configured `toKeyValue` generator with support for duplicate keys
-      # and a legible key-value separator.
-      mkCommands = generators.toKeyValue {
-        mkKeyValue = generators.mkKeyValueDefault {} " = ";
-        listsAsDuplicateKeys = true;
-        indent = ""; # No indent, since we don't have nesting
-      };
-
-      # Flatten the attrset, combining keys in a "path" like `"a:b:c" = "x"`.
-      # Uses `flattenAttrs` with a colon separator.
-      commands = flattenAttrs (p: k: "${p}:${k}") attrs;
-
-      # General filtering function to check if a key starts with any prefix in a given list.
-      filterCommands = list: n:
-        foldl (acc: prefix: acc || hasPrefix prefix n) false list;
-
-      # Partition keys into top commands and the rest
-      result = partition (filterCommands topCommandsPrefixes) (attrNames commands);
-      topCommands = filterAttrs (n: _: builtins.elem n result.right) commands;
-      remainingCommands = removeAttrs commands result.right;
-
-      # Partition remaining commands into bottom commands and regular commands
-      result2 = partition (filterCommands bottomCommandsPrefixes) result.wrong;
-      bottomCommands = filterAttrs (n: _: builtins.elem n result2.right) remainingCommands;
-      regularCommands = removeAttrs remainingCommands result2.right;
-    in
-      # Concatenate strings from mapping `mkCommands` over top, regular, and bottom commands.
-      concatMapStrings mkCommands [
-        topCommands
-        regularCommands
-        bottomCommands
-      ];
-  in
-    toHyprlang' attrs;
-
-  /**
-    Flatten a nested attribute set into a flat attribute set, using a custom key separator function.
-
-    This function recursively traverses a nested attribute set and produces a flat attribute set
-    where keys are joined using a user-defined function (`pred`). It allows transforming deeply
-    nested structures into a single-level attribute set while preserving key-value relationships.
-
-    Configuration:
-
-    * `pred` - A function `(string -> string -> string)` defining how keys should be concatenated.
-    
-    # Inputs
-
-    Structured function argument:
-
-    : pred (required)
-      : A function that determines how parent and child keys should be combined into a single key.
-        It takes a `prefix` (parent key) and `key` (current key) and returns the joined key.
-    
-    Value:
-
-    : The nested attribute set to be flattened.
-
-    # Type
-
-    ```
-    flattenAttrs :: (String -> String -> String) -> AttrSet -> AttrSet
-    ```
-
-    # Examples
-    :::{.example}
-
-    ```nix
-    let
-      nested = {
-        a = "3";
-        b = { c = "4"; d = "5"; };
-      };
-
-      separator = (prefix: key: "${prefix}.${key}");  # Use dot notation
-    in lib.flattenAttrs separator nested
-    ```
-
-    **Output:**
-    ```nix
-    {
-      "a" = "3";
-      "b.c" = "4";
-      "b.d" = "5";
-    }
-    ```
-
-    :::
-
-  */
-  flattenAttrs = pred: attrs: let
-    flattenAttrs' = prefix: attrs:
-      builtins.foldl' (
-        acc: key: let
-          value = attrs.${key};
-          newKey =
-            if prefix == ""
-            then key
-            else pred prefix key;
-        in
-          acc
-          // (
-            if builtins.isAttrs value
-            then flattenAttrs' newKey value
-            else {"${newKey}" = value;}
-          )
-      ) {} (builtins.attrNames attrs);
-  in
-    flattenAttrs' "" attrs;
-in
-{
-  inherit flattenAttrs toHyprlang;
-}
--- a/nix/module.nix
+++ b/nix/module.nix
@@ -5,148 +5,17 @@ inputs: {
  ...
 }: let
  inherit (pkgs.stdenv.hostPlatform) system;
-  selflib = import ./lib.nix lib;
  cfg = config.programs.hyprland;
+
+  package = inputs.self.packages.${system}.hyprland;
+  portalPackage = inputs.self.packages.${system}.xdg-desktop-portal-hyprland.override {
+    hyprland = cfg.finalPackage;
+  };
 in {
-  options = {
+  config = {
    programs.hyprland = {
-      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.
-
-          Special categories (e.g `devices`) should be written as
-          `"devices[device-name]"`.
-
-          ::: {.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`.
-        '';
-      };
-
-      topPrefixes = lib.mkOption {
-        type = with lib.types; listOf str;
-        default = ["$" "bezier"];
-        example = ["$" "bezier" "source"];
-        description = ''
-          List of prefix of attributes to put at the top of the config.
-        '';
-      };
-
-      bottomPrefixes = lib.mkOption {
-        type = with lib.types; listOf str;
-        default = [];
-        example = ["source"];
-        description = ''
-          List of prefix of attributes to put at the bottom of the config.
-        '';
-      };
+      package = lib.mkDefault package;
+      portalPackage = lib.mkDefault portalPackage;
    };
  };
-  config = lib.mkMerge [
-    {
-      programs.hyprland = {
-        package = lib.mkDefault inputs.self.packages.${system}.hyprland;
-        portalPackage = lib.mkDefault inputs.self.packages.${system}.xdg-desktop-portal-hyprland;
-      };
-    }
-    (lib.mkIf cfg.enable {
-      environment.etc."xdg/hypr/hyprland.conf" = let
-        shouldGenerate = cfg.extraConfig != "" || cfg.settings != {} || cfg.plugins != [];
-
-        pluginsToHyprlang = plugins:
-          selflib.toHyprlang {
-            topCommandsPrefixes = cfg.topPrefixes;
-            bottomCommandsPrefixes = cfg.bottomPrefixes;
-          }
-          {
-            plugin = let
-              mkEntry = entry:
-                if lib.types.package.check entry
-                then "${entry}/lib/lib${entry.pname}.so"
-                else entry;
-            in
-              map mkEntry cfg.plugins;
-          };
-      in
-        lib.mkIf shouldGenerate {
-          text =
-            lib.optionalString (cfg.plugins != [])
-            (pluginsToHyprlang cfg.plugins)
-            + lib.optionalString (cfg.settings != {})
-            (selflib.toHyprlang {
-                topCommandsPrefixes = cfg.topPrefixes;
-                bottomCommandsPrefixes = cfg.bottomPrefixes;
-              }
-              cfg.settings)
-            + lib.optionalString (cfg.extraConfig != "") cfg.extraConfig;
-        };
-    })
-  ];
 }
--- a/nix/overlays.nix
+++ b/nix/overlays.nix
@@ -22,9 +22,7 @@ in {
    # Dependencies
    inputs.aquamarine.overlays.default
    inputs.hyprcursor.overlays.default
-    inputs.hyprgraphics.overlays.default
    inputs.hyprland-protocols.overlays.default
-    inputs.hyprland-qtutils.overlays.default
    inputs.hyprlang.overlays.default
    inputs.hyprutils.overlays.default
    inputs.hyprwayland-scanner.overlays.default
--- a/protocols/frog-color-management-v1.xml
+++ b/protocols/frog-color-management-v1.xml
@@ -1,366 +0,0 @@
-<?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
@@ -1,13 +1,13 @@
 wayland_protos = dependency(
 	'wayland-protocols',
-	version: '>=1.41',
+	version: '>=1.32',
 	fallback: 'wayland-protocols',
 	default_options: ['tests=false'],
 )

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

@@ -33,14 +33,10 @@ 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',
@@ -70,8 +66,6 @@ protocols = [
 	wayland_protocol_dir / 'staging/xdg-dialog/xdg-dialog-v1.xml',
 	wayland_protocol_dir / 'staging/single-pixel-buffer/single-pixel-buffer-v1.xml',
 	wayland_protocol_dir / 'staging/security-context/security-context-v1.xml',
-	wayland_protocol_dir / 'staging/content-type/content-type-v1.xml',
-	wayland_protocol_dir / 'staging/color-management/color-management-v1.xml',
 ]

 wl_protocols = []
--- a/protocols/xx-color-management-v4.xml
+++ b/protocols/xx-color-management-v4.xml
--- a/scripts/generateVersion.sh
+++ b/scripts/generateVersion.sh
@@ -1,13 +1,4 @@
 #!/bin/sh
-
-# if the git directory doesn't exist, don't gather data to avoid overwriting, unless
-# the version file is missing altogether (otherwise compiling will fail)
-if [ ! -d ./.git ]; then
-    if [ -f ./src/version.h ]; then
-        exit 0
-    fi
-fi
-
 cp -fr ./src/version.h.in ./src/version.h

 HASH=${HASH-$(git rev-parse HEAD)}
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
--- a/src/Compositor.hpp
+++ b/src/Compositor.hpp
@@ -1,20 +1,41 @@
 #pragma once

+#include <memory>
+#include <deque>
+#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 "protocols/types/ColorManagement.hpp"
+#include "render/Renderer.hpp"
+#include "render/OpenGL.hpp"
+#include "hyprerror/HyprError.hpp"
+#include "plugins/PluginSystem.hpp"
+#include "helpers/Watchdog.hpp"

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

 class CWLSurfaceResource;
-struct SWorkspaceRule;

-enum eManagersInitStage : uint8_t {
+enum eManagersInitStage {
    STAGE_PRIORITY = 0,
    STAGE_BASICINIT,
    STAGE_LATE
@@ -22,11 +43,11 @@ enum eManagersInitStage : uint8_t {

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

-    wl_display*                                m_sWLDisplay   = nullptr;
-    wl_event_loop*                             m_sWLEventLoop = nullptr;
+    wl_display*                                m_sWLDisplay;
+    wl_event_loop*                             m_sWLEventLoop;
    int                                        m_iDRMFD       = -1;
    bool                                       m_bInitialized = false;
    SP<Aquamarine::CBackend>                   m_pAqBackend;
@@ -52,6 +73,8 @@ class CCompositor {
    void                                       startCompositor();
    void                                       stopCompositor();
    void                                       cleanup();
+    void                                       createLockFile();
+    void                                       removeLockFile();
    void                                       bumpNofile();
    void                                       restoreNofile();

@@ -67,11 +90,10 @@ 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_bWantsXwayland          = true;
-    bool                                       m_bOnlyConfigVerification = false;
+    bool                                       m_bIsShuttingDown = false;
+    bool                                       m_bFinalRequests  = false;
+    bool                                       m_bDesktopEnvSet  = false;
+    bool                                       m_bEnableXwayland = true;

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

@@ -81,7 +103,7 @@ class CCompositor {
    PHLMONITOR             getMonitorFromCursor();
    PHLMONITOR             getMonitorFromVector(const Vector2D&);
    void                   removeWindowFromVectorSafe(PHLWINDOW);
-    void                   focusWindow(PHLWINDOW, SP<CWLSurfaceResource> pSurface = nullptr, bool preserveFocusHistory = false);
+    void                   focusWindow(PHLWINDOW, SP<CWLSurfaceResource> pSurface = nullptr);
    void                   focusSurface(SP<CWLSurfaceResource>, PHLWINDOW pWindowOwner = nullptr);
    bool                   monitorExists(PHLMONITOR);
    PHLWINDOW              vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
@@ -93,24 +115,34 @@ class CCompositor {
    PHLMONITOR             getRealMonitorFromOutput(SP<Aquamarine::IOutput>);
    PHLWINDOW              getWindowFromSurface(SP<CWLSurfaceResource>);
    PHLWINDOW              getWindowFromHandle(uint32_t);
+    bool                   isWorkspaceVisible(PHLWORKSPACE);
+    bool                   isWorkspaceVisibleNotCovered(PHLWORKSPACE);
    PHLWORKSPACE           getWorkspaceByID(const WORKSPACEID&);
    PHLWORKSPACE           getWorkspaceByName(const std::string&);
    PHLWORKSPACE           getWorkspaceByString(const std::string&);
    void                   sanityCheckWorkspaces();
+    void                   updateWorkspaceWindowDecos(const WORKSPACEID&);
+    void                   updateWorkspaceWindowData(const WORKSPACEID&);
+    int                    getWindowsOnWorkspace(const WORKSPACEID& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
+    int                    getGroupsOnWorkspace(const WORKSPACEID& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
    PHLWINDOW              getUrgentWindow();
+    bool                   hasUrgentWindowOnWorkspace(const WORKSPACEID&);
+    PHLWINDOW              getFirstWindowOnWorkspace(const WORKSPACEID&);
+    PHLWINDOW              getTopLeftWindowOnWorkspace(const WORKSPACEID&);
+    PHLWINDOW              getFullscreenWindowOnWorkspace(const WORKSPACEID&);
    bool                   isWindowActive(PHLWINDOW);
    void                   changeWindowZOrder(PHLWINDOW, bool);
    void                   cleanupFadingOut(const MONITORID& monid);
    PHLWINDOW              getWindowInDirection(PHLWINDOW, char);
-    PHLWINDOW              getWindowInDirection(const CBox& box, PHLWORKSPACE pWorkspace, char dir, PHLWINDOW ignoreWindow = nullptr, bool useVectorAngles = false);
-    PHLWINDOW              getWindowCycle(PHLWINDOW cur, bool focusableOnly = false, std::optional<bool> floating = std::nullopt, bool visible = false, bool prev = false);
-    PHLWINDOW              getWindowCycleHist(PHLWINDOWREF cur, bool focusableOnly = false, std::optional<bool> floating = std::nullopt, bool visible = false, bool next = false);
+    PHLWINDOW              getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
+    PHLWINDOW              getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
    WORKSPACEID            getNextAvailableNamedWorkspace();
    bool                   isPointOnAnyMonitor(const Vector2D&);
    bool                   isPointOnReservedArea(const Vector2D& point, const PHLMONITOR monitor = nullptr);
    PHLMONITOR             getMonitorInDirection(const char&);
    PHLMONITOR             getMonitorInDirection(PHLMONITOR, const char&);
    void                   updateAllWindowsAnimatedDecorationValues();
+    void                   updateWorkspaceWindows(const WORKSPACEID& id);
    void                   updateWindowAnimatedDecorationValues(PHLWINDOW);
    MONITORID              getNextAvailableMonitorID(std::string const& name);
    void                   moveWorkspaceToMonitor(PHLWORKSPACE, PHLMONITOR, bool noWarpCursor = false);
@@ -119,7 +151,8 @@ class CCompositor {
    bool                   workspaceIDOutOfBounds(const WORKSPACEID&);
    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                   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);
@@ -132,8 +165,10 @@ class CCompositor {
    PHLLS                  getLayerSurfaceFromSurface(SP<CWLSurfaceResource>);
    void                   closeWindow(PHLWINDOW);
    Vector2D               parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
+    void                   forceReportSizesToWindowsOnWorkspace(const WORKSPACEID&);
    PHLWORKSPACE           createNewWorkspace(const WORKSPACEID&, const MONITORID&, const std::string& name = "",
                                              bool isEmpty = true); // will be deleted next frame if left empty and unfocused!
+    void                   renameWorkspace(const WORKSPACEID&, const std::string& name = "");
    void                   setActiveMonitor(PHLMONITOR);
    bool                   isWorkspaceSpecial(const WORKSPACEID&);
    WORKSPACEID            getNewSpecialID();
@@ -146,13 +181,10 @@ 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, PHLWORKSPACE pWorkspace = nullptr);

-    NColorManagement::SImageDescription getPreferredImageDescription();
-    bool                                shouldChangePreferredImageDescription();
-
-    std::string                         explicitConfigPath;
+    std::string            explicitConfigPath;

  private:
    void             initAllSignals();
@@ -161,13 +193,10 @@ class CCompositor {
    void             setRandomSplash();
    void             initManagers(eManagersInitStage stage);
    void             prepareFallbackOutput();
-    void             createLockFile();
-    void             removeLockFile();
-    void             setMallocThreshold();

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

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

-enum eIcons : uint8_t {
+using namespace Hyprutils::Math;
+
+enum eIcons {
    ICON_WARNING = 0,
    ICON_INFO,
    ICON_HINT,
@@ -17,7 +17,7 @@ enum eIcons : uint8_t {
    ICON_NONE
 };

-enum eRenderStage : uint8_t {
+enum eRenderStage {
    RENDER_PRE = 0,      /* Before binding the gl context */
    RENDER_BEGIN,        /* Just when the rendering begins, nothing has been rendered yet. Damage, current render data in opengl valid. */
    RENDER_PRE_WINDOWS,  /* Pre windows, post bottom and overlay layers */
@@ -29,7 +29,7 @@ enum eRenderStage : uint8_t {
    RENDER_POST_WINDOW,  /* After rendering a window (any pass) */
 };

-enum eInputType : uint8_t {
+enum eInputType {
    INPUT_TYPE_AXIS = 0,
    INPUT_TYPE_BUTTON,
    INPUT_TYPE_DRAG_START,
@@ -41,7 +41,7 @@ struct SCallbackInfo {
    bool cancelled = false; /* on cancellable events, will cancel the event. */
 };

-enum eHyprCtlOutputFormat : uint8_t {
+enum eHyprCtlOutputFormat {
    FORMAT_NORMAL = 0,
    FORMAT_JSON
 };
@@ -52,12 +52,6 @@ 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/ConfigDataValues.hpp
+++ b/src/config/ConfigDataValues.hpp
@@ -3,7 +3,7 @@
 #include "../helpers/varlist/VarList.hpp"
 #include <vector>

-enum eConfigValueDataTypes : int8_t {
+enum eConfigValueDataTypes {
    CVD_TYPE_INVALID   = -1,
    CVD_TYPE_GRADIENT  = 0,
    CVD_TYPE_CSS_VALUE = 1
@@ -11,7 +11,7 @@ enum eConfigValueDataTypes : int8_t {

 class ICustomConfigValueData {
  public:
-    virtual ~ICustomConfigValueData() = default;
+    virtual ~ICustomConfigValueData() = 0;

    virtual eConfigValueDataTypes getDataType() = 0;

@@ -20,40 +20,24 @@ class ICustomConfigValueData {

 class CGradientValueData : public ICustomConfigValueData {
  public:
-    CGradientValueData() = default;
-    CGradientValueData(CHyprColor col) {
+    CGradientValueData() {};
+    CGradientValueData(CColor col) {
        m_vColors.push_back(col);
-        updateColorsOk();
    };
-    virtual ~CGradientValueData() = default;
+    virtual ~CGradientValueData() {};

    virtual eConfigValueDataTypes getDataType() {
        return CVD_TYPE_GRADIENT;
    }

-    void reset(CHyprColor col) {
+    void reset(CColor col) {
        m_vColors.clear();
        m_vColors.emplace_back(col);
        m_fAngle = 0;
-        updateColorsOk();
-    }
-
-    void updateColorsOk() {
-        m_vColorsOkLabA.clear();
-        for (auto& c : m_vColors) {
-            const auto OKLAB = c.asOkLab();
-            m_vColorsOkLabA.emplace_back(OKLAB.l);
-            m_vColorsOkLabA.emplace_back(OKLAB.a);
-            m_vColorsOkLabA.emplace_back(OKLAB.b);
-            m_vColorsOkLabA.emplace_back(c.a);
-        }
    }

    /* Vector containing the colors */
-    std::vector<CHyprColor> m_vColors;
-
-    /* Vector containing pure colors for shoving into opengl */
-    std::vector<float> m_vColorsOkLabA;
+    std::vector<CColor> m_vColors;

    /* Float corresponding to the angle (rad) */
    float m_fAngle = 0;
--- a/src/config/ConfigDescriptions.hpp
+++ b/src/config/ConfigDescriptions.hpp
@@ -139,12 +139,6 @@ 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]",
@@ -253,98 +247,86 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
     */

    SConfigOptionDescription{
-        .value       = "decoration:blur:enabled",
+        .value       = "blur:enabled",
        .description = "enable kawase window background blur",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:size",
+        .value       = "blur:size",
        .description = "blur size (distance)",
        .type        = CONFIG_OPTION_INT,
        .data        = SConfigOptionDescription::SRangeData{8, 0, 100},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:passes",
+        .value       = "blur:passes",
        .description = "the amount of passes to perform",
        .type        = CONFIG_OPTION_INT,
        .data        = SConfigOptionDescription::SRangeData{1, 0, 10},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:ignore_opacity",
+        .value       = "blur:ignore_opacity",
        .description = "make the blur layer ignore the opacity of the window",
        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
+        .data        = SConfigOptionDescription::SBoolData{false},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:new_optimizations",
+        .value       = "blur:new_optimizations",
        .description = "whether to enable further optimizations to the blur. Recommended to leave on, as it will massively improve performance.",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:xray",
+        .value       = "blur:xray",
        .description = "if enabled, floating windows will ignore tiled windows in their blur. Only available if blur_new_optimizations is true. Will reduce overhead on floating "
                       "blur significantly.",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:noise",
+        .value       = "blur:noise",
        .description = "how much noise to apply. [0.0 - 1.0]",
        .type        = CONFIG_OPTION_FLOAT,
        .data        = SConfigOptionDescription::SFloatData{0.0117, 0, 1},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:contrast",
+        .value       = "blur:contrast",
        .description = "contrast modulation for blur. [0.0 - 2.0]",
        .type        = CONFIG_OPTION_FLOAT,
        .data        = SConfigOptionDescription::SFloatData{0.8916, 0, 2},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:brightness",
+        .value       = "blur:brightness",
        .description = "brightness modulation for blur. [0.0 - 2.0]",
        .type        = CONFIG_OPTION_FLOAT,
        .data        = SConfigOptionDescription::SFloatData{0.8172, 0, 2},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:vibrancy",
+        .value       = "blur:vibrancy",
        .description = "Increase saturation of blurred colors. [0.0 - 1.0]",
        .type        = CONFIG_OPTION_FLOAT,
        .data        = SConfigOptionDescription::SFloatData{0.1696, 0, 1},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:vibrancy_darkness",
+        .value       = "blur:vibrancy_darkness",
        .description = "How strong the effect of vibrancy is on dark areas . [0.0 - 1.0]",
        .type        = CONFIG_OPTION_FLOAT,
        .data        = SConfigOptionDescription::SFloatData{0, 0, 1},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:special",
+        .value       = "blur:special",
        .description = "whether to blur behind the special workspace (note: expensive)",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:popups",
+        .value       = "blur:popups",
        .description = "whether to blur popups (e.g. right-click menus)",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
    SConfigOptionDescription{
-        .value       = "decoration:blur:popups_ignorealpha",
-        .description = "works like ignorealpha in layer rules. If pixel opacity is below set value, will not blur. [0.0 - 1.0]",
-        .type        = CONFIG_OPTION_FLOAT,
-        .data        = SConfigOptionDescription::SFloatData{0.2, 0, 1},
-    },
-    SConfigOptionDescription{
-        .value       = "decoration:blur:input_methods",
-        .description = "whether to blur input methods (e.g. fcitx5)",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "decoration:blur:input_methods_ignorealpha",
+        .value       = "blur:popups_ignorealpha",
        .description = "works like ignorealpha in layer rules. If pixel opacity is below set value, will not blur. [0.0 - 1.0]",
        .type        = CONFIG_OPTION_FLOAT,
        .data        = SConfigOptionDescription::SFloatData{0.2, 0, 1},
@@ -501,12 +483,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_INT,
        .data        = SConfigOptionDescription::SRangeData{1, 0, 3},
    },
-    SConfigOptionDescription{
-        .value       = "input:follow_mouse_threshold",
-        .description = "The smallest distance in logical pixels the mouse needs to travel for the window under it to get focused. Works only with follow_mouse = 1.",
-        .type        = CONFIG_OPTION_FLOAT,
-        .data        = SConfigOptionDescription::SFloatData{},
-    },
    SConfigOptionDescription{
        .value       = "input:focus_on_close",
        .description = "Controls the window focus behavior when a window is closed. When set to 0, focus will shift to the next window candidate. When set to 1, focus will shift "
@@ -608,18 +584,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
-    SConfigOptionDescription{
-        .value       = "input:touchpad:flip_x",
-        .description = "Inverts the horizontal movement of the touchpad",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "input:touchpad:flip_y",
-        .description = "Inverts the vertical movement of the touchpad",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },

    /*
     * input:touchdevice:
@@ -656,22 +620,16 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
    },
    SConfigOptionDescription{
        .value       = "input:tablet:output",
-        .description = "the monitor to bind tablets. Can be current or a monitor name. Leave empty to map across all monitors.",
+        .description = "the monitor to bind tablets. Empty means unbound..",
        .type        = CONFIG_OPTION_STRING_SHORT,
        .data        = SConfigOptionDescription::SStringData{""}, //##TODO UNSET?
    },
    SConfigOptionDescription{
        .value       = "input:tablet:region_position",
-        .description = "position of the mapped region in monitor layout relative to the top left corner of the bound monitor or all monitors.",
+        .description = "position of the mapped region in monitor layout.",
        .type        = CONFIG_OPTION_VECTOR,
        .data        = SConfigOptionDescription::SVectorData{{}, {-20000, -20000}, {20000, 20000}},
    },
-    SConfigOptionDescription{
-        .value       = "input:tablet:absolute_region_position",
-        .description = "whether to treat the region_position as an absolute position in monitor layout. Only applies when output is empty.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
    SConfigOptionDescription{
        .value       = "input:tablet:region_size",
        .description = "size of the mapped region. When this variable is set, tablet input will be mapped to the region. [0, 0] or invalid size means unset.",
@@ -827,25 +785,25 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
-        .value       = "group:col.border_active",
+        .value       = "general:col.border_active",
        .description = "border color for inactive windows",
        .type        = CONFIG_OPTION_GRADIENT,
        .data        = SConfigOptionDescription::SGradientData{"0x66ffff00"},
    },
    SConfigOptionDescription{
-        .value       = "group:col.border_inactive",
+        .value       = "general:col.border_inactive",
        .description = "border color for the active window",
        .type        = CONFIG_OPTION_GRADIENT,
        .data        = SConfigOptionDescription::SGradientData{"0x66777700"},
    },
    SConfigOptionDescription{
-        .value       = "group:col.border_locked_inactive",
+        .value       = "general:col.border_locked_active",
        .description = "inactive border color for window that cannot be added to a group (see denywindowfromgroup dispatcher)",
        .type        = CONFIG_OPTION_GRADIENT,
        .data        = SConfigOptionDescription::SGradientData{"0x66ff5500"},
    },
    SConfigOptionDescription{
-        .value       = "group:col.border_locked_active",
+        .value       = "general:col.border_locked_inactive",
        .description = "active border color for window that cannot be added to a group",
        .type        = CONFIG_OPTION_GRADIENT,
        .data        = SConfigOptionDescription::SGradientData{"0x66775500"},
@@ -901,7 +859,7 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .value       = "group:groupbar:gradients",
        .description = "enables gradients",
        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
+        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
        .value       = "group:groupbar:height",
@@ -909,12 +867,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_INT,
        .data        = SConfigOptionDescription::SRangeData{14, 1, 64},
    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:indicator_height",
-        .description = "height of the groupbar indicator",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{3, 1, 64},
-    },
    SConfigOptionDescription{
        .value       = "group:groupbar:stacked",
        .description = "render the groupbar as a vertical stack",
@@ -939,30 +891,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:rounding",
-        .description = "how much to round the groupbar",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{1, 0, 20},
-    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:gradient_rounding",
-        .description = "how much to round the groupbar gradient",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{1, 0, 20},
-    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:round_only_edges",
-        .description = "if yes, will only round at the groupbar edges",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:gradient_round_only_edges",
-        .description = "if yes, will only round at the groupbar gradient edges",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
    SConfigOptionDescription{
        .value       = "group:groupbar:text_color",
        .description = "controls the group bar text color",
@@ -993,18 +921,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_COLOR,
        .data        = SConfigOptionDescription::SColorData{0x66775500},
    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:gaps_out",
-        .description = "gap between gradients and window",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{2, 0, 20},
-    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:gaps_in",
-        .description = "gap between gradients",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{2, 0, 20},
-    },

    /*
     * misc:
@@ -1054,9 +970,9 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
    },
    SConfigOptionDescription{
        .value       = "misc:vrr",
-        .description = "	controls the VRR (Adaptive Sync) of your monitors. 0 - off, 1 - on, 2 - fullscreen only, 3 - fullscreen with game or video content type [0/1/2/3]",
+        .description = "	controls the VRR (Adaptive Sync) of your monitors. 0 - off, 1 - on, 2 - fullscreen only [0/1/2]",
        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{.value = 0, .min = 0, .max = 3},
+        .data        = SConfigOptionDescription::SRangeData{0, 0, 2},
    },
    SConfigOptionDescription{
        .value       = "misc:mouse_move_enables_dpms",
@@ -1199,24 +1115,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
-    SConfigOptionDescription{
-        .value       = "misc:disable_hyprland_qtutils_check",
-        .description = "disable the warning if hyprland-qtutils is missing",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "misc:lockdead_screen_delay",
-        .description = "the delay in ms after the lockdead screen appears if the lock screen did not appear after a lock event occurred.",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{1000, 0, 5000},
-    },
-    SConfigOptionDescription{
-        .value       = "misc:enable_anr_dialog",
-        .description = "whether to enable the ANR (app not responding) dialog when your apps hang",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },

    /*
     * binds:
@@ -1270,13 +1168,7 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .value       = "binds:movefocus_cycles_fullscreen",
        .description = "If enabled, when on a fullscreen window, movefocus will cycle fullscreen, if not, it will move the focus in a direction.",
        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "binds:movefocus_cycles_groupfirst",
-        .description = "If enabled, when in a grouped window, movefocus will cycle windows in the groups first, then at each ends of tabs, it'll move on to other windows/groups",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
+        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
        .value       = "binds:disable_keybind_grabbing",
@@ -1290,12 +1182,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
-    SConfigOptionDescription{
-        .value       = "binds:allow_pin_fullscreen",
-        .description = "Allows fullscreen to pinned windows, and restore their pinned status afterwards",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },

    /*
     * xwayland:
@@ -1319,12 +1205,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
-    SConfigOptionDescription{
-        .value       = "xwayland:create_abstract_socket",
-        .description = "Create the abstract Unix domain socket for XWayland",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },

    /*
     * opengl:
@@ -1336,6 +1216,13 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
+    SConfigOptionDescription{
+        .value       = "opengl:force_introspection",
+        .description = "forces introspection at all times. Introspection is aimed at reducing GPU usage in certain cases, but might cause graphical glitches on nvidia. 0 - "
+                       "nothing, 1 - force always on, 2 - force always on if nvidia",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{2, 0, 2},
+    },

    /*
     * render:
@@ -1356,57 +1243,33 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
    SConfigOptionDescription{
        .value       = "render:direct_scanout",
        .description = "Enables direct scanout. Direct scanout attempts to reduce lag when there is only one fullscreen application on a screen (e.g. game). It is also "
-                       "recommended to set this to false if the fullscreen application shows graphical glitches. 0 - off, 1 - on, 2 - auto (on with content type 'game')",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{.value = 0, .min = 0, .max = 2},
-    },
-    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.",
+                       "recommended to set this to false if the fullscreen application shows graphical glitches.",
        .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:cm_fs_passthrough",
-        .description = "Passthrough color settings for fullscreen apps when possible",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{.value = 2, .min = 0, .max = 2},
-    },
-    SConfigOptionDescription{
-        .value       = "render:cm_enabled",
-        .description = "Enable Color Management pipelines (requires restart to fully take effect)",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
+        .data        = SConfigOptionDescription::SBoolData{false},
    },

    /*
     * cursor:
     */

+    SConfigOptionDescription{
+        .value       = "cursor:use_nearest_neighbor",
+        .description = "sync xcursor theme with gsettings, it applies cursor-theme and cursor-size on theme load to gsettings making most CSD gtk based clients use same xcursor "
+                       "theme and size.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
    SConfigOptionDescription{
        .value       = "cursor:no_hardware_cursors",
-        .description = "disables hardware cursors. Auto = disable when tearing",
+        .description = "disables hardware cursors",
        .type        = CONFIG_OPTION_CHOICE,
        .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Auto"},
    },
    SConfigOptionDescription{
        .value       = "cursor:no_break_fs_vrr",
-        .description = "disables scheduling new frames on cursor movement for fullscreen apps with VRR enabled to avoid framerate spikes (may require no_hardware_cursors = true) "
-                       "0 - off, 1 - on, 2 - auto (on with content type 'game')",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{.value = 2, .min = 0, .max = 2},
+        .description = "disables scheduling new frames on cursor movement for fullscreen apps with VRR enabled to avoid framerate spikes (requires no_hardware_cursors = true)",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
    },
    SConfigOptionDescription{
        .value       = "cursor:min_refresh_rate",
@@ -1440,9 +1303,9 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
    },
    SConfigOptionDescription{
        .value       = "cursor:warp_on_change_workspace",
-        .description = "Move the cursor to the last focused window after changing the workspace. Options: 0 (Disabled), 1 (Enabled), 2 (Force - ignores cursor:no_warps option)",
-        .type        = CONFIG_OPTION_CHOICE,
-        .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Force"},
+        .description = "If true, move the cursor to the last focused window after changing the workspace.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
    },
    SConfigOptionDescription{
        .value       = "cursor:default_monitor",
@@ -1481,37 +1344,8 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
-        .value       = "cursor:use_cpu_buffer",
-        .description = "Makes HW cursors use a CPU buffer. Required on Nvidia to have HW cursors. Experimental",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "cursor:sync_gsettings_theme",
-        .description = "sync xcursor theme with gsettings, it applies cursor-theme and cursor-size on theme load to gsettings making most CSD gtk based clients use same xcursor "
-                       "theme and size.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
-    SConfigOptionDescription{
-        .value       = "cursor:warp_back_after_non_mouse_input",
-        .description = "warp the cursor back to where it was after using a non-mouse input to move it, and then returning back to mouse.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-
-    /*
-     * ecosystem:
-     */
-    SConfigOptionDescription{
-        .value       = "ecosystem:no_update_news",
-        .description = "disable the popup that shows up when you update hyprland to a new version.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "ecosystem:no_donation_nag",
-        .description = "disable the popup that shows up twice a year encouraging to donate.",
+        .value       = "cursor:allow_dumb_copy",
+        .description = "Makes HW cursors work on Nvidia, at the cost of a possible hitch whenever the image changes",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
@@ -1598,24 +1432,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
-    SConfigOptionDescription{
-        .value       = "debug:log_damage",
-        .description = "enables logging the damage.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "debug:pass",
-        .description = "enables render pass debugging.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "debug:full_cm_proto",
-        .description = "claims support for all cm proto features (requires restart)",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },

    /*
     * dwindle:
@@ -1745,20 +1561,8 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .data        = SConfigOptionDescription::SBoolData{true},
    },
    SConfigOptionDescription{
-        .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{true},
-    },
-    SConfigOptionDescription{
-        .value       = "master:center_ignores_reserved",
-        .description = "centers the master window on monitor ignoring reserved areas",
+        .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.",
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{false},
    },
@@ -1776,16 +1580,4 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
        .type        = CONFIG_OPTION_BOOL,
        .data        = SConfigOptionDescription::SBoolData{true},
    },
-    SConfigOptionDescription{
-        .value       = "experimental:xx_color_management_v4",
-        .description = "enable color management protocol",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
-    SConfigOptionDescription{
-        .value       = "master:always_keep_position",
-        .description = "whether to keep the master window in its configured position when there are no slave windows",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
 };
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
--- a/src/config/ConfigManager.hpp
+++ b/src/config/ConfigManager.hpp
@@ -1,30 +1,33 @@
 #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 <deque>
+#include <algorithm>
+#include <regex>
 #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/LayerRule.hpp"
+#include "../desktop/LayerSurface.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 {
@@ -53,14 +56,26 @@ 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;
+    HANDLE                       handle = 0;
    std::string                  name   = "";
    Hyprlang::PCONFIGHANDLERFUNC fn     = nullptr;
 };

 struct SPluginVariable {
-    HANDLE      handle = nullptr;
+    HANDLE      handle = 0;
    std::string name   = "";
 };

@@ -69,7 +84,7 @@ struct SExecRequestedRule {
    uint64_t    iPid   = 0;
 };

-enum eConfigOptionType : uint8_t {
+enum eConfigOptionType : uint16_t {
    CONFIG_OPTION_BOOL         = 0,
    CONFIG_OPTION_INT          = 1, /* e.g. 0/1/2*/
    CONFIG_OPTION_FLOAT        = 2,
@@ -81,7 +96,7 @@ enum eConfigOptionType : uint8_t {
    CONFIG_OPTION_VECTOR       = 8,
 };

-enum eConfigOptionFlags : uint8_t {
+enum eConfigOptionFlags : uint32_t {
    CONFIG_OPTION_FLAG_PERCENTAGE = (1 << 0),
 };

@@ -104,7 +119,7 @@ struct SConfigOptionDescription {
    };

    struct SColorData {
-        CHyprColor color;
+        CColor color;
    };

    struct SChoiceData {
@@ -133,39 +148,12 @@ struct SConfigOptionDescription {
    std::variant<SBoolData, SRangeData, SFloatData, SStringData, SColorData, SChoiceData, SGradientData, SVectorData> data;
 };

-struct SFirstExecRequest {
-    std::string exec      = "";
-    bool        withRules = false;
-};
-
-struct SFloatCache {
-    size_t hash;
-
-    SFloatCache(PHLWINDOW window) {
-        hash = std::hash<std::string>{}(window->m_szClass) ^ (std::hash<std::string>{}(window->m_szTitle) << 1);
-    }
-
-    bool operator==(const SFloatCache& other) const {
-        return hash == other.hash;
-    }
-};
-
-namespace std {
-    template <>
-    struct hash<SFloatCache> {
-        size_t operator()(const SFloatCache& id) const {
-            return id.hash;
-        }
-    };
-}
-
 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 = "");
@@ -177,8 +165,9 @@ class CConfigManager {

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

    SMonitorRule                                                    getMonitorRuleFor(const PHLMONITOR);
    SWorkspaceRule                                                  getWorkspaceRuleFor(PHLWORKSPACE workspace);
@@ -186,127 +175,139 @@ class CConfigManager {

    PHLMONITOR                                                      getBoundMonitorForWS(const std::string&);
    std::string                                                     getBoundMonitorStringForWS(const std::string&);
-    const std::vector<SWorkspaceRule>&                              getAllWorkspaceRules();
+    const std::deque<SWorkspaceRule>&                               getAllWorkspaceRules();

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

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

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

-    const std::unordered_map<std::string, SP<Hyprutils::Animation::SAnimationPropertyConfig>>& getAnimationConfig();
+    std::unordered_map<std::string, 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                                               ensureMonitorStatus();
-    void                                               ensureVRR(PHLMONITOR pMonitor = nullptr);
+    void                      performMonitorReload();
+    void                      appendMonitorRule(const SMonitorRule&);
+    bool                      replaceMonitorRule(const SMonitorRule&);
+    void                      ensureMonitorStatus();
+    void                      ensureVRR(PHLMONITOR pMonitor = nullptr);

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

-    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&);

-    SP<Hyprutils::Animation::SAnimationPropertyConfig> getAnimationPropertyConfig(const std::string&);
+    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&);
-    std::optional<std::string> handleUnbind(const std::string&, const std::string&);
-    std::optional<std::string> handleWindowRule(const std::string&, const std::string&);
-    std::optional<std::string> handleLayerRule(const std::string&, const std::string&);
-    std::optional<std::string> handleWorkspaceRules(const std::string&, const std::string&);
-    std::optional<std::string> handleBezier(const std::string&, const std::string&);
-    std::optional<std::string> handleAnimation(const std::string&, const std::string&);
-    std::optional<std::string> handleSource(const std::string&, const std::string&);
-    std::optional<std::string> handleSubmap(const std::string&, const std::string&);
-    std::optional<std::string> handleBlurLS(const std::string&, const std::string&);
-    std::optional<std::string> handleBindWS(const std::string&, const std::string&);
-    std::optional<std::string> handleEnv(const std::string&, const std::string&);
-    std::optional<std::string> handlePlugin(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleRawExec(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleExecOnce(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&);
+    std::optional<std::string>                                                              handleUnbind(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleWindowRule(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleLayerRule(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleWindowRuleV2(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleWorkspaceRules(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleBezier(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleAnimation(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleSource(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleSubmap(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleBlurLS(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleBindWS(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handleEnv(const std::string&, const std::string&);
+    std::optional<std::string>                                                              handlePlugin(const std::string&, const std::string&);

-    std::string                configCurrentPath;
+    std::string                                                                             configCurrentPath;

-    bool                       m_bWantsMonitorReload                  = false;
-    bool                       m_bNoMonitorReload                     = false;
-    bool                       isLaunchingExecOnce                    = false; // For exec-once to skip initial ws tracking
-    bool                       m_bLastConfigVerificationWasSuccessful = true;
+    std::unordered_map<std::string, std::function<CWindowOverridableVar<bool>*(PHLWINDOW)>> mbWindowProperties = {
+        {"allowsinput", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.allowsInput; }},
+        {"dimaround", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.dimAround; }},
+        {"decorate", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.decorate; }},
+        {"focusonactivate", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.focusOnActivate; }},
+        {"keepaspectratio", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.keepAspectRatio; }},
+        {"nearestneighbor", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.nearestNeighbor; }},
+        {"noanim", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noAnim; }},
+        {"noblur", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noBlur; }},
+        {"noborder", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noBorder; }},
+        {"nodim", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noDim; }},
+        {"nofocus", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noFocus; }},
+        {"nomaxsize", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noMaxSize; }},
+        {"norounding", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noRounding; }},
+        {"noshadow", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noShadow; }},
+        {"noshortcutsinhibit", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noShortcutsInhibit; }},
+        {"opaque", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.opaque; }},
+        {"forcergbx", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.RGBX; }},
+        {"syncfullscreen", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.syncFullscreen; }},
+        {"immediate", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.tearing; }},
+        {"xray", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.xray; }},
+    };

-    void                       storeFloatingSize(PHLWINDOW window, const Vector2D& size);
-    std::optional<Vector2D>    getStoredFloatingSize(PHLWINDOW window);
+    std::unordered_map<std::string, std::function<CWindowOverridableVar<int>*(PHLWINDOW)>> miWindowProperties = {
+        {"rounding", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.rounding; }}, {"bordersize", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.borderSize; }}};
+
+    bool m_bWantsMonitorReload = false;
+    bool m_bForceReload        = false;
+    bool m_bNoMonitorReload    = false;
+    bool isLaunchingExecOnce   = false; // For exec-once to skip initial ws tracking

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

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

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

-    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::deque<SMonitorRule>                                  m_dMonitorRules;
+    std::deque<SWorkspaceRule>                                m_dWorkspaceRules;
+    std::deque<SWindowRule>                                   m_dWindowRules;
+    std::deque<SLayerRule>                                    m_dLayerRules;
+    std::deque<std::string>                                   m_dBlurLSNamespaces;

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

-    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 = "";
-
-    uint32_t                                         m_configValueNumber = 0;
+    std::vector<std::pair<std::string, std::string>>          m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
+    std::string                                               m_szConfigErrors = "";

    // internal methods
-    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&);
-
-    void                                      registerConfigVar(const char* name, const Hyprlang::INT& val);
-    void                                      registerConfigVar(const char* name, const Hyprlang::FLOAT& val);
-    void                                      registerConfigVar(const char* name, const Hyprlang::VEC2& val);
-    void                                      registerConfigVar(const char* name, const Hyprlang::STRING& val);
-    void                                      registerConfigVar(const char* name, Hyprlang::CUSTOMTYPE&& val);
-
-    std::unordered_map<SFloatCache, Vector2D> m_mStoredFloatingSizes;
-
-    friend struct SConfigOptionDescription;
+    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&);
 };

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

@@ -12,7 +13,6 @@ class CConfigValue {
    CConfigValue(const std::string& val) {
        const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);

-        // NOLINTNEXTLINE
        p_ = PVHYPRLANG->getDataStaticPtr();

 #ifdef HYPRLAND_DEBUG
@@ -70,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
@@ -1,81 +0,0 @@
-#include "ConfigWatcher.hpp"
-#include <sys/inotify.h>
-#include "../debug/Log.hpp"
-#include <ranges>
-#include <fcntl.h>
-#include <unistd.h>
-#include <filesystem>
-
-using namespace Hyprutils::OS;
-
-CConfigWatcher::CConfigWatcher() : m_inotifyFd(inotify_init()) {
-    if (!m_inotifyFd.isValid()) {
-        Debug::log(ERR, "CConfigWatcher couldn't open an inotify node. Config will not be automatically reloaded");
-        return;
-    }
-
-    // TODO: make CFileDescriptor take F_GETFL, F_SETFL
-    const int FLAGS = fcntl(m_inotifyFd.get(), F_GETFL, 0);
-    if (fcntl(m_inotifyFd.get(), F_SETFL, FLAGS | O_NONBLOCK) < 0) {
-        Debug::log(ERR, "CConfigWatcher couldn't non-block inotify node. Config will not be automatically reloaded");
-        m_inotifyFd.reset();
-        return;
-    }
-}
-
-CFileDescriptor& 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.get(), watch.wd);
-    }
-
-    m_watches.clear();
-
-    // add new paths
-    for (const auto& path : paths) {
-        m_watches.emplace_back(SInotifyWatch{
-            .wd   = inotify_add_watch(m_inotifyFd.get(), 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.get(), 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.get(), &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
@@ -1,33 +0,0 @@
-#pragma once
-#include "../helpers/memory/Memory.hpp"
-#include <vector>
-#include <string>
-#include <functional>
-#include <hyprutils/os/FileDescriptor.hpp>
-
-class CConfigWatcher {
-  public:
-    CConfigWatcher();
-    ~CConfigWatcher() = default;
-
-    struct SConfigWatchEvent {
-        std::string file;
-    };
-
-    Hyprutils::OS::CFileDescriptor& 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;
-    Hyprutils::OS::CFileDescriptor                m_inotifyFd;
-};
-
-inline UP<CConfigWatcher> g_pConfigWatcher = makeUnique<CConfigWatcher>();
--- a/src/config/defaultConfig.hpp
+++ b/src/config/defaultConfig.hpp
@@ -4,8 +4,8 @@

 inline const std::string AUTOCONFIG = R"#(
 # #######################################################################################
-# AUTOGENERATED HYPRLAND CONFIG.
-# PLEASE USE THE CONFIG PROVIDED IN THE GIT REPO /examples/hyprland.conf AND EDIT IT,
+# AUTOGENERATED HYPR CONFIG.
+# PLEASE USE THE CONFIG PROVIDED IN THE GIT REPO /examples/hypr.conf AND EDIT IT,
 # OR EDIT THIS ONE ACCORDING TO THE WIKI INSTRUCTIONS.
 # #######################################################################################

@@ -94,7 +94,6 @@ 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
@@ -152,10 +151,10 @@ animations {
 # uncomment all if you wish to use that.
 # workspace = w[tv1], gapsout:0, gapsin:0
 # workspace = f[1], gapsout:0, gapsin:0
-# windowrule = bordersize 0, floating:0, onworkspace:w[tv1]
-# windowrule = rounding 0, floating:0, onworkspace:w[tv1]
-# windowrule = bordersize 0, floating:0, onworkspace:f[1]
-# windowrule = rounding 0, floating:0, onworkspace:f[1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:f[1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:f[1]

 # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
 dwindle {
@@ -269,7 +268,7 @@ bindm = $mainMod, mouse:272, movewindow
 bindm = $mainMod, mouse:273, resizewindow

 # Laptop multimedia keys for volume and LCD brightness
-bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume -l 1 @DEFAULT_AUDIO_SINK@ 5%+
+bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%+
 bindel = ,XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-
 bindel = ,XF86AudioMute, exec, wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle
 bindel = ,XF86AudioMicMute, exec, wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle
@@ -289,12 +288,15 @@ bindl = , XF86AudioPrev, exec, playerctl previous
 # See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
 # See https://wiki.hyprland.org/Configuring/Workspace-Rules/ for workspace rules

-# Example windowrule
-# windowrule = float,class:^(kitty)$,title:^(kitty)$
+# Example windowrule v1
+# windowrule = float, ^(kitty)$
+
+# Example windowrule v2
+# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$

 # Ignore maximize requests from apps. You'll probably like this.
-windowrule = suppressevent maximize, class:.*
+windowrulev2 = suppressevent maximize, class:.*

 # Fix some dragging issues with XWayland
-windowrule = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0
+windowrulev2 = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0
 )#";
--- a/src/debug/CrashReporter.cpp
+++ b/src/debug/CrashReporter.cpp
@@ -2,11 +2,10 @@
 #include <fcntl.h>
 #include <sys/utsname.h>
 #include <link.h>
-#include <ctime>
-#include <cerrno>
+#include <time.h>
+#include <errno.h>
 #include <sys/stat.h>
 #include <filesystem>
-#include "../helpers/MiscFunctions.hpp"

 #include "../plugins/PluginSystem.hpp"
 #include "../signal-safe.hpp"
@@ -32,10 +31,10 @@ static char const* const MESSAGES[] = {"Sorry, didn't mean to...",

 // <random> is not async-signal-safe, fake it with time(NULL) instead
 char const* getRandomMessage() {
-    return MESSAGES[time(nullptr) % (sizeof(MESSAGES) / sizeof(MESSAGES[0]))];
+    return MESSAGES[time(NULL) % (sizeof(MESSAGES) / sizeof(MESSAGES[0]))];
 }

-[[noreturn]] inline void exitWithError(char const* err) {
+[[noreturn]] inline void exit_with_error(char const* err) {
    write(STDERR_FILENO, err, strlen(err));
    // perror() is not signal-safe, but we use it here
    // because if the crash-handler already crashed, it can't get any worse.
@@ -43,17 +42,17 @@ char const* getRandomMessage() {
    abort();
 }

-void NCrashReporter::createAndSaveCrash(int sig) {
-    int reportFd = -1;
+void CrashReporter::createAndSaveCrash(int sig) {
+    int reportFd;

    // We're in the signal handler, so we *only* have stack memory.
    // To save as much stack memory as possible,
    // destroy things as soon as possible.
    {
-        CMaxLengthCString<255> reportPath;
+        MaxLengthCString<255> reportPath;

-        const auto             HOME       = sigGetenv("HOME");
-        const auto             CACHE_HOME = sigGetenv("XDG_CACHE_HOME");
+        const auto            HOME       = sig_getenv("HOME");
+        const auto            CACHE_HOME = sig_getenv("XDG_CACHE_HOME");

        if (CACHE_HOME && CACHE_HOME[0] != '\0') {
            reportPath += CACHE_HOME;
@@ -62,24 +61,24 @@ void NCrashReporter::createAndSaveCrash(int sig) {
            reportPath += HOME;
            reportPath += "/.cache/hyprland";
        } else {
-            exitWithError("$CACHE_HOME and $HOME not set, nowhere to report crash\n");
+            exit_with_error("$CACHE_HOME and $HOME not set, nowhere to report crash\n");
            return;
        }

-        int ret = mkdir(reportPath.getStr(), S_IRWXU);
+        int ret = mkdir(reportPath.get_str(), S_IRWXU);
        //__asm__("int $3");
        if (ret < 0 && errno != EEXIST) {
-            exitWithError("failed to mkdir() crash report directory\n");
+            exit_with_error("failed to mkdir() crash report directory\n");
        }
        reportPath += "/hyprlandCrashReport";
-        reportPath.writeNum(getpid());
+        reportPath.write_num(getpid());
        reportPath += ".txt";

        {
-            CBufFileWriter<64> stderr(2);
+            BufFileWriter<64> stderr(2);
            stderr += "Hyprland has crashed :( Consult the crash report at ";
            if (!reportPath.boundsExceeded()) {
-                stderr += reportPath.getStr();
+                stderr += reportPath.get_str();
            } else {
                stderr += "[ERROR: Crash report path does not fit into memory! Check if your $CACHE_HOME/$HOME is too deeply nested. Max 255 characters.]";
            }
@@ -87,12 +86,12 @@ void NCrashReporter::createAndSaveCrash(int sig) {
            stderr.flush();
        }

-        reportFd = open(reportPath.getStr(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+        reportFd = open(reportPath.get_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
        if (reportFd < 0) {
-            exitWithError("Failed to open crash report path for writing");
+            exit_with_error("Failed to open crash report path for writing");
        }
    }
-    CBufFileWriter<512> finalCrashReport(reportFd);
+    BufFileWriter<512> finalCrashReport(reportFd);

    finalCrashReport += "--------------------------------------------\n   Hyprland Crash Report\n--------------------------------------------\n";
    finalCrashReport += getRandomMessage();
@@ -101,7 +100,7 @@ void NCrashReporter::createAndSaveCrash(int sig) {
    finalCrashReport += "Hyprland received signal ";
    finalCrashReport.writeNum(sig);
    finalCrashReport += '(';
-    finalCrashReport += sigStrsignal(sig);
+    finalCrashReport += sig_strsignal(sig);
    finalCrashReport += ")\nVersion: ";
    finalCrashReport += GIT_COMMIT_HASH;
    finalCrashReport += "\nTag: ";
@@ -112,7 +111,7 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 #ifdef LEGACY_RENDERER
    finalCrashReport += "legacyrenderer\n";
 #endif
-#if ISDEBUG
+#ifndef ISDEBUG
    finalCrashReport += "debug\n";
 #endif
 #ifdef NO_XWAYLAND
@@ -123,9 +122,9 @@ void NCrashReporter::createAndSaveCrash(int sig) {
    if (g_pPluginSystem && g_pPluginSystem->pluginCount() > 0) {
        finalCrashReport += "Hyprland seems to be running with plugins. This crash might not be Hyprland's fault.\nPlugins:\n";

-        const size_t          count = g_pPluginSystem->pluginCount();
-        std::vector<CPlugin*> plugins(count);
-        g_pPluginSystem->sigGetPlugins(plugins.data(), count);
+        size_t   count = g_pPluginSystem->pluginCount();
+        CPlugin* plugins[count];
+        g_pPluginSystem->sig_getPlugins(plugins, count);

        for (size_t i = 0; i < count; i++) {
            auto p = plugins[i];
@@ -162,7 +161,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 -E '(VGA|Display|3D)'");
+    finalCrashReport.writeCmdOutput("lspci -vnn | grep VGA");
 #endif

    finalCrashReport += "\n\nos-release:\n";
@@ -242,5 +241,5 @@ void NCrashReporter::createAndSaveCrash(int sig) {

    finalCrashReport += "\n\nLog tail:\n";

-    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find('\n') + 1);
+    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find("\n") + 1);
 }
--- a/src/debug/CrashReporter.hpp
+++ b/src/debug/CrashReporter.hpp
@@ -2,6 +2,6 @@

 #include "../defines.hpp"

-namespace NCrashReporter {
+namespace CrashReporter {
    void createAndSaveCrash(int sig);
 };
--- a/src/debug/HyprCtl.cpp
+++ b/src/debug/HyprCtl.cpp
@@ -1,13 +1,10 @@
 #include "HyprCtl.hpp"

-#include <algorithm>
 #include <format>
-#include <fstream>
-#include <iterator>
 #include <netinet/in.h>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -25,7 +22,6 @@

 #include <hyprutils/string/String.hpp>
 using namespace Hyprutils::String;
-using namespace Hyprutils::OS;
 #include <aquamarine/input/Input.hpp>

 #include "../config/ConfigDataValues.hpp"
@@ -40,17 +36,6 @@ using namespace Hyprutils::OS;
 #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() == ',')
@@ -120,7 +105,6 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
    "vrr": {},
    "solitary": "{:x}",
    "activelyTearing": {},
-    "directScanoutTo": "{:x}",
    "disabled": {},
    "currentFormat": "{}",
    "mirrorOf": "{}",
@@ -133,27 +117,26 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
            escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
            (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_pLastMonitor ? "true" : "false"),
            (m->dpmsStatus ? "true" : "false"), (m->output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->solitaryClient.get(),
-            (m->tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->lastScanout.get(), (m->m_bEnabled ? "false" : "true"),
-            formatToString(m->output->state->state().drmFormat), m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));
+            (m->tearingState.activelyTearing ? "true" : "false"), (m->m_bEnabled ? "false" : "true"), formatToString(m->output->state->state().drmFormat),
+            m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));

    } else {
        result += std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t"
                              "special workspace: {} ({})\n\treserved: {} {} {} {}\n\tscale: {:.2f}\n\ttransform: {}\n\tfocused: {}\n\t"
-                              "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: "
-                              "{}\n\tavailableModes: {}\n\n",
+                              "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: {}\n\tavailableModes: {}\n\n",
                              m->szName, m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->szShortDescription,
                              m->output->make, m->output->model, m->output->serial, m->activeWorkspaceID(), (!m->activeWorkspace ? "" : m->activeWorkspace->m_szName),
                              m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x,
                              (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform,
                              (m == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(),
-                              m->tearingState.activelyTearing, (uint64_t)m->lastScanout.get(), !m->m_bEnabled, formatToString(m->output->state->state().drmFormat),
+                              m->tearingState.activelyTearing, !m->m_bEnabled, formatToString(m->output->state->state().drmFormat),
                              m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));
    }

    return result;
 }

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

@@ -256,32 +239,30 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
    "grouped": [{}],
    "tags": [{}],
    "swallowing": "0x{:x}",
-    "focusHistoryID": {},
-    "inhibitingIdle": {}
+    "focusHistoryID": {}
 }},)#",
-            (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"),
-            (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(),
-            getFocusHistoryID(w), (g_pInputManager->isWindowInhibiting(w, false) ? "true" : "false"));
+            (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));
    } else {
        return std::format(
            "Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tpseudo: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
            "{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
            "{}\n\txwayland: {}\n\tpinned: "
-            "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\tinhibitingIdle: {}\n\n",
-            (uintptr_t)w.get(), w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y,
-            (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID,
-            (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->monitorID(), w->m_szClass, w->m_szTitle,
-            w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (uint8_t)w->m_sFullscreenState.internal,
-            (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(), getFocusHistoryID(w),
-            (int)g_pInputManager->isWindowInhibiting(w, false));
+            "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\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));
    }
 }

-static std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
+std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";
    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
        result += "[";
@@ -319,17 +300,15 @@ std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat form
    "windows": {},
    "hasfullscreen": {},
    "lastwindow": "0x{:x}",
-    "lastwindowtitle": "{}",
-    "ispersistent": {}
+    "lastwindowtitle": "{}"
 }})#",
                           w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"),
-                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_bHasFullscreenWindow ? "true" : "false",
-                           (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "", w->m_bPersistent ? "true" : "false");
+                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), g_pCompositor->getWindowsOnWorkspace(w->m_iID),
+                           ((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false"), (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "");
    } else {
-        return std::format(
-            "workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\tispersistent: {}\n\n",
-            w->m_iID, w->m_szName, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_bHasFullscreenWindow,
-            (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "", (int)w->m_bPersistent);
+        return std::format("workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\n", w->m_iID,
+                           w->m_szName, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", g_pCompositor->getWindowsOnWorkspace(w->m_iID),
+                           (int)w->m_bHasFullscreenWindow, (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "");
    }
 }

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

@@ -396,7 +374,7 @@ static std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::stri
    return CHyprCtl::getWorkspaceData(w, format);
 }

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

    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -417,7 +395,7 @@ static std::string workspacesRequest(eHyprCtlOutputFormat format, std::string re
    return result;
 }

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

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

    if (!validMapped(PWINDOW))
@@ -451,7 +429,7 @@ static std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string
    return result;
 }

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

    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -479,11 +457,9 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
                    "y": {},
                    "w": {},
                    "h": {},
-                    "namespace": "{}",
-                    "pid": {}
+                    "namespace": "{}"
                }},)#",
-                        (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace),
-                        layer->getPID());
+                        (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace));
                }

                trimTrailingComma(result);
@@ -514,8 +490,8 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
                result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]);

                for (auto const& layer : level) {
-                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}, pid: {}\n", (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y,
-                                          layer->geometry.width, layer->geometry.height, layer->szNamespace, layer->getPID());
+                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}\n", (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width,
+                                          layer->geometry.height, layer->szNamespace);
                }

                layerLevel++;
@@ -527,7 +503,7 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
    return result;
 }

-static std::string layoutsRequest(eHyprCtlOutputFormat format, std::string request) {
+std::string layoutsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result = "";
    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
        result += "[";
@@ -549,13 +525,13 @@ static std::string layoutsRequest(eHyprCtlOutputFormat format, std::string reque
    return result;
 }

-static std::string configErrorsRequest(eHyprCtlOutputFormat format, std::string request) {
+std::string configErrorsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string result     = "";
    std::string currErrors = g_pConfigManager->getErrors();
    CVarList    errLines(currErrors, 0, '\n');
    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
        result += "[";
-        for (const auto& line : errLines) {
+        for (auto line : errLines) {
            result += std::format(
                R"#(
 	"{}",)#",
@@ -565,14 +541,14 @@ static std::string configErrorsRequest(eHyprCtlOutputFormat format, std::string
        trimTrailingComma(result);
        result += "\n]\n";
    } else {
-        for (const auto& line : errLines) {
+        for (auto line : errLines) {
            result += std::format("{}\n", line);
        }
    }
    return result;
 }

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

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

-static std::string animationsRequest(eHyprCtlOutputFormat format, std::string request) {
+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";
@@ -771,8 +747,8 @@ static std::string animationsRequest(eHyprCtlOutputFormat format, std::string re
    "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] = ']';
@@ -795,7 +771,7 @@ static std::string animationsRequest(eHyprCtlOutputFormat format, std::string re
    return ret;
 }

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

    if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -809,15 +785,12 @@ static std::string rollinglogRequest(eHyprCtlOutputFormat format, std::string re
    return result;
 }

-static std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::string request) {
+std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string ret       = "";
    const auto  SHORTCUTS = PROTO::globalShortcuts->getAllShortcuts();
    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
-        for (auto const& sh : SHORTCUTS) {
+        for (auto const& sh : SHORTCUTS)
            ret += std::format("{}:{} -> {}\n", sh.appid, sh.id, sh.description);
-        }
-        if (ret.empty())
-            ret = "none";
    } else {
        ret += "[";
        for (auto const& sh : SHORTCUTS) {
@@ -835,31 +808,31 @@ static std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::stri
    return ret;
 }

-static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
+std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string ret = "";
    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
-        for (auto const& kb : g_pKeybindManager->m_vKeybinds) {
+        for (auto const& kb : g_pKeybindManager->m_lKeybinds) {
            ret += "bind";
-            if (kb->locked)
+            if (kb.locked)
                ret += "l";
-            if (kb->mouse)
+            if (kb.mouse)
                ret += "m";
-            if (kb->release)
+            if (kb.release)
                ret += "r";
-            if (kb->repeat)
+            if (kb.repeat)
                ret += "e";
-            if (kb->nonConsuming)
+            if (kb.nonConsuming)
                ret += "n";
-            if (kb->hasDescription)
+            if (kb.hasDescription)
                ret += "d";

-            ret += std::format("\n\tmodmask: {}\n\tsubmap: {}\n\tkey: {}\n\tkeycode: {}\n\tcatchall: {}\n\tdescription: {}\n\tdispatcher: {}\n\targ: {}\n\n", kb->modmask,
-                               kb->submap, kb->key, kb->keycode, kb->catchAll, kb->description, kb->handler, kb->arg);
+            ret += std::format("\n\tmodmask: {}\n\tsubmap: {}\n\tkey: {}\n\tkeycode: {}\n\tcatchall: {}\n\tdescription: {}\n\tdispatcher: {}\n\targ: {}\n\n", kb.modmask, kb.submap,
+                               kb.key, kb.keycode, kb.catchAll, kb.description, kb.handler, kb.arg);
        }
    } else {
        // json
        ret += "[";
-        for (auto const& kb : g_pKeybindManager->m_vKeybinds) {
+        for (auto const& kb : g_pKeybindManager->m_lKeybinds) {
            ret += std::format(
                R"#(
 {{
@@ -867,7 +840,6 @@ static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request
    "mouse": {},
    "release": {},
    "repeat": {},
-    "longPress": {},
    "non_consuming": {},
    "has_description": {},
    "modmask": {},
@@ -879,9 +851,9 @@ static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request
    "dispatcher": "{}",
    "arg": "{}"
 }},)#",
-                kb->locked ? "true" : "false", kb->mouse ? "true" : "false", kb->release ? "true" : "false", kb->repeat ? "true" : "false", kb->longPress ? "true" : "false",
-                kb->nonConsuming ? "true" : "false", kb->hasDescription ? "true" : "false", kb->modmask, escapeJSONStrings(kb->submap), escapeJSONStrings(kb->key), kb->keycode,
-                kb->catchAll ? "true" : "false", escapeJSONStrings(kb->description), escapeJSONStrings(kb->handler), escapeJSONStrings(kb->arg));
+                kb.locked ? "true" : "false", kb.mouse ? "true" : "false", kb.release ? "true" : "false", kb.repeat ? "true" : "false", kb.nonConsuming ? "true" : "false",
+                kb.hasDescription ? "true" : "false", kb.modmask, escapeJSONStrings(kb.submap), escapeJSONStrings(kb.key), kb.keycode, kb.catchAll ? "true" : "false",
+                escapeJSONStrings(kb.description), escapeJSONStrings(kb.handler), escapeJSONStrings(kb.arg));
        }
        trimTrailingComma(ret);
        ret += "]";
@@ -899,18 +871,17 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
        std::string result = std::format("Hyprland {} built from branch {} at commit {} {} ({}).\n"
                                         "Date: {}\n"
                                         "Tag: {}, commits: {}\n"
-                                         "built against:\n aquamarine {}\n hyprlang {}\n hyprutils {}\n hyprcursor {}\n hyprgraphics {}\n\n\n",
-                                         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);
+                                         "built against aquamarine {}\n\n\n",
+                                         HYPRLAND_VERSION, GIT_BRANCH, GIT_COMMIT_HASH, GIT_DIRTY, commitMsg, GIT_COMMIT_DATE, GIT_TAG, GIT_COMMITS, AQUAMARINE_VERSION);

-#if (!defined(LEGACY_RENDERER) && !ISDEBUG && !defined(NO_XWAYLAND))
+#if (!defined(LEGACY_RENDERER) && !defined(ISDEBUG) && !defined(NO_XWAYLAND))
        result += "no flags were set\n";
 #else
        result += "flags set:\n";
 #ifdef LEGACY_RENDERER
        result += "legacyrenderer\n";
 #endif
-#if ISDEBUG
+#ifdef ISDEBUG
        result += "debug\n";
 #endif
 #ifdef NO_XWAYLAND
@@ -930,18 +901,14 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
    "tag": "{}",
    "commits": "{}",
    "buildAquamarine": "{}",
-    "buildHyprlang": "{}",
-    "buildHyprutils": "{}",
-    "buildHyprcursor": "{}",
-    "buildHyprgraphics": "{}",
    "flags": [)#",
            GIT_BRANCH, GIT_COMMIT_HASH, HYPRLAND_VERSION, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg), GIT_COMMIT_DATE, GIT_TAG,
-            GIT_COMMITS, AQUAMARINE_VERSION, HYPRLANG_VERSION, HYPRUTILS_VERSION, HYPRCURSOR_VERSION, HYPRGRAPHICS_VERSION);
+            GIT_COMMITS, AQUAMARINE_VERSION);

 #ifdef LEGACY_RENDERER
        result += "\"legacyrenderer\",";
 #endif
-#if ISDEBUG
+#ifdef ISDEBUG
        result += "\"debug\",";
 #endif
 #ifdef NO_XWAYLAND
@@ -977,49 +944,16 @@ std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request)
 #if defined(__DragonFly__) || defined(__FreeBSD__)
    const std::string GPUINFO = execAndGet("pciconf -lv | grep -F -A4 vga");
 #elif defined(__arm__) || defined(__aarch64__)
-    std::string                 GPUINFO;
-    const std::filesystem::path dev_tree = "/proc/device-tree";
-    try {
-        if (std::filesystem::exists(dev_tree) && std::filesystem::is_directory(dev_tree)) {
-            std::for_each(std::filesystem::directory_iterator(dev_tree), std::filesystem::directory_iterator{}, [&](const std::filesystem::directory_entry& entry) {
-                if (std::filesystem::is_directory(entry) && entry.path().filename().string().starts_with("soc")) {
-                    std::for_each(std::filesystem::directory_iterator(entry.path()), std::filesystem::directory_iterator{}, [&](const std::filesystem::directory_entry& sub_entry) {
-                        if (std::filesystem::is_directory(sub_entry) && sub_entry.path().filename().string().starts_with("gpu")) {
-                            std::filesystem::path file_path = sub_entry.path() / "compatible";
-                            std::ifstream         file(file_path);
-                            if (file)
-                                GPUINFO.append(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
-                        }
-                    });
-                }
-            });
-        }
-    } catch (...) { GPUINFO = "error"; }
+    const std::string GPUINFO = execAndGet("cat /proc/device-tree/soc*/gpu*/compatible");
 #else
-    const std::string GPUINFO = execAndGet("lspci -vnn | grep -E '(VGA|Display|3D)'");
+    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
 #endif
    result += "GPU information: \n" + GPUINFO;
-    if (GPUINFO.contains("NVIDIA") && std::filesystem::exists("/proc/driver/nvidia/version")) {
-        std::ifstream file("/proc/driver/nvidia/version");
-        std::string   line;
-        if (file.is_open()) {
-            while (std::getline(file, line)) {
-                if (!line.contains("NVRM"))
-                    continue;
-                result += line;
-                result += "\n";
-            }
-        } else
-            result += "error";
-    }
+    if (GPUINFO.contains("NVIDIA") && std::filesystem::exists("/proc/driver/nvidia/version"))
+        result += execAndGet("cat /proc/driver/nvidia/version | grep NVRM");
    result += "\n\n";

-    if (std::ifstream file("/etc/os-release"); file.is_open()) {
-        std::stringstream buffer;
-        buffer << file.rdbuf();
-        result += "os-release: " + buffer.str() + "\n\n";
-    } else
-        result += "os-release: error\n\n";
+    result += "os-release: " + execAndGet("cat /etc/os-release") + "\n\n";

    result += "plugins:\n";
    if (g_pPluginSystem) {
@@ -1038,7 +972,7 @@ std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request)
    return result;
 }

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

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

-static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
+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)
@@ -1108,9 +1042,6 @@ static 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")) {
@@ -1128,29 +1059,32 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
    return retval;
 }

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

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

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

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

    return "ok";
 }

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

    return "ok";
 }

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

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

    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
@@ -1168,33 +1102,41 @@ static std::string cursorPosRequest(eHyprCtlOutputFormat format, std::string req
    return "error";
 }

-static std::string dispatchBatch(eHyprCtlOutputFormat format, std::string request) {
-    // split by ; ignores ; inside [] and adds ; on last command
+std::string dispatchBatch(eHyprCtlOutputFormat format, std::string request) {
+    // split by ;

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

-    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;
+    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();
+
+    const std::string DELIMITER = "\n\n\n";
+
+    while (curitem != "" || request != "") {
+        reply += g_pHyprCtl->getReply(curitem) + DELIMITER;
+
+        nextItem();
    }

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

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

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

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

    const auto    KB  = vars[1];
@@ -1293,7 +1235,7 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
    return "ok";
 }

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

    std::string errorMessage = "";
@@ -1307,7 +1249,7 @@ static std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string req
        return "ok";
    }

-    const CHyprColor COLOR = configStringToInt(vars[1]).value_or(0);
+    const CColor COLOR = configStringToInt(vars[1]);

    for (size_t i = 2; i < vars.size(); ++i)
        errorMessage += vars[i] + ' ';
@@ -1322,12 +1264,12 @@ static std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string req
    return "ok";
 }

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

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

    auto        nextItem = [&]() {
@@ -1368,22 +1310,23 @@ static std::string dispatchGetOption(eHyprCtlOutputFormat format, std::string re
            return std::format("custom type: {}\nset: {}", ((ICustomConfigValueData*)std::any_cast<void*>(VAL))->toString(), VAR->m_bSetByUser);
    } else {
        if (TYPE == typeid(Hyprlang::INT))
-            return std::format(R"({{"option": "{}", "int": {}, "set": {} }})", curitem, std::any_cast<Hyprlang::INT>(VAL), VAR->m_bSetByUser);
+            return std::format("{{\"option\": \"{}\", \"int\": {}, \"set\": {} }}", curitem, std::any_cast<Hyprlang::INT>(VAL), VAR->m_bSetByUser);
        else if (TYPE == typeid(Hyprlang::FLOAT))
-            return std::format(R"({{"option": "{}", "float": {:2f}, "set": {} }})", curitem, std::any_cast<Hyprlang::FLOAT>(VAL), VAR->m_bSetByUser);
+            return std::format("{{\"option\": \"{}\", \"float\": {:2f}, \"set\": {} }}", curitem, std::any_cast<Hyprlang::FLOAT>(VAL), VAR->m_bSetByUser);
        else if (TYPE == typeid(Hyprlang::VEC2))
-            return std::format(R"({{"option": "{}", "vec2": [{},{}], "set": {} }})", curitem, std::any_cast<Hyprlang::VEC2>(VAL).x, std::any_cast<Hyprlang::VEC2>(VAL).y,
+            return std::format("{{\"option\": \"{}\", \"vec2\": [{},{}], \"set\": {} }}", curitem, std::any_cast<Hyprlang::VEC2>(VAL).x, std::any_cast<Hyprlang::VEC2>(VAL).y,
                               VAR->m_bSetByUser);
        else if (TYPE == typeid(Hyprlang::STRING))
-            return std::format(R"({{"option": "{}", "str": "{}", "set": {} }})", curitem, escapeJSONStrings(std::any_cast<Hyprlang::STRING>(VAL)), VAR->m_bSetByUser);
+            return std::format("{{\"option\": \"{}\", \"str\": \"{}\", \"set\": {} }}", curitem, escapeJSONStrings(std::any_cast<Hyprlang::STRING>(VAL)), VAR->m_bSetByUser);
        else if (TYPE == typeid(void*))
-            return std::format(R"({{"option": "{}", "custom": "{}", "set": {} }})", curitem, ((ICustomConfigValueData*)std::any_cast<void*>(VAL))->toString(), VAR->m_bSetByUser);
+            return std::format("{{\"option\": \"{}\", \"custom\": \"{}\", \"set\": {} }}", curitem, ((ICustomConfigValueData*)std::any_cast<void*>(VAL))->toString(),
+                               VAR->m_bSetByUser);
    }

    return "invalid type (internal error)";
 }

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

@@ -1409,7 +1352,7 @@ static std::string decorationRequest(eHyprCtlOutputFormat format, std::string re
    return result;
 }

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

    if (vars.size() < 2)
@@ -1464,7 +1407,7 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
    return "ok";
 }

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

    if (vars.size() < 2)
@@ -1492,40 +1435,17 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque

        g_pPluginSystem->unloadPlugin(PLUGIN);
    } else if (OPERATION == "list") {
-        const auto  PLUGINS = g_pPluginSystem->getAllPlugins();
-        std::string result  = "";
+        const auto PLUGINS = g_pPluginSystem->getAllPlugins();

-        if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
-            result += "[";
+        if (PLUGINS.size() == 0)
+            return "no plugins loaded";

-            if (PLUGINS.size() == 0)
-                return "[]";
-
-            for (auto const& p : PLUGINS) {
-                result += std::format(
-                    R"#(
-{{
-    "name": "{}",
-    "author": "{}",
-    "handle": "{:x}",
-    "version": "{}",
-    "description": "{}"
-}},)#",
-                    escapeJSONStrings(p->name), escapeJSONStrings(p->author), (uintptr_t)p->m_pHandle, escapeJSONStrings(p->version), escapeJSONStrings(p->description));
-            }
-            trimTrailingComma(result);
-            result += "]";
-        } else {
-            if (PLUGINS.size() == 0)
-                return "no plugins loaded";
-
-            for (auto const& p : PLUGINS) {
-                result +=
-                    std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->name, p->author, (uintptr_t)p->m_pHandle, p->version, p->description);
-            }
+        std::string list = "";
+        for (auto const& p : PLUGINS) {
+            list += std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->name, p->author, (uintptr_t)p->m_pHandle, p->version, p->description);
        }

-        return result;
+        return list;
    } else {
        return "unknown opt";
    }
@@ -1533,7 +1453,7 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
    return "ok";
 }

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

    if (vars.size() < 5)
@@ -1549,8 +1469,9 @@ static std::string dispatchNotify(eHyprCtlOutputFormat format, std::string reque
        icon = std::stoi(ICON);
    } catch (std::exception& e) { return "invalid arg 1"; }

-    if (icon > ICON_NONE || icon < 0)
+    if (icon > ICON_NONE || icon < 0) {
        icon = ICON_NONE;
+    }

    const auto TIME = vars[2];
    int        time = 0;
@@ -1558,13 +1479,10 @@ static std::string dispatchNotify(eHyprCtlOutputFormat format, std::string reque
        time = std::stoi(TIME);
    } catch (std::exception& e) { return "invalid arg 2"; }

-    const auto COLOR_RESULT = configStringToInt(vars[3]);
-    if (!COLOR_RESULT)
-        return "invalid arg 3";
-    CHyprColor color = *COLOR_RESULT;
+    CColor color = configStringToInt(vars[3]);

-    size_t     msgidx   = 4;
-    float      fontsize = 13.f;
+    size_t msgidx   = 4;
+    float  fontsize = 13.f;
    if (vars[msgidx].length() > 9 && vars[msgidx].compare(0, 9, "fontsize:") == 0) {
        const auto FONTSIZE = vars[msgidx].substr(9);

@@ -1588,7 +1506,7 @@ static std::string dispatchNotify(eHyprCtlOutputFormat format, std::string reque
    return "ok";
 }

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

    int      amount = -1;
@@ -1608,7 +1526,7 @@ static std::string dispatchDismissNotify(eHyprCtlOutputFormat format, std::strin
    return "ok";
 }

-static std::string getIsLocked(eHyprCtlOutputFormat format, std::string request) {
+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"#(
@@ -1620,7 +1538,7 @@ static std::string getIsLocked(eHyprCtlOutputFormat format, std::string request)
    return lockedStr;
 }

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

@@ -1635,7 +1553,7 @@ static std::string getDescriptions(eHyprCtlOutputFormat format, std::string requ
    return json;
 }

-static std::string submapRequest(eHyprCtlOutputFormat format, std::string request) {
+std::string submapRequest(eHyprCtlOutputFormat format, std::string request) {
    std::string submap = g_pKeybindManager->getCurrentSubmap();
    if (submap.empty())
        submap = "default";
@@ -1688,6 +1606,8 @@ CHyprCtl::CHyprCtl() {
 CHyprCtl::~CHyprCtl() {
    if (m_eventSource)
        wl_event_source_remove(m_eventSource);
+    if (m_iSocketFD >= 0)
+        close(m_iSocketFD);
    if (!m_socketPath.empty())
        unlink(m_socketPath.c_str());
 }
@@ -1782,7 +1702,7 @@ std::string CHyprCtl::getReply(std::string request) {
        }

        for (auto const& w : g_pCompositor->m_vWindows) {
-            if (!w->m_bIsMapped || !w->m_pWorkspace || !w->m_pWorkspace->isVisible())
+            if (!w->m_bIsMapped || !g_pCompositor->isWorkspaceVisible(w->m_pWorkspace))
                continue;

            w->updateDynamicRules();
@@ -1802,7 +1722,7 @@ std::string CHyprCtl::makeDynamicCall(const std::string& input) {
    return getReply(input);
 }

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

@@ -1815,18 +1735,18 @@ static bool successWrite(int fd, const std::string& data, bool needLog = true) {
    return false;
 }

-static void runWritingDebugLogThread(const int conn) {
+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
    std::thread([conn]() {
-        while (Debug::SRollingLogFollow::get().isRunning()) {
-            if (Debug::SRollingLogFollow::get().isEmpty(conn)) {
+        while (Debug::RollingLogFollow::Get().IsRunning()) {
+            if (Debug::RollingLogFollow::Get().isEmpty(conn)) {
                std::this_thread::sleep_for(1000ms);
                continue;
            }

-            auto line = Debug::SRollingLogFollow::get().getLog(conn);
+            auto line = Debug::RollingLogFollow::Get().GetLog(conn);
            if (!successWrite(conn, line))
                // We cannot write, when connection is closed. So thread will successfully exit by itself
                break;
@@ -1834,25 +1754,22 @@ static void runWritingDebugLogThread(const int conn) {
            std::this_thread::sleep_for(100ms);
        }
        close(conn);
-        Debug::SRollingLogFollow::get().stopFor(conn);
+        Debug::RollingLogFollow::Get().StopFor(conn);
    }).detach();
 }

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

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

-    if (!g_pHyprCtl->m_iSocketFD.isValid())
-        return 0;
-
    sockaddr_in            clientAddress;
    socklen_t              clientSize = sizeof(clientAddress);

-    const auto             ACCEPTEDCONNECTION = accept4(g_pHyprCtl->m_iSocketFD.get(), (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);
+    const auto             ACCEPTEDCONNECTION = accept4(g_pHyprCtl->m_iSocketFD, (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);

    std::array<char, 1024> readBuffer;

@@ -1896,9 +1813,9 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {

    if (isFollowUpRollingLogRequest(request)) {
        Debug::log(LOG, "Followup rollinglog request received. Starting thread to write to socket.");
-        Debug::SRollingLogFollow::get().startFor(ACCEPTEDCONNECTION);
+        Debug::RollingLogFollow::Get().StartFor(ACCEPTEDCONNECTION);
        runWritingDebugLogThread(ACCEPTEDCONNECTION);
-        Debug::log(LOG, Debug::SRollingLogFollow::get().debugInfo());
+        Debug::log(LOG, Debug::RollingLogFollow::Get().DebugInfo());
    } else
        close(ACCEPTEDCONNECTION);

@@ -1909,9 +1826,9 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
 }

 void CHyprCtl::startHyprCtlSocket() {
-    m_iSocketFD = CFileDescriptor{socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)};
+    m_iSocketFD = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);

-    if (!m_iSocketFD.isValid()) {
+    if (m_iSocketFD < 0) {
        Debug::log(ERR, "Couldn't start the Hyprland Socket. (1) IPC will not work.");
        return;
    }
@@ -1922,15 +1839,15 @@ void CHyprCtl::startHyprCtlSocket() {

    strcpy(SERVERADDRESS.sun_path, m_socketPath.c_str());

-    if (bind(m_iSocketFD.get(), (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
+    if (bind(m_iSocketFD, (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
        Debug::log(ERR, "Couldn't start the Hyprland Socket. (2) IPC will not work.");
        return;
    }

    // 10 max queued.
-    listen(m_iSocketFD.get(), 10);
+    listen(m_iSocketFD, 10);

    Debug::log(LOG, "Hypr socket started at {}", m_socketPath);

-    m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, m_iSocketFD.get(), WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
+    m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, m_iSocketFD, WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
 }
--- a/src/debug/HyprCtl.hpp
+++ b/src/debug/HyprCtl.hpp
@@ -1,10 +1,9 @@
 #pragma once

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

 // exposed for main.cpp
 std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request);
@@ -15,12 +14,12 @@ class CHyprCtl {
    CHyprCtl();
    ~CHyprCtl();

-    std::string                    makeDynamicCall(const std::string& input);
-    SP<SHyprCtlCommand>            registerCommand(SHyprCtlCommand cmd);
-    void                           unregisterCommand(const SP<SHyprCtlCommand>& cmd);
-    std::string                    getReply(std::string);
+    std::string         makeDynamicCall(const std::string& input);
+    SP<SHyprCtlCommand> registerCommand(SHyprCtlCommand cmd);
+    void                unregisterCommand(const SP<SHyprCtlCommand>& cmd);
+    std::string         getReply(std::string);

-    Hyprutils::OS::CFileDescriptor m_iSocketFD;
+    int                 m_iSocketFD = -1;

    struct {
        bool all           = false;
@@ -39,4 +38,4 @@ class CHyprCtl {
    std::string                      m_socketPath;
 };

-inline UP<CHyprCtl> g_pHyprCtl;
+inline std::unique_ptr<CHyprCtl> g_pHyprCtl;
--- a/src/debug/HyprDebugOverlay.cpp
+++ b/src/debug/HyprDebugOverlay.cpp
@@ -2,21 +2,13 @@
 #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>();
 }

 void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
-    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
-
-    if (!*PDEBUGOVERLAY)
-        return;
-
-    m_dLastRenderTimes.emplace_back(durationUs / 1000.f);
+    m_dLastRenderTimes.push_back(durationUs / 1000.f);

    if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
        m_dLastRenderTimes.pop_front();
@@ -26,12 +18,7 @@ void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs)
 }

 void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
-    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
-
-    if (!*PDEBUGOVERLAY)
-        return;
-
-    m_dLastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
+    m_dLastRenderTimesNoOverlay.push_back(durationUs / 1000.f);

    if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
        m_dLastRenderTimesNoOverlay.pop_front();
@@ -41,12 +28,7 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float du
 }

 void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
-    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
-
-    if (!*PDEBUGOVERLAY)
-        return;
-
-    m_dLastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
+    m_dLastFrametimes.push_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);

    if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
        m_dLastFrametimes.pop_front();
@@ -198,38 +180,23 @@ 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;
 }

 void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
-    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
-
-    if (!*PDEBUGOVERLAY)
-        return;
-
    m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs);
 }

 void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
-    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
-
-    if (!*PDEBUGOVERLAY)
-        return;
-
    m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
 }

 void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
-    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
-
-    if (!*PDEBUGOVERLAY)
-        return;
-
    m_mMonitorOverlays[pMonitor].frameData(pMonitor);
 }

@@ -271,8 +238,6 @@ void CHyprDebugOverlay::draw() {

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

-    CTexPassElement::SRenderData data;
-    data.tex = m_pTexture;
-    data.box = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
-    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
+    CBox pMonBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    g_pHyprOpenGL->renderTexture(m_pTexture, &pMonBox, 1.f);
 }
--- a/src/debug/HyprDebugOverlay.hpp
+++ b/src/debug/HyprDebugOverlay.hpp
@@ -1,10 +1,11 @@
 #pragma once

 #include "../defines.hpp"
+#include "../helpers/Monitor.hpp"
 #include "../render/Texture.hpp"
+#include <deque>
 #include <cairo/cairo.h>
 #include <map>
-#include <deque>

 class CHyprRenderer;

@@ -48,4 +49,4 @@ class CHyprDebugOverlay {
    friend class CHyprRenderer;
 };

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

-#include "../managers/AnimationManager.hpp"
-#include "../managers/HookSystemManager.hpp"
-#include "../render/Renderer.hpp"
-
-static inline auto iconBackendFromLayout(PangoLayout* layout) {
+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) {
@@ -23,10 +18,10 @@ static inline auto iconBackendFromLayout(PangoLayout* layout) {

 CHyprNotificationOverlay::CHyprNotificationOverlay() {
    static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
-        if (m_vNotifications.size() == 0)
+        if (m_dNotifications.size() == 0)
            return;

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

    m_pTexture = makeShared<CTexture>();
@@ -39,11 +34,11 @@ CHyprNotificationOverlay::~CHyprNotificationOverlay() {
        cairo_surface_destroy(m_pCairoSurface);
 }

-void CHyprNotificationOverlay::addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon, const float fontSize) {
-    const auto PNOTIF = m_vNotifications.emplace_back(makeUnique<SNotification>()).get();
+void CHyprNotificationOverlay::addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon, const float fontSize) {
+    const auto PNOTIF = m_dNotifications.emplace_back(std::make_unique<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;
+    PNOTIF->color = color == CColor(0) ? ICONS_COLORS[icon] : color;
    PNOTIF->started.reset();
    PNOTIF->timeMs   = timeMs;
    PNOTIF->icon     = icon;
@@ -56,12 +51,12 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CH

 void CHyprNotificationOverlay::dismissNotifications(const int amount) {
    if (amount == -1)
-        m_vNotifications.clear();
+        m_dNotifications.clear();
    else {
-        const int AMT = std::min(amount, static_cast<int>(m_vNotifications.size()));
+        const int AMT = std::min(amount, static_cast<int>(m_dNotifications.size()));

        for (int i = 0; i < AMT; ++i) {
-            m_vNotifications.erase(m_vNotifications.begin());
+            m_dNotifications.pop_front();
        }
    }
 }
@@ -92,7 +87,7 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
    const auto iconBackendID = iconBackendFromLayout(layout);
    const auto PBEZIER       = g_pAnimationManager->getBezier("default");

-    for (auto const& notif : m_vNotifications) {
+    for (auto const& notif : m_dNotifications) {
        const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD;
        const auto FONTSIZE        = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);

@@ -187,7 +182,7 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
    g_object_unref(layout);

    // cleanup notifs
-    std::erase_if(m_vNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
+    std::erase_if(m_dNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });

    return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
 }
@@ -210,7 +205,7 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
    }

    // Draw the notifications
-    if (m_vNotifications.size() == 0)
+    if (m_dNotifications.size() == 0)
        return;

    // Render to the monitor
@@ -225,8 +220,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);

@@ -246,14 +241,10 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {

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

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

 bool CHyprNotificationOverlay::hasAny() {
-    return !m_vNotifications.empty();
+    return !m_dNotifications.empty();
 }
--- a/src/debug/HyprNotificationOverlay.hpp
+++ b/src/debug/HyprNotificationOverlay.hpp
@@ -2,14 +2,15 @@

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

-#include <vector>
+#include <deque>

 #include <cairo/cairo.h>

-enum eIconBackend : uint8_t {
+enum eIconBackend {
    ICONS_BACKEND_NONE = 0,
    ICONS_BACKEND_NF,
    ICONS_BACKEND_FA
@@ -18,17 +19,17 @@ enum eIconBackend : uint8_t {
 static const std::array<std::array<std::string, ICON_NONE + 1>, 3 /* backends */> ICONS_ARRAY = {
    std::array<std::string, ICON_NONE + 1>{"[!]", "[i]", "[Hint]", "[Err]", "[?]", "[ok]", ""},
    std::array<std::string, ICON_NONE + 1>{"", "", "", "", "", "󰸞", ""}, std::array<std::string, ICON_NONE + 1>{"", "", "", "", "", ""}};
-static const std::array<CHyprColor, ICON_NONE + 1> ICONS_COLORS = {CHyprColor{255.0 / 255.0, 204 / 255.0, 102 / 255.0, 1.0},
-                                                                   CHyprColor{128 / 255.0, 255 / 255.0, 255 / 255.0, 1.0},
-                                                                   CHyprColor{179 / 255.0, 255 / 255.0, 204 / 255.0, 1.0},
-                                                                   CHyprColor{255 / 255.0, 77 / 255.0, 77 / 255.0, 1.0},
-                                                                   CHyprColor{255 / 255.0, 204 / 255.0, 153 / 255.0, 1.0},
-                                                                   CHyprColor{128 / 255.0, 255 / 255.0, 128 / 255.0, 1.0},
-                                                                   CHyprColor{0, 0, 0, 1.0}};
+static const std::array<CColor, ICON_NONE + 1> ICONS_COLORS = {CColor{255.0 / 255.0, 204 / 255.0, 102 / 255.0, 1.0},
+                                                               CColor{128 / 255.0, 255 / 255.0, 255 / 255.0, 1.0},
+                                                               CColor{179 / 255.0, 255 / 255.0, 204 / 255.0, 1.0},
+                                                               CColor{255 / 255.0, 77 / 255.0, 77 / 255.0, 1.0},
+                                                               CColor{255 / 255.0, 204 / 255.0, 153 / 255.0, 1.0},
+                                                               CColor{128 / 255.0, 255 / 255.0, 128 / 255.0, 1.0},
+                                                               CColor{0, 0, 0, 1.0}};

 struct SNotification {
    std::string text = "";
-    CHyprColor  color;
+    CColor      color;
    CTimer      started;
    float       timeMs   = 0;
    eIcons      icon     = ICON_NONE;
@@ -41,23 +42,23 @@ class CHyprNotificationOverlay {
    ~CHyprNotificationOverlay();

    void draw(PHLMONITOR pMonitor);
-    void addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
+    void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
    void dismissNotifications(const int amount);
    bool hasAny();

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

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

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

 #include <fstream>
@@ -17,7 +18,7 @@ void Debug::close() {
    logOfs.close();
 }

-void Debug::log(eLogLevel level, std::string str) {
+void Debug::log(LogLevel level, std::string str) {
    if (level == TRACE && !trace)
        return;

@@ -25,7 +26,6 @@ void Debug::log(eLogLevel level, std::string str) {
        return;

    std::string coloredStr = str;
-    //NOLINTBEGIN
    switch (level) {
        case LOG:
            str        = "[LOG] " + str;
@@ -53,14 +53,13 @@ void Debug::log(eLogLevel level, std::string str) {
            break;
        default: break;
    }
-    //NOLINTEND

    rollingLog += str + "\n";
    if (rollingLog.size() > ROLLING_LOG_SIZE)
        rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);

-    if (SRollingLogFollow::get().isRunning())
-        SRollingLogFollow::get().addLog(str);
+    if (RollingLogFollow::Get().IsRunning())
+        RollingLogFollow::Get().AddLog(str);

    if (!disableLogs || !**disableLogs) {
        // log to a file
--- a/src/debug/Log.hpp
+++ b/src/debug/Log.hpp
@@ -5,11 +5,13 @@
 #include <fstream>
 #include <chrono>
 #include <mutex>
+#include "../includes.hpp"
+#include "../helpers/MiscFunctions.hpp"

 #define LOGMESSAGESIZE   1024
 #define ROLLING_LOG_SIZE 4096

-enum eLogLevel : int8_t {
+enum LogLevel {
    NONE = -1,
    LOG  = 0,
    WARN,
@@ -19,7 +21,6 @@ enum eLogLevel : int8_t {
    TRACE
 };

-// NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
    inline std::string     logFile;
    inline std::ofstream   logOfs;
@@ -37,11 +38,10 @@ namespace Debug {
    void                   close();

    //
-    void log(eLogLevel level, std::string str);
+    void log(LogLevel level, std::string str);

    template <typename... Args>
-    //NOLINTNEXTLINE
-    void log(eLogLevel level, std::format_string<Args...> fmt, Args&&... args) {
+    void log(LogLevel level, std::format_string<Args...> fmt, Args&&... args) {
        std::lock_guard<std::mutex> guard(logMutex);

        if (level == TRACE && !trace)
--- a/src/debug/RollingLogFollow.hpp
+++ b/src/debug/RollingLogFollow.hpp
@@ -2,9 +2,8 @@

 #include <shared_mutex>

-// NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
-    struct SRollingLogFollow {
+    struct RollingLogFollow {
        std::unordered_map<int, std::string> socketToRollingLogFollowQueue;
        std::shared_mutex                    m;
        bool                                 running                    = false;
@@ -16,12 +15,12 @@ namespace Debug {
            return socketToRollingLogFollowQueue[socket].empty();
        }

-        std::string debugInfo() {
+        std::string DebugInfo() {
            std::shared_lock<std::shared_mutex> r(m);
            return std::format("RollingLogFollow, got {} connections", socketToRollingLogFollowQueue.size());
        }

-        std::string getLog(int socket) {
+        std::string GetLog(int socket) {
            std::unique_lock<std::shared_mutex> w(m);

            const std::string                   ret = socketToRollingLogFollowQueue[socket];
@@ -30,7 +29,7 @@ namespace Debug {
            return ret;
        };

-        void addLog(const std::string& log) {
+        void AddLog(std::string log) {
            std::unique_lock<std::shared_mutex> w(m);
            running = true;
            std::vector<int> to_erase;
@@ -38,26 +37,26 @@ namespace Debug {
                socketToRollingLogFollowQueue[p.first] += log + "\n";
        }

-        bool isRunning() {
+        bool IsRunning() {
            std::shared_lock<std::shared_mutex> r(m);
            return running;
        }

-        void stopFor(int socket) {
+        void StopFor(int socket) {
            std::unique_lock<std::shared_mutex> w(m);
            socketToRollingLogFollowQueue.erase(socket);
            if (socketToRollingLogFollowQueue.empty())
                running = false;
        }

-        void startFor(int socket) {
+        void StartFor(int socket) {
            std::unique_lock<std::shared_mutex> w(m);
            socketToRollingLogFollowQueue[socket] = std::format("[LOG] Following log to socket: {} started\n", socket);
            running                               = true;
        }

-        static SRollingLogFollow& get() {
-            static SRollingLogFollow    instance;
+        static RollingLogFollow& Get() {
+            static RollingLogFollow     instance;
            static std::mutex           gm;
            std::lock_guard<std::mutex> lock(gm);
            return instance;
--- a/src/defines.hpp
+++ b/src/defines.hpp
@@ -1,5 +1,3 @@
-#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 "../helpers/memory/Memory.hpp"
+#include "../macros.hpp"
 class CWorkspace;
 class CWindow;
 class CLayerSurface;
--- a/src/desktop/LayerRule.cpp
+++ b/src/desktop/LayerRule.cpp
@@ -1,38 +0,0 @@
-#include <re2/re2.h>
-#include "LayerRule.hpp"
-#include <unordered_set>
-#include <algorithm>
-#include "../debug/Log.hpp"
-
-static const auto RULES        = std::unordered_set<std::string>{"noanim", "blur", "blurpopups", "dimaround"};
-static const auto RULES_PREFIX = std::unordered_set<std::string>{"ignorealpha", "ignorezero", "xray", "animation", "order"};
-
-CLayerRule::CLayerRule(const std::string& rule_, const std::string& ns_) : targetNamespace(ns_), rule(rule_) {
-    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule_](const auto& prefix) { return rule_.starts_with(prefix); });
-
-    if (!VALID)
-        return;
-
-    if (rule == "noanim")
-        ruleType = RULE_NOANIM;
-    else if (rule == "blur")
-        ruleType = RULE_BLUR;
-    else if (rule == "blurpopups")
-        ruleType = RULE_BLURPOPUPS;
-    else if (rule == "dimaround")
-        ruleType = RULE_DIMAROUND;
-    else if (rule.starts_with("ignorealpha"))
-        ruleType = RULE_IGNOREALPHA;
-    else if (rule.starts_with("ignorezero"))
-        ruleType = RULE_IGNOREZERO;
-    else if (rule.starts_with("xray"))
-        ruleType = RULE_XRAY;
-    else if (rule.starts_with("animation"))
-        ruleType = RULE_ANIMATION;
-    else if (rule.starts_with("order"))
-        ruleType = RULE_ORDER;
-    else {
-        Debug::log(ERR, "CLayerRule: didn't match a rule that was found valid?!");
-        ruleType = RULE_INVALID;
-    }
-}
--- a/src/desktop/LayerRule.hpp
+++ b/src/desktop/LayerRule.hpp
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <string>
-#include <cstdint>
-#include "Rule.hpp"
-
-class CLayerRule {
-  public:
-    CLayerRule(const std::string& rule, const std::string& targetNS);
-
-    enum eRuleType : uint8_t {
-        RULE_INVALID = 0,
-        RULE_NOANIM,
-        RULE_BLUR,
-        RULE_BLURPOPUPS,
-        RULE_DIMAROUND,
-        RULE_IGNOREALPHA,
-        RULE_IGNOREZERO,
-        RULE_XRAY,
-        RULE_ANIMATION,
-        RULE_ORDER,
-        RULE_ZUMBA,
-    };
-
-    eRuleType           ruleType = RULE_INVALID;
-
-    const std::string   targetNamespace;
-    const std::string   rule;
-
-    CRuleRegexContainer targetNamespaceRegex;
-};
--- a/src/desktop/LayerSurface.cpp
+++ b/src/desktop/LayerSurface.cpp
@@ -4,18 +4,11 @@
 #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));

-    auto  pMonitor = resource->monitor.empty() ? g_pCompositor->m_pLastMonitor.lock() : g_pCompositor->getMonitorFromName(resource->monitor);
+    auto  pMonitor = resource->monitor.empty() ? g_pCompositor->getMonitorFromCursor() : g_pCompositor->getMonitorFromName(resource->monitor);

    pLS->surface->assign(resource->surface.lock(), pLS);

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

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

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

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

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

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

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

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

    startAnimation(false);

@@ -240,13 +235,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->simulateMouseMovement();
+    g_pInputManager->sendMotionEventsToFocused();

    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 }
@@ -275,7 +270,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) {
@@ -312,17 +307,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)) {
@@ -332,7 +327,7 @@ void CLayerSurface::onCommit() {
            nullptr);
        if (!WASLASTFOCUS && popupHead) {
            popupHead->breadthfirst(
-                [&WASLASTFOCUS](WP<CPopup> popup, void* data) {
+                [&WASLASTFOCUS](CPopup* popup, void* data) {
                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_pWLSurface && g_pSeatManager->state.keyboardFocus == popup->m_pWLSurface->resource());
                },
                nullptr);
@@ -383,73 +378,54 @@ void CLayerSurface::applyRules() {
    animationStyle.reset();

    for (auto const& rule : g_pConfigManager->getMatchingRules(self.lock())) {
-        switch (rule->ruleType) {
-            case CLayerRule::RULE_NOANIM: {
-                noAnimations = true;
-                break;
-            }
-            case CLayerRule::RULE_BLUR: {
-                forceBlur = true;
-                break;
-            }
-            case CLayerRule::RULE_BLURPOPUPS: {
-                forceBlurPopups = true;
-                break;
-            }
-            case CLayerRule::RULE_IGNOREALPHA:
-            case CLayerRule::RULE_IGNOREZERO: {
-                const auto  FIRST_SPACE_POS = rule->rule.find_first_of(' ');
-                std::string alphaValue      = "";
-                if (FIRST_SPACE_POS != std::string::npos)
-                    alphaValue = rule->rule.substr(FIRST_SPACE_POS + 1);
+        if (rule.rule == "noanim")
+            noAnimations = true;
+        else if (rule.rule == "blur")
+            forceBlur = true;
+        else if (rule.rule == "blurpopups")
+            forceBlurPopups = true;
+        else if (rule.rule.starts_with("ignorealpha") || rule.rule.starts_with("ignorezero")) {
+            const auto  FIRST_SPACE_POS = rule.rule.find_first_of(' ');
+            std::string alphaValue      = "";
+            if (FIRST_SPACE_POS != std::string::npos)
+                alphaValue = rule.rule.substr(FIRST_SPACE_POS + 1);

-                try {
-                    ignoreAlpha = true;
-                    if (!alphaValue.empty())
-                        ignoreAlphaValue = std::stof(alphaValue);
-                } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
-                break;
-            }
-            case CLayerRule::RULE_DIMAROUND: {
-                dimAround = true;
-                break;
-            }
-            case CLayerRule::RULE_XRAY: {
-                CVarList vars{rule->rule, 0, ' '};
-                try {
-                    xray = configStringToInt(vars[1]).value_or(false);
-                } catch (...) {}
-                break;
-            }
-            case CLayerRule::RULE_ANIMATION: {
-                CVarList vars{rule->rule, 2, 's'};
-                animationStyle = vars[1];
-                break;
-            }
-            case CLayerRule::RULE_ORDER: {
-                CVarList vars{rule->rule, 2, 's'};
-                try {
-                    order = std::stoi(vars[1]);
-                } catch (...) { Debug::log(ERR, "Invalid value passed to order"); }
-                break;
-            }
-            default: break;
+            try {
+                ignoreAlpha = true;
+                if (!alphaValue.empty())
+                    ignoreAlphaValue = std::stof(alphaValue);
+            } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
+        } else if (rule.rule == "dimaround") {
+            dimAround = true;
+        } else if (rule.rule.starts_with("xray")) {
+            CVarList vars{rule.rule, 0, ' '};
+            try {
+                xray = configStringToInt(vars[1]);
+            } catch (...) {}
+        } else if (rule.rule.starts_with("animation")) {
+            CVarList vars{rule.rule, 2, 's'};
+            animationStyle = vars[1];
+        } else if (rule.rule.starts_with("order")) {
+            CVarList vars{rule.rule, 2, 's'};
+            try {
+                order = std::stoi(vars[1]);
+            } catch (...) { Debug::log(ERR, "Invalid value passed to order"); }
        }
    }
 }

 void CLayerSurface::startAnimation(bool in, bool instant) {
+    const auto ANIMSTYLE = animationStyle.value_or(realPosition.m_pConfig->pValues->internalStyle);
    if (in) {
-        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
-        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
-        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
+        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersIn");
+        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersIn");
+        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn");
    } else {
-        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
-        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
-        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut"));
+        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersOut");
+        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersOut");
+        alpha.m_pConfig        = 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();
@@ -490,9 +466,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;

@@ -517,11 +493,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")) {
@@ -540,25 +516,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)
@@ -569,7 +545,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() {
@@ -577,22 +553,10 @@ int CLayerSurface::popupsCount() {
        return 0;

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

 MONITORID CLayerSurface::monitorID() {
    return monitor ? monitor->ID : MONITOR_INVALID;
 }
-
-pid_t CLayerSurface::getPID() {
-    pid_t PID = -1;
-
-    if (!layerSurface || !layerSurface->surface || !layerSurface->surface->getResource() || !layerSurface->surface->getResource()->resource() ||
-        !layerSurface->surface->getResource()->resource()->client)
-        return -1;
-
-    wl_client_get_credentials(layerSurface->surface->getResource()->resource()->client, &PID, nullptr, nullptr);
-
-    return PID;
-}
--- a/src/desktop/LayerSurface.hpp
+++ b/src/desktop/LayerSurface.hpp
@@ -5,6 +5,11 @@
 #include "WLSurface.hpp"
 #include "../helpers/AnimatedVariable.hpp"

+struct SLayerRule {
+    std::string targetNamespace = "";
+    std::string rule            = "";
+};
+
 class CLayerShellResource;

 class CLayerSurface {
@@ -17,17 +22,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();

-    PHLANIMVAR<Vector2D>    realPosition;
-    PHLANIMVAR<Vector2D>    realSize;
-    PHLANIMVAR<float>       alpha;
+    CAnimatedVariable<Vector2D> realPosition;
+    CAnimatedVariable<Vector2D> realSize;
+    CAnimatedVariable<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;
@@ -59,9 +64,7 @@ class CLayerSurface {
    CBox                       geometry = {0, 0, 0, 0};
    Vector2D                   position;
    std::string                szNamespace = "";
-    UP<CPopup>                 popupHead;
-
-    pid_t                      getPID();
+    std::unique_ptr<CPopup>    popupHead;

    void                       onDestroy();
    void                       onMap();
--- a/src/desktop/Popup.cpp
+++ b/src/desktop/Popup.cpp
@@ -6,43 +6,27 @@
 #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>

-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(PHLWINDOW pOwner) : m_pWindowOwner(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(PHLLS pOwner) : m_pLayerOwner(pOwner) {
+    initAllSignals();
 }

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

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

-    popup->initAllSignals();
-    return popup;
+    m_vLastSize = popup->surface->current.geometry.size();
+    reposition();
+
+    initAllSignals();
 }

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

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

@@ -99,13 +82,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 = CSubsurface::create(m_pSelf);
+    m_pSubsurfaceHead = std::make_unique<CSubsurface>(this);

    //unconstrain();
    sendScale();
@@ -133,7 +116,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();

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

    // damage all children
    breadthfirst(
-        [](WP<CPopup> p, void* data) {
+        [](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);

-    // 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();
+    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) {
@@ -187,10 +169,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;
    }
@@ -240,7 +222,7 @@ Vector2D CPopup::coordsRelativeToParent() {
    if (!m_pResource)
        return {};

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

    while (current->m_pParent && current->m_pResource) {
@@ -264,16 +246,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() {
-    WP<CPopup> curr = m_pSelf;
+    CPopup* curr = this;
    while (curr->m_pParent) {
        curr = curr->m_pParent;
    }
@@ -282,11 +264,7 @@ void CPopup::recheckTree() {
 }

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

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

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

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

@@ -335,42 +313,35 @@ void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(W
        bfHelper(nodes2, fn, data);
 }

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

-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);
+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);

    for (auto const& p : popups | std::views::reverse) {
        if (!p->m_pResource || !p->m_bMapped)
            continue;

        if (!allowsInput) {
-            const bool HASSURFACE = p->m_pResource && p->m_pResource->surface;
+            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();

-            Vector2D   offset = HASSURFACE ? p->m_pResource->surface->current.geometry.pos() : Vector2D{};
-            Vector2D   size   = HASSURFACE ? p->m_pResource->surface->current.geometry.size() : p->size();
-
-            if (size == Vector2D{})
-                size = p->size();
-
-            const auto BOX = CBox{p->coordsGlobal() + offset, size};
+            const auto     BOX = CBox{p->coordsGlobal() + offset, size};
            if (BOX.containsPoint(globalCoords))
                return p;
        } else {
-            const auto REGION = CRegion{p->m_pWLSurface->resource()->current.input}.intersect(CBox{{}, p->m_pWLSurface->resource()->current.size}).translate(p->coordsGlobal());
+            const Vector2D offset = p->m_pResource ? (p->size() - p->m_pResource->geometry.size()) / 2.F : 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 {};
-}
-
-bool CPopup::inert() const {
-    return m_bInert;
+    return nullptr;
 }
--- 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
-    static UP<CPopup> create(PHLWINDOW pOwner);
-    static UP<CPopup> create(PHLLS pOwner);
+    CPopup(PHLWINDOW pOwner);
+    CPopup(PHLLS pOwner);

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

    ~CPopup();

@@ -34,26 +34,22 @@ class CPopup {
    void           recheckTree();

    bool           visible();
-    bool           inert() const;

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

    WP<CXDGPopupResource> m_pResource;

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

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

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

    Vector2D    localToGlobal(const Vector2D& rel);
    Vector2D    t1ParentCoords();
-    static void bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(WP<CPopup>, void*)> fn, void* data);
+    static void bfHelper(std::vector<CPopup*> const& nodes, std::function<void(CPopup*, void*)> fn, void* data);
 };
--- a/src/desktop/Rule.cpp
+++ b/src/desktop/Rule.cpp
@@ -1,22 +0,0 @@
-#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
@@ -1,21 +0,0 @@
-#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,50 +4,33 @@
 #include "../config/ConfigValue.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/core/Subcompositor.hpp"
-#include "../render/Renderer.hpp"
-#include "../managers/input/InputManager.hpp"

-UP<CSubsurface> CSubsurface::create(PHLWINDOW pOwner) {
-    auto subsurface             = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_pWindowParent = pOwner;
-    subsurface->m_pSelf         = subsurface;
-
-    subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
-    return subsurface;
+CSubsurface::CSubsurface(PHLWINDOW pOwner) : m_pWindowParent(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(CPopup* pOwner) : m_pPopupParent(pOwner) {
+    initSignals();
+    initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
 }

-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, 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, 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(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());
+}
+
+CSubsurface::~CSubsurface() {
+    ;
 }

 void CSubsurface::initSignals() {
@@ -107,7 +90,7 @@ void CSubsurface::onCommit() {

    g_pHyprRenderer->damageSurface(m_pWLSurface->resource(), COORDS.x, COORDS.y);

-    if (m_pPopupParent && !m_pPopupParent->inert() && m_pPopupParent->m_pWLSurface)
+    if (m_pPopupParent)
        m_pPopupParent->recheckTree();
    if (!m_pWindowParent.expired()) // I hate you firefox why are you doing this
        m_pWindowParent->m_pPopupHead->recheckTree();
@@ -116,20 +99,11 @@ void CSubsurface::onCommit() {
    checkSiblingDamage();

    if (m_vLastSize != m_pWLSurface->resource()->current.size) {
-        // TODO: fix this
-        // CBox box{COORDS, m_vLastSize};
-        // g_pHyprRenderer->damageBox(box);
-        // m_vLastSize = m_pWLSurface->resource()->current.size;
-        // box         = {COORDS, m_vLastSize};
-        // g_pHyprRenderer->damageBox(box);
-
-        CBox box;
-        if (m_pPopupParent && !m_pPopupParent->inert() && m_pPopupParent->m_pWLSurface)
-            box = m_pPopupParent->m_pWLSurface->getSurfaceBoxGlobal().value_or(CBox{});
-        else if (m_pWindowParent)
-            box = m_pWindowParent->getWindowMainSurfaceBox();
-
-        g_pHyprRenderer->damageBox(box);
+        CBox box{COORDS, m_vLastSize};
+        g_pHyprRenderer->damageBox(&box);
+        m_vLastSize = m_pWLSurface->resource()->current.size;
+        box         = {COORDS, m_vLastSize};
+        g_pHyprRenderer->damageBox(&box);
    }
 }

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

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

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

    ASSERT(PSUBSURFACE);

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

 void CSubsurface::onMap() {
@@ -167,7 +139,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();
@@ -177,7 +149,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();
@@ -197,7 +169,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,35 +10,31 @@ class CWLSubsurfaceResource;
 class CSubsurface {
  public:
    // root dummy nodes
-    static UP<CSubsurface> create(PHLWINDOW pOwner);
-    static UP<CSubsurface> create(WP<CPopup> pOwner);
+    CSubsurface(PHLWINDOW pOwner);
+    CSubsurface(CPopup* pOwner);

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

-    ~CSubsurface() = default;
+    ~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();
-
-    WP<CSubsurface> m_pSelf;
+    void     recheckDamageForSubsurfaces();

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

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

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

-    std::vector<UP<CSubsurface>> m_vChildren;
+    std::vector<std::unique_ptr<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,9 +1,7 @@
 #include "WLSurface.hpp"
-#include "LayerSurface.hpp"
-#include "../desktop/Window.hpp"
+#include "../Compositor.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/LayerShell.hpp"
-#include "../render/Renderer.hpp"

 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface) {
    m_pResource = pSurface;
@@ -74,7 +72,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 {
@@ -98,7 +96,7 @@ CRegion CWLSurface::computeDamage() const {
    if (!m_pResource->current.texture)
        return {};

-    CRegion damage = m_pResource->current.accumulateBufferDamage();
+    CRegion damage = m_pResource->accumulateCurrentBufferDamage();
    damage.transform(wlTransformToHyprutils(m_pResource->current.transform), m_pResource->current.bufferSize.x, m_pResource->current.bufferSize.y);

    const auto BUFSIZE    = m_pResource->current.bufferSize;
--- a/src/desktop/WLSurface.hpp
+++ b/src/desktop/WLSurface.hpp
@@ -84,11 +84,7 @@ class CWLSurface {
    static SP<CWLSurface> fromResource(SP<CWLSurfaceResource> pSurface);

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

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

    friend class CPointerConstraint;
-    friend class CXxColorManagerV4;
-};
+};
--- a/src/desktop/Window.cpp
+++ b/src/desktop/Window.cpp
--- a/src/desktop/Window.hpp
+++ b/src/desktop/Window.hpp
@@ -1,10 +1,10 @@
 #pragma once

-#include <vector>
+#include <deque>
 #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,26 +12,23 @@
 #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"
 #include "WLSurface.hpp"
 #include "Workspace.hpp"
-#include "WindowRule.hpp"
-#include "../protocols/types/ContentType.hpp"

 class CXDGSurfaceResource;
 class CXWaylandSurface;

-enum eIdleInhibitMode : uint8_t {
+enum eIdleInhibitMode {
    IDLEINHIBIT_NONE = 0,
    IDLEINHIBIT_ALWAYS,
    IDLEINHIBIT_FULLSCREEN,
    IDLEINHIBIT_FOCUS
 };

-enum eGroupRules : uint8_t {
+enum eGroupRules {
    // effective only during first map, except for _ALWAYS variant
    GROUP_NONE        = 0,
    GROUP_SET         = 1 << 0, // Open as new group or add to focused group
@@ -43,7 +40,7 @@ enum eGroupRules : uint8_t {
    GROUP_OVERRIDE    = 1 << 6, // Override other rules
 };

-enum eGetWindowProperties : uint8_t {
+enum eGetWindowProperties {
    WINDOW_ONLY      = 0,
    RESERVED_EXTENTS = 1 << 0,
    INPUT_EXTENTS    = 1 << 1,
@@ -53,13 +50,12 @@ enum eGetWindowProperties : uint8_t {
    USE_PROP_TILED   = 1 << 5,
 };

-enum eSuppressEvents : uint8_t {
+enum eSuppressEvents {
    SUPPRESS_NONE               = 0,
    SUPPRESS_FULLSCREEN         = 1 << 0,
    SUPPRESS_MAXIMIZE           = 1 << 1,
    SUPPRESS_ACTIVATE           = 1 << 2,
    SUPPRESS_ACTIVATE_FOCUSONLY = 1 << 3,
-    SUPPRESS_FULLSCREEN_OUTPUT  = 1 << 4,
 };

 class IWindowTransformer;
@@ -68,7 +64,7 @@ struct SAlphaValue {
    float m_fAlpha;
    bool  m_bOverride;

-    float applyAlpha(float alpha) const {
+    float applyAlpha(float alpha) {
        if (m_bOverride)
            return m_fAlpha;
        else
@@ -76,8 +72,8 @@ struct SAlphaValue {
    };
 };

-enum eOverridePriority : uint8_t {
-    PRIORITY_LAYOUT = 0,
+enum eOverridePriority {
+    PRIORITY_LAYOUT,
    PRIORITY_WORKSPACE_RULE,
    PRIORITY_WINDOW_RULE,
    PRIORITY_SET_PROP,
@@ -89,7 +85,9 @@ class CWindowOverridableVar {
    CWindowOverridableVar(T const& value, eOverridePriority priority) {
        values[priority] = value;
    }
-    CWindowOverridableVar(T const& value) : defaultValue{value} {}
+    CWindowOverridableVar(T const& value) {
+        defaultValue = value;
+    }

    CWindowOverridableVar()  = default;
    ~CWindowOverridableVar() = default;
@@ -186,20 +184,34 @@ struct SWindowData {
    CWindowOverridableVar<bool>               renderUnfocused    = false;

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

-    CWindowOverridableVar<float>              scrollMouse;
-    CWindowOverridableVar<float>              scrollTouchpad;
-
    CWindowOverridableVar<std::string>        animationStyle;
    CWindowOverridableVar<Vector2D>           maxSize;
    CWindowOverridableVar<Vector2D>           minSize;

    CWindowOverridableVar<CGradientValueData> activeBorderColor;
    CWindowOverridableVar<CGradientValueData> inactiveBorderColor;
+};

-    CWindowOverridableVar<bool>               persistentSize;
+struct SWindowRule {
+    std::string szRule;
+    std::string szValue;
+
+    bool        v2 = false;
+    std::string szTitle;
+    std::string szClass;
+    std::string szInitialTitle;
+    std::string szInitialClass;
+    std::string szTag;
+    int         bX11              = -1; // -1 means "ANY"
+    int         bFloating         = -1;
+    int         bFullscreen       = -1;
+    int         bPinned           = -1;
+    int         bFocus            = -1;
+    std::string szFullscreenState = ""; // empty means any
+    std::string szOnWorkspace     = ""; // empty means any
+    std::string szWorkspace       = ""; // empty means any
 };

 struct SInitialWorkspaceToken {
@@ -207,7 +219,7 @@ struct SInitialWorkspaceToken {
    std::string  workspace;
 };

-struct SFullscreenState {
+struct sFullscreenState {
    eFullscreenMode internal = FSMODE_NONE;
    eFullscreenMode client   = FSMODE_NONE;
 };
@@ -238,8 +250,8 @@ class CWindow {
    Vector2D m_vSize     = Vector2D(0, 0);

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

    // for not spamming the protocols
    Vector2D                                     m_vReportedPosition;
@@ -266,7 +278,7 @@ class CWindow {
    bool             m_bIsFloating      = false;
    bool             m_bDraggingTiled   = false; // for dragging around tiled windows
    bool             m_bWasMaximized    = false;
-    SFullscreenState m_sFullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
+    sFullscreenState m_sFullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
    std::string      m_szTitle          = "";
    std::string      m_szClass          = "";
    std::string      m_szInitialTitle   = "";
@@ -293,37 +305,33 @@ class CWindow {
    bool m_bNoInitialFocus = false;

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

    // bitfield eSuppressEvents
    uint64_t m_eSuppressedEvents = SUPPRESS_NONE;

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

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

    // Fade in-out
-    PHLANIMVAR<float> m_fAlpha;
-    bool              m_bFadingOut     = false;
-    bool              m_bReadyToDelete = false;
-    Vector2D          m_vOriginalClosedPos;  // these will be used for calculations later on in
-    Vector2D          m_vOriginalClosedSize; // drawing the closing animations
-    SBoxExtents       m_eOriginalClosedExtents;
-    bool              m_bAnimatingIn = false;
+    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;

    // For pinned (sticky) windows
    bool m_bPinned = false;

-    // For preserving pinned state when fullscreening a pinned window
-    bool m_bPinFullscreened = false;
-
    // urgency hint
    bool m_bIsUrgent = false;

@@ -332,33 +340,31 @@ class CWindow {

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

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

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

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

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

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

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

    // swallowing
    PHLWINDOWREF m_pSwallowed;
-    bool         m_bCurrentlySwallowed = false;
-    bool         m_bGroupSwallowed     = false;
+    bool         m_bGroupSwallowed = false;

    // focus stuff
    bool m_bStayFocused = false;
@@ -385,110 +391,94 @@ class CWindow {
    bool     m_bTearingHint = false;

    // stores the currently matched window rules
-    std::vector<SP<CWindowRule>> m_vMatchedRules;
+    std::vector<SWindowRule> m_vMatchedRules;

    // window tags
    CTagKeeper m_tags;

-    // ANR
-    PHLANIMVAR<float> m_notRespondingTint;
-
    // For the list lookup
-    bool operator==(const CWindow& rhs) const {
+    bool operator==(const CWindow& rhs) {
        return m_pXDGSurface == rhs.m_pXDGSurface && m_pXWaylandSurface == rhs.m_pXWaylandSurface && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize &&
            m_bFadingOut == rhs.m_bFadingOut;
    }

    // methods
-    CBox                       getFullWindowBoundingBox();
-    SBoxExtents                getFullWindowExtents();
-    CBox                       getWindowBoxUnified(uint64_t props);
-    CBox                       getWindowIdealBoundingBoxIgnoreReserved();
-    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                       updateToplevel();
-    void                       updateSurfaceScaleTransformDetails(bool force = false);
-    void                       moveToWorkspace(PHLWORKSPACE);
-    PHLWINDOW                  x11TransientFor();
-    void                       onUnmap();
-    void                       onMap();
-    void                       setHidden(bool hidden);
-    bool                       isHidden();
-    void                       applyDynamicRule(const SP<CWindowRule>& r);
-    void                       updateDynamicRules();
-    SBoxExtents                getFullWindowReservedArea();
-    Vector2D                   middle();
-    bool                       opaque();
-    float                      rounding();
-    float                      roundingPower();
-    bool                       canBeTorn();
-    void                       setSuspended(bool suspend);
-    bool                       visibleOnMonitor(PHLMONITOR pMonitor);
-    WORKSPACEID                workspaceID();
-    MONITORID                  monitorID();
-    bool                       onSpecialWorkspace();
-    void                       activate(bool force = false);
-    int                        surfacesCount();
-    void                       clampWindowSize(const std::optional<Vector2D> minSize, const std::optional<Vector2D> maxSize);
-    bool                       isFullscreen();
-    bool                       isEffectiveInternalFSMode(const eFullscreenMode);
-    int                        getRealBorderSize();
-    float                      getScrollMouse();
-    float                      getScrollTouchpad();
-    void                       updateWindowData();
-    void                       updateWindowData(const struct SWorkspaceRule&);
-    void                       onBorderAngleAnimEnd(WP<Hyprutils::Animation::CBaseAnimatedVariable> pav);
-    bool                       isInCurvedCorner(double x, double y);
-    bool                       hasPopupAt(const Vector2D& pos);
-    int                        popupsCount();
-    void                       applyGroupRules();
-    void                       createGroup();
-    void                       destroyGroup();
-    PHLWINDOW                  getGroupHead();
-    PHLWINDOW                  getGroupTail();
-    PHLWINDOW                  getGroupCurrent();
-    PHLWINDOW                  getGroupPrevious();
-    PHLWINDOW                  getGroupWindowByIndex(int);
-    int                        getGroupSize();
-    bool                       canBeGroupedInto(PHLWINDOW pWindow);
-    void                       setGroupCurrent(PHLWINDOW pWindow);
-    void                       insertWindowToGroup(PHLWINDOW pWindow);
-    void                       updateGroupOutputs();
-    void                       switchWithWindowInGroup(PHLWINDOW pWindow);
-    void                       setAnimationsToMove();
-    void                       onWorkspaceAnimUpdate();
-    void                       onFocusAnimUpdate();
-    void                       onUpdateState();
-    void                       onUpdateMeta();
-    void                       onX11ConfigureRequest(CBox box);
-    void                       onResourceChangeX11();
-    std::string                fetchTitle();
-    std::string                fetchClass();
-    void                       warpCursor(bool force = false);
-    PHLWINDOW                  getSwallower();
-    void                       unsetWindowData(eOverridePriority priority);
-    bool                       isX11OverrideRedirect();
-    bool                       isModal();
-    Vector2D                   requestedMinSize();
-    Vector2D                   requestedMaxSize();
-    Vector2D                   realToReportSize();
-    Vector2D                   realToReportPosition();
-    Vector2D                   xwaylandSizeToReal(Vector2D size);
-    Vector2D                   xwaylandPositionToReal(Vector2D size);
-    void                       updateX11SurfaceScale();
-    void                       sendWindowSize(bool force = false);
-    NContentType::eContentType getContentType();
-    void                       setContentType(NContentType::eContentType contentType);
-    void                       deactivateGroupMembers();
-    bool                       isNotResponding();
+    CBox                   getFullWindowBoundingBox();
+    SBoxExtents            getFullWindowExtents();
+    CBox                   getWindowBoxUnified(uint64_t props);
+    CBox                   getWindowIdealBoundingBoxIgnoreReserved();
+    void                   addWindowDeco(std::unique_ptr<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);
+    PHLWINDOW              X11TransientFor();
+    void                   onUnmap();
+    void                   onMap();
+    void                   setHidden(bool hidden);
+    bool                   isHidden();
+    void                   applyDynamicRule(const SWindowRule& r);
+    void                   updateDynamicRules();
+    SBoxExtents            getFullWindowReservedArea();
+    Vector2D               middle();
+    bool                   opaque();
+    float                  rounding();
+    bool                   canBeTorn();
+    void                   setSuspended(bool suspend);
+    bool                   visibleOnMonitor(PHLMONITOR pMonitor);
+    WORKSPACEID            workspaceID();
+    MONITORID              monitorID();
+    bool                   onSpecialWorkspace();
+    void                   activate(bool force = false);
+    int                    surfacesCount();
+    void                   clampWindowSize(const std::optional<Vector2D> minSize, const std::optional<Vector2D> maxSize);
+    bool                   isFullscreen();
+    bool                   isEffectiveInternalFSMode(const eFullscreenMode);
+    int                    getRealBorderSize();
+    void                   updateWindowData();
+    void                   updateWindowData(const struct SWorkspaceRule&);
+    void                   onBorderAngleAnimEnd(void* ptr);
+    bool                   isInCurvedCorner(double x, double y);
+    bool                   hasPopupAt(const Vector2D& pos);
+    int                    popupsCount();
+    void                   applyGroupRules();
+    void                   createGroup();
+    void                   destroyGroup();
+    PHLWINDOW              getGroupHead();
+    PHLWINDOW              getGroupTail();
+    PHLWINDOW              getGroupCurrent();
+    PHLWINDOW              getGroupPrevious();
+    PHLWINDOW              getGroupWindowByIndex(int);
+    int                    getGroupSize();
+    bool                   canBeGroupedInto(PHLWINDOW pWindow);
+    void                   setGroupCurrent(PHLWINDOW pWindow);
+    void                   insertWindowToGroup(PHLWINDOW pWindow);
+    void                   updateGroupOutputs();
+    void                   switchWithWindowInGroup(PHLWINDOW pWindow);
+    void                   setAnimationsToMove();
+    void                   onWorkspaceAnimUpdate();
+    void                   onUpdateState();
+    void                   onUpdateMeta();
+    void                   onX11Configure(CBox box);
+    void                   onResourceChangeX11();
+    std::string            fetchTitle();
+    std::string            fetchClass();
+    void                   warpCursor();
+    PHLWINDOW              getSwallower();
+    void                   unsetWindowData(eOverridePriority priority);
+    bool                   isX11OverrideRedirect();
+    bool                   isModal();
+    Vector2D               requestedMinSize();
+    Vector2D               requestedMaxSize();

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

    // listeners
@@ -508,7 +498,7 @@ class CWindow {
        CHyprSignalListener commit;
        CHyprSignalListener destroy;
        CHyprSignalListener activate;
-        CHyprSignalListener configureRequest;
+        CHyprSignalListener configure;
        CHyprSignalListener setGeometry;
        CHyprSignalListener updateState;
        CHyprSignalListener updateMetadata;
@@ -542,42 +532,6 @@ inline bool validMapped(PHLWINDOWREF w) {
    return w->m_bIsMapped;
 }

-namespace NWindowProperties {
-    static const std::unordered_map<std::string, std::function<CWindowOverridableVar<bool>*(const PHLWINDOW&)>> boolWindowProperties = {
-        {"allowsinput", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.allowsInput; }},
-        {"dimaround", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.dimAround; }},
-        {"decorate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.decorate; }},
-        {"focusonactivate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.focusOnActivate; }},
-        {"keepaspectratio", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.keepAspectRatio; }},
-        {"nearestneighbor", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.nearestNeighbor; }},
-        {"noanim", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noAnim; }},
-        {"noblur", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noBlur; }},
-        {"noborder", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noBorder; }},
-        {"nodim", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noDim; }},
-        {"nofocus", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noFocus; }},
-        {"nomaxsize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noMaxSize; }},
-        {"norounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noRounding; }},
-        {"noshadow", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noShadow; }},
-        {"noshortcutsinhibit", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noShortcutsInhibit; }},
-        {"opaque", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.opaque; }},
-        {"forcergbx", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.RGBX; }},
-        {"syncfullscreen", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.syncFullscreen; }},
-        {"immediate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.tearing; }},
-        {"xray", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.xray; }},
-    };
-
-    const std::unordered_map<std::string, std::function<CWindowOverridableVar<int>*(const PHLWINDOW&)>> intWindowProperties = {
-        {"rounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.rounding; }},
-        {"bordersize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.borderSize; }},
-    };
-
-    const std::unordered_map<std::string, std::function<CWindowOverridableVar<float>*(PHLWINDOW)>> floatWindowProperties = {
-        {"roundingpower", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.roundingPower; }},
-        {"scrollmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.scrollMouse; }},
-        {"scrolltouchpad", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.scrollTouchpad; }},
-    };
-};
-
 /**
    format specification
    - 'x', only address, equivalent of (uintpr_t)CWindow*
--- a/src/desktop/WindowRule.cpp
+++ b/src/desktop/WindowRule.cpp
@@ -1,96 +0,0 @@
-#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", "persistentsize",
-};
-static const auto RULES_PREFIX = std::unordered_set<std::string>{
-    "animation", "bordercolor",   "bordersize", "center",    "content", "fullscreenstate", "group",    "idleinhibit",   "maxsize",     "minsize",
-    "monitor",   "move",          "opacity",    "plugin:",   "prop",    "pseudo",          "rounding", "roundingpower", "scrollmouse", "scrolltouchpad",
-    "size",      "suppressevent", "tag",        "workspace", "xray",
-};
-
-CWindowRule::CWindowRule(const std::string& rule, const std::string& value, bool isV2, bool isExecRule) : szValue(value), szRule(rule), v2(isV2), execRule(isExecRule) {
-    const auto VALS  = CVarList(rule, 2, ' ');
-    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule](auto prefix) { return rule.starts_with(prefix); }) ||
-        (NWindowProperties::boolWindowProperties.find(VALS[0]) != NWindowProperties::boolWindowProperties.end()) ||
-        (NWindowProperties::intWindowProperties.find(VALS[0]) != NWindowProperties::intWindowProperties.end()) ||
-        (NWindowProperties::floatWindowProperties.find(VALS[0]) != NWindowProperties::floatWindowProperties.end());
-
-    if (!VALID)
-        return;
-
-    if (rule == "float")
-        ruleType = RULE_FLOAT;
-    else if (rule == "fullscreen")
-        ruleType = RULE_FULLSCREEN;
-    else if (rule == "maximize")
-        ruleType = RULE_MAXIMIZE;
-    else if (rule == "noinitialfocus")
-        ruleType = RULE_NOINITIALFOCUS;
-    else if (rule == "pin")
-        ruleType = RULE_PIN;
-    else if (rule == "stayfocused")
-        ruleType = RULE_STAYFOCUSED;
-    else if (rule == "tile")
-        ruleType = RULE_TILE;
-    else if (rule == "renderunfocused")
-        ruleType = RULE_RENDERUNFOCUSED;
-    else if (rule == "persistentsize")
-        ruleType = RULE_PERSISTENTSIZE;
-    else if (rule.starts_with("animation"))
-        ruleType = RULE_ANIMATION;
-    else if (rule.starts_with("bordercolor"))
-        ruleType = RULE_BORDERCOLOR;
-    else if (rule.starts_with("center"))
-        ruleType = RULE_CENTER;
-    else if (rule.starts_with("fullscreenstate"))
-        ruleType = RULE_FULLSCREENSTATE;
-    else if (rule.starts_with("group"))
-        ruleType = RULE_GROUP;
-    else if (rule.starts_with("idleinhibit"))
-        ruleType = RULE_IDLEINHIBIT;
-    else if (rule.starts_with("maxsize"))
-        ruleType = RULE_MAXSIZE;
-    else if (rule.starts_with("minsize"))
-        ruleType = RULE_MINSIZE;
-    else if (rule.starts_with("monitor"))
-        ruleType = RULE_MONITOR;
-    else if (rule.starts_with("move"))
-        ruleType = RULE_MOVE;
-    else if (rule.starts_with("opacity"))
-        ruleType = RULE_OPACITY;
-    else if (rule.starts_with("plugin:"))
-        ruleType = RULE_PLUGIN;
-    else if (rule.starts_with("pseudo"))
-        ruleType = RULE_PSEUDO;
-    else if (rule.starts_with("size"))
-        ruleType = RULE_SIZE;
-    else if (rule.starts_with("suppressevent"))
-        ruleType = RULE_SUPPRESSEVENT;
-    else if (rule.starts_with("tag"))
-        ruleType = RULE_TAG;
-    else if (rule.starts_with("workspace"))
-        ruleType = RULE_WORKSPACE;
-    else if (rule.starts_with("prop"))
-        ruleType = RULE_PROP;
-    else if (rule.starts_with("content"))
-        ruleType = RULE_CONTENT;
-    else {
-        // check if this is a prop.
-        const CVarList VARS(rule, 0, 's', true);
-        if (NWindowProperties::intWindowProperties.find(VARS[0]) != NWindowProperties::intWindowProperties.end() ||
-            NWindowProperties::boolWindowProperties.find(VARS[0]) != NWindowProperties::boolWindowProperties.end() ||
-            NWindowProperties::floatWindowProperties.find(VARS[0]) != NWindowProperties::floatWindowProperties.end()) {
-            *const_cast<std::string*>(&szRule) = "prop " + rule;
-            ruleType                           = RULE_PROP;
-            Debug::log(LOG, "CWindowRule: direct prop rule found, rewritten {} -> {}", rule, szRule);
-        } else {
-            Debug::log(ERR, "CWindowRule: didn't match a rule that was found valid?!");
-            ruleType = RULE_INVALID;
-        }
-    }
-}
--- a/src/desktop/WindowRule.hpp
+++ b/src/desktop/WindowRule.hpp
@@ -1,71 +0,0 @@
-#pragma once
-
-#include <string>
-#include <cstdint>
-#include "Rule.hpp"
-
-class CWindowRule {
-  public:
-    CWindowRule(const std::string& rule, const std::string& value, bool isV2 = false, bool isExecRule = false);
-
-    enum eRuleType : uint8_t {
-        RULE_INVALID = 0,
-        RULE_FLOAT,
-        RULE_FULLSCREEN,
-        RULE_MAXIMIZE,
-        RULE_NOINITIALFOCUS,
-        RULE_PIN,
-        RULE_STAYFOCUSED,
-        RULE_TILE,
-        RULE_RENDERUNFOCUSED,
-        RULE_ANIMATION,
-        RULE_BORDERCOLOR,
-        RULE_CENTER,
-        RULE_FULLSCREENSTATE,
-        RULE_GROUP,
-        RULE_IDLEINHIBIT,
-        RULE_MAXSIZE,
-        RULE_MINSIZE,
-        RULE_MONITOR,
-        RULE_MOVE,
-        RULE_OPACITY,
-        RULE_PLUGIN,
-        RULE_PSEUDO,
-        RULE_SIZE,
-        RULE_SUPPRESSEVENT,
-        RULE_TAG,
-        RULE_WORKSPACE,
-        RULE_PROP,
-        RULE_CONTENT,
-        RULE_PERSISTENTSIZE,
-    };
-
-    eRuleType         ruleType = RULE_INVALID;
-
-    const std::string szValue;
-    const std::string szRule;
-    const bool        v2       = false;
-    const bool        execRule = false;
-
-    std::string       szTitle;
-    std::string       szClass;
-    std::string       szInitialTitle;
-    std::string       szInitialClass;
-    std::string       szTag;
-    int               bX11              = -1; // -1 means "ANY"
-    int               bFloating         = -1;
-    int               bFullscreen       = -1;
-    int               bPinned           = -1;
-    int               bFocus            = -1;
-    std::string       szFullscreenState = ""; // empty means any
-    std::string       szOnWorkspace     = ""; // empty means any
-    std::string       szWorkspace       = ""; // empty means any
-    std::string       szContentType     = ""; // empty means any
-
-    // precompiled regexes
-    CRuleRegexContainer rTitle;
-    CRuleRegexContainer rClass;
-    CRuleRegexContainer rInitialTitle;
-    CRuleRegexContainer rInitialClass;
-    CRuleRegexContainer rV1Regex;
-};
--- a/src/desktop/Workspace.cpp
+++ b/src/desktop/Workspace.cpp
@@ -1,12 +1,7 @@
 #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;

@@ -16,18 +11,27 @@ PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string
    return workspace;
 }

-CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) :
-    m_iID(id), m_szName(name), m_pMonitor(monitor), m_bIsSpecialWorkspace(special), m_bWasCreatedEmpty(isEmpty) {
-    ;
+CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) {
+    m_pMonitor            = monitor;
+    m_iID                 = id;
+    m_szName              = name;
+    m_bIsSpecialWorkspace = special;
+    m_bWasCreatedEmpty    = isEmpty;
 }

 void CWorkspace::init(PHLWORKSPACE self) {
    m_pSelf = self;

-    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_vRenderOffset,
-                                         g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(1.f, m_fAlpha, g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
-                                         AVARDAMAGE_ENTIRE);
+    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();

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

-SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const {
+SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName(bool perMonitor) const {
+    if (perMonitor)
+        return m_sPrevWorkspacePerMonitor;
+
    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.
@@ -76,15 +85,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->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
-        m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig(ANIMNAME);
+        m_vRenderOffset.m_pConfig = g_pConfigManager->getAnimationPropertyConfig(ANIMNAME);
    }

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

    // set floating windows offset callbacks
-    m_vRenderOffset->setUpdateCallback([&](auto) {
+    m_vRenderOffset.setUpdateCallback([&](void*) {
        for (auto const& w : g_pCompositor->m_vWindows) {
            if (!validMapped(w) || w->workspaceID() != m_iID)
                continue;
@@ -97,91 +106,91 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
        const auto PMONITOR = m_pMonitor.lock();
        float      movePerc = 100.f;

-        if (ANIMSTYLE.find('%') != std::string::npos) {
+        if (ANIMSTYLE.find("%") != std::string::npos) {
            try {
                auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' ') + 1);
                movePerc     = std::stoi(percstr.substr(0, percstr.length() - 1));
            } 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();
    }
 }

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

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

 std::string CWorkspace::getConfigName() {
@@ -261,15 +273,14 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
            // n - named: n[true] or n[s:string] or n[e:string]
            // m - monitor: m[monitor_selector]
            // w - windowCount: w[1-4] or w[1], optional flag t or f for tiled or floating and
-            //                  flag p to count only pinned windows, e.g. w[p1-2], w[pg4]
            //                  flag g to count groups instead of windows, e.g. w[t1-2], w[fg4]
            //                  flag v will count only visible windows
            // f - fullscreen state : f[-1], f[0], f[1], or f[2] for different fullscreen states
            //                        -1: no fullscreen, 0: fullscreen, 1: maximized, 2: fullscreen without sending fs state to window

-            const auto  CLOSING_BRACKET = selector.find_first_of(']', i);
-            std::string prop            = selector.substr(i, CLOSING_BRACKET == std::string::npos ? std::string::npos : CLOSING_BRACKET + 1 - i);
-            i                           = std::min(CLOSING_BRACKET, std::string::npos - 1);
+            const auto  NEXTSPACE = selector.find_first_of(' ', i);
+            std::string prop      = selector.substr(i, NEXTSPACE == std::string::npos ? std::string::npos : NEXTSPACE - i);
+            i                     = std::min(NEXTSPACE, std::string::npos - 1);

            if (cur == 'r') {
                WORKSPACEID from = 0, to = 0;
@@ -285,7 +296,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                    return false;
                }

-                const auto DASHPOS = prop.find('-');
+                const auto DASHPOS = prop.find("-");
                const auto LHS = prop.substr(0, DASHPOS), RHS = prop.substr(DASHPOS + 1);

                if (!isNumber(LHS) || !isNumber(RHS)) {
@@ -321,7 +332,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {

                const auto SHOULDBESPECIAL = configStringToInt(prop);

-                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_bIsSpecialWorkspace)
+                if ((bool)SHOULDBESPECIAL != m_bIsSpecialWorkspace)
                    return false;
                continue;
            }
@@ -356,7 +367,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {

                const auto WANTSNAMED = configStringToInt(prop);

-                if (WANTSNAMED && *WANTSNAMED != (m_iID <= -1337))
+                if (WANTSNAMED != (m_iID <= -1337))
                    return false;
                continue;
            }
@@ -371,7 +382,6 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                prop = prop.substr(2, prop.length() - 3);

                int  wantsOnlyTiled    = -1;
-                int  wantsOnlyPinned   = false;
                bool wantsCountGroup   = false;
                bool wantsCountVisible = false;

@@ -383,9 +393,6 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                    } else if (flag == 'f' && wantsOnlyTiled == -1) {
                        wantsOnlyTiled = 0;
                        flagCount++;
-                    } else if (flag == 'p' && !wantsOnlyPinned) {
-                        wantsOnlyPinned = true;
-                        flagCount++;
                    } else if (flag == 'g' && !wantsCountGroup) {
                        wantsCountGroup = true;
                        flagCount++;
@@ -415,20 +422,18 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {

                    int count;
                    if (wantsCountGroup)
-                        count = getGroups(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                          wantsOnlyPinned ? std::optional<bool>(wantsOnlyPinned) : std::nullopt,
-                                          wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                        count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                    wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
                    else
-                        count = getWindows(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                           wantsOnlyPinned ? std::optional<bool>(wantsOnlyPinned) : std::nullopt,
-                                           wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                        count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                     wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);

                    if (count != from)
                        return false;
                    continue;
                }

-                const auto DASHPOS = prop.find('-');
+                const auto DASHPOS = prop.find("-");
                const auto LHS = prop.substr(0, DASHPOS), RHS = prop.substr(DASHPOS + 1);

                if (!isNumber(LHS) || !isNumber(RHS)) {
@@ -451,13 +456,11 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {

                WORKSPACEID count;
                if (wantsCountGroup)
-                    count =
-                        getGroups(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                  wantsOnlyPinned ? std::optional<bool>(wantsOnlyPinned) : std::nullopt, wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                    count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
                else
-                    count = getWindows(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                       wantsOnlyPinned ? std::optional<bool>(wantsOnlyPinned) : std::nullopt,
-                                       wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                    count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                 wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);

                if (std::clamp(count, from, to) != count)
                    return false;
@@ -522,148 +525,3 @@ bool CWorkspace::inert() {
 MONITORID CWorkspace::monitorID() {
    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
 }
-
-PHLWINDOW CWorkspace::getFullscreenWindow() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace == m_pSelf && w->isFullscreen())
-            return w;
-    }
-
-    return nullptr;
-}
-
-bool CWorkspace::isVisible() {
-    return m_bVisible;
-}
-
-bool CWorkspace::isVisibleNotCovered() {
-    const auto PMONITOR = m_pMonitor.lock();
-    if (PMONITOR->activeSpecialWorkspace)
-        return PMONITOR->activeSpecialWorkspace->m_iID == m_iID;
-
-    return PMONITOR->activeWorkspace->m_iID == m_iID;
-}
-
-int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
-    int no = 0;
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
-            continue;
-        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
-            continue;
-        if (onlyPinned.has_value() && w->m_bPinned != onlyPinned.value())
-            continue;
-        if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
-            continue;
-        no++;
-    }
-
-    return no;
-}
-
-int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
-    int no = 0;
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
-            continue;
-        if (!w->m_sGroupData.head)
-            continue;
-        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
-            continue;
-        if (onlyPinned.has_value() && w->m_bPinned != onlyPinned.value())
-            continue;
-        if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
-            continue;
-        no++;
-    }
-    return no;
-}
-
-PHLWINDOW CWorkspace::getFirstWindow() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && !w->isHidden())
-            return w;
-    }
-
-    return nullptr;
-}
-
-PHLWINDOW CWorkspace::getTopLeftWindow() {
-    const auto PMONITOR = m_pMonitor.lock();
-
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
-            continue;
-
-        const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
-
-        if (WINDOWIDEALBB.x <= PMONITOR->vecPosition.x + 1 && WINDOWIDEALBB.y <= PMONITOR->vecPosition.y + 1)
-            return w;
-    }
-    return nullptr;
-}
-
-bool CWorkspace::hasUrgentWindow() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && w->m_bIsUrgent)
-            return true;
-    }
-
-    return false;
-}
-
-void CWorkspace::updateWindowDecos() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf)
-            continue;
-
-        w->updateWindowDecos();
-    }
-}
-
-void CWorkspace::updateWindowData() {
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
-
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf)
-            continue;
-
-        w->updateWindowData(WORKSPACERULE);
-    }
-}
-
-void CWorkspace::forceReportSizesToWindows() {
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
-            continue;
-
-        w->sendWindowSize(true);
-    }
-}
-
-void CWorkspace::rename(const std::string& name) {
-    if (g_pCompositor->isWorkspaceSpecial(m_iID))
-        return;
-
-    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_iID, name);
-    m_szName = name;
-
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
-    m_bPersistent            = WORKSPACERULE.isPersistent;
-
-    if (WORKSPACERULE.isPersistent)
-        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_pSelf.lock());
-
-    g_pEventManager->postEvent({"renameworkspace", std::to_string(m_iID) + "," + m_szName});
-}
-
-void CWorkspace::updateWindows() {
-    m_bHasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_vWindows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_pSelf && w->isFullscreen(); });
-
-    for (auto const& w : g_pCompositor->m_vWindows) {
-        if (!w->m_bIsMapped || w->m_pWorkspace != m_pSelf)
-            continue;
-
-        w->updateDynamicRules();
-    }
-}
--- a/src/desktop/Workspace.hpp
+++ b/src/desktop/Workspace.hpp
@@ -24,19 +24,22 @@ class CWorkspace {

    // Workspaces ID-based have IDs > 0
    // and workspaces name-based have IDs starting with -1337
-    WORKSPACEID     m_iID    = WORKSPACE_INVALID;
-    std::string     m_szName = "";
-    PHLMONITORREF   m_pMonitor;
+    WORKSPACEID   m_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;

-    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
-    PHLANIMVAR<Vector2D> m_vRenderOffset;
-    PHLANIMVAR<float>    m_fAlpha;
-    bool                 m_bForceRendering = false;
+    CAnimatedVariable<Vector2D> m_vRenderOffset;
+    CAnimatedVariable<float>    m_fAlpha;
+    bool                        m_bForceRendering = false;

    // allows damage to propagate.
    bool m_bVisible = false;
@@ -60,35 +63,26 @@ class CWorkspace {

    // Inert: destroyed and invalid. If this is true, release the ptr you have.
    bool             inert();
+
    void             startAnim(bool in, bool left, bool instant = false);
    void             setActive(bool on);
+
    void             moveToMonitor(const MONITORID&);
    MONITORID        monitorID();
+
    PHLWINDOW        getLastFocusedWindow();
    void             rememberPrevWorkspace(const PHLWORKSPACE& prevWorkspace);
+
    std::string      getConfigName();
+
    bool             matchesStaticSelector(const std::string& selector);
+
    void             markInert();
-    SWorkspaceIDName getPrevWorkspaceIDName() const;
-    void             updateWindowDecos();
-    void             updateWindowData();
-    int              getWindows(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyPinned = {}, std::optional<bool> onlyVisible = {});
-    int              getGroups(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyPinned = {}, std::optional<bool> onlyVisible = {});
-    bool             hasUrgentWindow();
-    PHLWINDOW        getFirstWindow();
-    PHLWINDOW        getTopLeftWindow();
-    PHLWINDOW        getFullscreenWindow();
-    bool             isVisible();
-    bool             isVisibleNotCovered();
-    void             rename(const std::string& name = "");
-    void             forceReportSizesToWindows();
-    void             updateWindows();
+
+    SWorkspaceIDName getPrevWorkspaceIDName(bool perMonitor) const;

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

    SP<HOOK_CALLBACK_FN> m_pFocusedWindowHook;
    bool                 m_bInert = true;
--- a/src/devices/IHID.hpp
+++ b/src/devices/IHID.hpp
@@ -4,14 +4,14 @@
 #include <string>
 #include "../helpers/signal/Signal.hpp"

-enum eHIDCapabilityType : uint8_t {
+enum eHIDCapabilityType : uint32_t {
    HID_INPUT_CAPABILITY_KEYBOARD = (1 << 0),
    HID_INPUT_CAPABILITY_POINTER  = (1 << 1),
    HID_INPUT_CAPABILITY_TOUCH    = (1 << 2),
    HID_INPUT_CAPABILITY_TABLET   = (1 << 3),
 };

-enum eHIDType : uint8_t {
+enum eHIDType {
    HID_TYPE_UNKNOWN = 0,
    HID_TYPE_POINTER,
    HID_TYPE_KEYBOARD,
@@ -27,7 +27,7 @@ enum eHIDType : uint8_t {
 */
 class IHID {
  public:
-    virtual ~IHID() = default;
+    virtual ~IHID() {}

    virtual uint32_t getCapabilities() = 0;
    virtual eHIDType getType();
--- a/src/devices/IKeyboard.cpp
+++ b/src/devices/IKeyboard.cpp
@@ -8,8 +8,6 @@
 #include <aquamarine/input/Input.hpp>
 #include <cstring>

-using namespace Hyprutils::OS;
-
 #define LED_COUNT 3

 constexpr static std::array<const char*, 8> MODNAMES = {
@@ -43,14 +41,13 @@ void IKeyboard::clearManuallyAllocd() {
    if (xkbKeymap)
        xkb_keymap_unref(xkbKeymap);

-    if (xkbSymState)
-        xkb_state_unref(xkbSymState);
+    if (xkbKeymapFD >= 0)
+        close(xkbKeymapFD);

-    xkbSymState    = nullptr;
    xkbKeymap      = nullptr;
    xkbState       = nullptr;
    xkbStaticState = nullptr;
-    xkbKeymapFD.reset();
+    xkbKeymapFD    = -1;
 }

 void IKeyboard::setKeymap(const SStringRuleNames& rules) {
@@ -126,14 +123,14 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
        updateModifiers(0, 0, modifiersState.locked, modifiersState.group);
    }

-    for (size_t i = 0; i < std::min(LEDNAMES.size(), ledIndexes.size()); ++i) {
-        ledIndexes[i] = xkb_map_led_get_index(xkbKeymap, LEDNAMES[i]);
-        Debug::log(LOG, "xkb: LED index {} (name {}) got index {}", i, LEDNAMES[i], ledIndexes[i]);
+    for (size_t i = 0; i < LEDNAMES.size(); ++i) {
+        ledIndexes.at(i) = xkb_map_led_get_index(xkbKeymap, LEDNAMES.at(i));
+        Debug::log(LOG, "xkb: LED index {} (name {}) got index {}", i, LEDNAMES.at(i), ledIndexes.at(i));
    }

-    for (size_t i = 0; i < std::min(MODNAMES.size(), modIndexes.size()); ++i) {
-        modIndexes[i] = xkb_map_mod_get_index(xkbKeymap, MODNAMES[i]);
-        Debug::log(LOG, "xkb: Mod index {} (name {}) got index {}", i, MODNAMES[i], modIndexes[i]);
+    for (size_t i = 0; i < MODNAMES.size(); ++i) {
+        modIndexes.at(i) = xkb_map_mod_get_index(xkbKeymap, MODNAMES.at(i));
+        Debug::log(LOG, "xkb: Mod index {} (name {}) got index {}", i, MODNAMES.at(i), modIndexes.at(i));
    }

    updateKeymapFD();
@@ -146,30 +143,31 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
 void IKeyboard::updateKeymapFD() {
    Debug::log(LOG, "Updating keymap fd for keyboard {}", deviceName);

-    if (xkbKeymapFD.isValid())
-        xkbKeymapFD.reset();
+    if (xkbKeymapFD >= 0)
+        close(xkbKeymapFD);
+    xkbKeymapFD = -1;

    auto cKeymapStr = xkb_keymap_get_as_string(xkbKeymap, XKB_KEYMAP_FORMAT_TEXT_V1);
    xkbKeymapString = cKeymapStr;
    free(cKeymapStr);

-    CFileDescriptor rw, ro;
-    if (!allocateSHMFilePair(xkbKeymapString.length() + 1, rw, ro))
+    int rw, ro;
+    if (!allocateSHMFilePair(xkbKeymapString.length() + 1, &rw, &ro))
        Debug::log(ERR, "IKeyboard: failed to allocate shm pair for the keymap");
    else {
-        auto keymapFDDest = mmap(nullptr, xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw.get(), 0);
-        rw.reset();
+        auto keymapFDDest = mmap(nullptr, xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw, 0);
+        close(rw);
        if (keymapFDDest == MAP_FAILED) {
            Debug::log(ERR, "IKeyboard: failed to mmap a shm pair for the keymap");
-            ro.reset();
+            close(ro);
        } else {
            memcpy(keymapFDDest, xkbKeymapString.c_str(), xkbKeymapString.length());
            munmap(keymapFDDest, xkbKeymapString.length() + 1);
-            xkbKeymapFD = std::move(ro);
+            xkbKeymapFD = ro;
        }
    }

-    Debug::log(LOG, "Updated keymap fd to {}", xkbKeymapFD.get());
+    Debug::log(LOG, "Updated keymap fd to {}", xkbKeymapFD);
 }

 void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
@@ -289,8 +287,8 @@ std::optional<uint32_t> IKeyboard::getLEDs() {
        return {};

    uint32_t leds = 0;
-    for (uint32_t i = 0; i < std::min((size_t)LED_COUNT, ledIndexes.size()); ++i) {
-        if (xkb_state_led_index_is_active(xkbState, ledIndexes[i]))
+    for (uint32_t i = 0; i < LED_COUNT; ++i) {
+        if (xkb_state_led_index_is_active(xkbState, ledIndexes.at(i)))
            leds |= (1 << i);
    }

@@ -323,10 +321,10 @@ uint32_t IKeyboard::getModifiers() {
    uint32_t modMask = modifiersState.depressed | modifiersState.latched;
    uint32_t mods    = 0;
    for (size_t i = 0; i < modIndexes.size(); ++i) {
-        if (modIndexes[i] == XKB_MOD_INVALID)
+        if (modIndexes.at(i) == XKB_MOD_INVALID)
            continue;

-        if (!(modMask & (1 << modIndexes[i])))
+        if (!(modMask & (1 << modIndexes.at(i))))
            continue;

        mods |= (1 << i);
--- a/src/devices/IKeyboard.hpp
+++ b/src/devices/IKeyboard.hpp
@@ -6,7 +6,6 @@

 #include <optional>
 #include <xkbcommon/xkbcommon.h>
-#include <hyprutils/os/FileDescriptor.hpp>

 AQUAMARINE_FORWARD(IKeyboard);

@@ -97,7 +96,7 @@ class IKeyboard : public IHID {

    std::string                    xkbFilePath     = "";
    std::string                    xkbKeymapString = "";
-    Hyprutils::OS::CFileDescriptor xkbKeymapFD;
+    int                            xkbKeymapFD     = -1;

    SStringRuleNames               currentRules;
    int                            repeatRate        = 0;
--- a/src/devices/IPointer.hpp
+++ b/src/devices/IPointer.hpp
@@ -17,10 +17,8 @@ class IPointer : public IHID {
    virtual SP<Aquamarine::IPointer> aq()        = 0;

    struct SMotionEvent {
-        uint32_t     timeMs = 0;
-        Vector2D     delta, unaccel;
-        bool         mouse = false;
-        SP<IPointer> device;
+        uint32_t timeMs = 0;
+        Vector2D delta, unaccel;
    };

    struct SMotionAbsoluteEvent {
@@ -33,7 +31,6 @@ class IPointer : public IHID {
        uint32_t                timeMs = 0;
        uint32_t                button = 0;
        wl_pointer_button_state state  = WL_POINTER_BUTTON_STATE_PRESSED;
-        bool                    mouse  = false;
    };

    struct SAxisEvent {
@@ -43,7 +40,6 @@ class IPointer : public IHID {
        wl_pointer_axis_relative_direction relativeDirection = WL_POINTER_AXIS_RELATIVE_DIRECTION_IDENTICAL;
        double                             delta             = 0.0;
        int32_t                            deltaDiscrete     = 0;
-        bool                               mouse             = false;
    };

    struct SSwipeBeginEvent {
@@ -110,9 +106,6 @@ class IPointer : public IHID {

    bool         connected   = false; // means connected to the cursor
    std::string  boundOutput = "";
-    bool         flipX       = false; // decide to invert horizontal movement
-    bool         flipY       = false; // decide to invert vertical movement
-    bool         isTouchpad  = false;

    WP<IPointer> self;
 };
--- a/src/devices/Keyboard.cpp
+++ b/src/devices/Keyboard.cpp
@@ -1,5 +1,6 @@
 #include "Keyboard.hpp"
 #include "../defines.hpp"
+#include "../Compositor.hpp"

 #include <aquamarine/input/Input.hpp>

--- a/src/devices/Mouse.cpp
+++ b/src/devices/Mouse.cpp
@@ -14,11 +14,6 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
    if (!mouse)
        return;

-    if (auto handle = mouse->getLibinputHandle()) {
-        double w = 0, h = 0;
-        isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
-    }
-
    listeners.destroy = mouse->events.destroy.registerListener([this](std::any d) {
        mouse.reset();
        events.destroy.emit();
@@ -31,8 +26,6 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
            .timeMs  = E.timeMs,
            .delta   = E.delta,
            .unaccel = E.unaccel,
-            .mouse   = true,
-            .device  = self.lock(),
        });
    });

@@ -53,7 +46,6 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
            .timeMs = E.timeMs,
            .button = E.button,
            .state  = E.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED,
-            .mouse  = true,
        });
    });

@@ -67,7 +59,6 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
            .relativeDirection = (wl_pointer_axis_relative_direction)E.direction,
            .delta             = E.delta,
            .deltaDiscrete     = E.discrete,
-            .mouse             = true,
        });
    });

--- a/src/devices/Tablet.hpp
+++ b/src/devices/Tablet.hpp
@@ -3,6 +3,7 @@
 #include "IHID.hpp"
 #include "../macros.hpp"
 #include "../helpers/math/Math.hpp"
+#include "../helpers/math/Math.hpp"

 AQUAMARINE_FORWARD(ITablet);
 AQUAMARINE_FORWARD(ITabletTool);
@@ -26,7 +27,7 @@ class CTablet : public IHID {
    virtual eHIDType        getType();
    SP<Aquamarine::ITablet> aq();

-    enum eTabletToolAxes : uint16_t {
+    enum eTabletToolAxes {
        HID_TABLET_TOOL_AXIS_X        = (1 << 0),
        HID_TABLET_TOOL_AXIS_Y        = (1 << 1),
        HID_TABLET_TOOL_AXIS_TILT_X   = (1 << 2),
@@ -91,10 +92,9 @@ class CTablet : public IHID {
    WP<CTablet> self;

    bool        relativeInput = false;
-    bool        absolutePos   = false;
    std::string boundOutput   = "";
    CBox        activeArea;
-    CBox        boundBox;
+    CBox        boundBox; // output-local

  private:
    CTablet(SP<Aquamarine::ITablet> tablet);
@@ -172,7 +172,7 @@ class CTabletTool : public IHID {
    static SP<CTabletTool> create(SP<Aquamarine::ITabletTool> tool);
    ~CTabletTool();

-    enum eTabletToolType : uint8_t {
+    enum eTabletToolType {
        HID_TABLET_TOOL_TYPE_PEN = 1,
        HID_TABLET_TOOL_TYPE_ERASER,
        HID_TABLET_TOOL_TYPE_BRUSH,
@@ -183,7 +183,7 @@ class CTabletTool : public IHID {
        HID_TABLET_TOOL_TYPE_TOTEM,
    };

-    enum eTabletToolCapabilities : uint8_t {
+    enum eTabletToolCapabilities {
        HID_TABLET_TOOL_CAPABILITY_TILT     = (1 << 0),
        HID_TABLET_TOOL_CAPABILITY_PRESSURE = (1 << 1),
        HID_TABLET_TOOL_CAPABILITY_DISTANCE = (1 << 2),
--- 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 UNLIKELY (!resource->good())
+    if (!resource->good())
        return;

    listeners.destroy = pointer->events.destroy.registerListener([this](std::any d) {
@@ -19,11 +19,7 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : point
        events.destroy.emit();
    });

-    listeners.motion         = pointer->events.move.registerListener([this](std::any d) {
-        auto E   = std::any_cast<SMotionEvent>(d);
-        E.device = self.lock();
-        pointerEvents.motion.emit(E);
-    });
+    listeners.motion         = pointer->events.move.registerListener([this](std::any d) { pointerEvents.motion.emit(d); });
    listeners.motionAbsolute = pointer->events.warp.registerListener([this](std::any d) {
        // we need to unpack the event and add our device here because it's required to calculate the position correctly
        auto E   = std::any_cast<SMotionAbsoluteEvent>(d);
@@ -42,7 +38,7 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : point
    listeners.holdBegin      = pointer->events.holdBegin.registerListener([this](std::any d) { pointerEvents.holdBegin.emit(d); });
    listeners.holdEnd        = pointer->events.holdEnd.registerListener([this](std::any d) { pointerEvents.holdEnd.emit(d); });

-    boundOutput = resource->boundOutput ? resource->boundOutput->szName : "";
+    boundOutput = resource->boundOutput ? resource->boundOutput->szName : "entire";

    deviceName = pointer->name;
 }
--- a/src/events/Events.hpp
+++ b/src/events/Events.hpp
@@ -1,7 +1,12 @@
 #pragma once
 #include "../defines.hpp"

-// NOLINTNEXTLINE(readability-identifier-naming)
+//
+// LISTEN_NAME -> the wl_listener
+//
+// LISTENER_NAME -> the wl_listener.notify function
+//
+
 namespace Events {
    // Window events
    DYNLISTENFUNC(commitWindow);
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -11,18 +11,11 @@
 #include "../protocols/XDGShell.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/ToplevelExport.hpp"
-#include "../protocols/types/ContentType.hpp"
 #include "../xwayland/XSurface.hpp"
-#include "managers/AnimationManager.hpp"
 #include "managers/PointerManager.hpp"
-#include "../desktop/LayerSurface.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;

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

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

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

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

 void Events::listener_mapWindow(void* owner, void* data) {
@@ -130,193 +121,162 @@ 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;
+    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) {
-            case CWindowRule::RULE_MONITOR: {
-                try {
-                    const auto MONITORSTR = trim(r->szRule.substr(r->szRule.find(' ')));
+        if (r.szRule.starts_with("monitor")) {
+            try {
+                const auto MONITORSTR = trim(r.szRule.substr(r.szRule.find(' ')));

-                    if (MONITORSTR == "unset") {
-                        PWINDOW->m_pMonitor = PMONITOR;
+                if (MONITORSTR == "unset") {
+                    PWINDOW->m_pMonitor = PMONITOR;
+                } else {
+                    if (isNumber(MONITORSTR)) {
+                        const MONITORID MONITOR = std::stoi(MONITORSTR);
+                        if (const auto PM = g_pCompositor->getMonitorFromID(MONITOR); PM)
+                            PWINDOW->m_pMonitor = PM;
+                        else
+                            PWINDOW->m_pMonitor = g_pCompositor->m_vMonitors.at(0);
                    } else {
-                        if (isNumber(MONITORSTR)) {
-                            const MONITORID MONITOR = std::stoi(MONITORSTR);
-                            if (const auto PM = g_pCompositor->getMonitorFromID(MONITOR); PM)
-                                PWINDOW->m_pMonitor = PM;
-                            else
-                                PWINDOW->m_pMonitor = g_pCompositor->m_vMonitors.at(0);
-                        } else {
-                            const auto PMONITOR = g_pCompositor->getMonitorFromName(MONITORSTR);
-                            if (PMONITOR)
-                                PWINDOW->m_pMonitor = PMONITOR;
-                            else {
-                                Debug::log(ERR, "No monitor in monitor {} rule", MONITORSTR);
-                                continue;
-                            }
+                        const auto PMONITOR = g_pCompositor->getMonitorFromName(MONITORSTR);
+                        if (PMONITOR)
+                            PWINDOW->m_pMonitor = PMONITOR;
+                        else {
+                            Debug::log(ERR, "No monitor in monitor {} rule", MONITORSTR);
+                            continue;
                        }
                    }
+                }

-                    const auto PMONITORFROMID = PWINDOW->m_pMonitor.lock();
+                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;
+                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;

-                    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;
+                Debug::log(LOG, "Rule monitor, applying to {:mw}", PWINDOW);
+            } catch (std::exception& e) { Debug::log(ERR, "Rule monitor failed, rule: {} -> {} | err: {}", r.szRule, r.szValue, e.what()); }
+        } else if (r.szRule.starts_with("workspace")) {
+            // check if it isnt unset
+            const auto WORKSPACERQ = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
+
+            if (WORKSPACERQ == "unset") {
+                requestedWorkspace = "";
+            } else {
+                requestedWorkspace = WORKSPACERQ;
            }
-            case CWindowRule::RULE_WORKSPACE: {
-                // check if it isnt unset
-                const auto WORKSPACERQ = r->szRule.substr(r->szRule.find_first_of(' ') + 1);

-                if (WORKSPACERQ == "unset")
-                    requestedWorkspace = "";
+            const auto JUSTWORKSPACE = WORKSPACERQ.contains(' ') ? WORKSPACERQ.substr(0, WORKSPACERQ.find_first_of(' ')) : WORKSPACERQ;
+
+            if (JUSTWORKSPACE == PWORKSPACE->m_szName || JUSTWORKSPACE == "name:" + PWORKSPACE->m_szName)
+                requestedWorkspace = "";
+
+            Debug::log(LOG, "Rule workspace matched by {}, {} applied.", PWINDOW, r.szValue);
+        } else if (r.szRule.starts_with("float")) {
+            PWINDOW->m_bIsFloating = true;
+        } else if (r.szRule.starts_with("tile")) {
+            PWINDOW->m_bIsFloating = false;
+        } else if (r.szRule.starts_with("pseudo")) {
+            PWINDOW->m_bIsPseudotiled = true;
+        } else if (r.szRule.starts_with("noinitialfocus")) {
+            PWINDOW->m_bNoInitialFocus = true;
+        } else if (r.szRule.starts_with("fullscreenstate")) {
+            const auto ARGS = CVarList(r.szRule.substr(r.szRule.find_first_of(' ') + 1), 2, ' ');
+            int        internalMode, clientMode;
+            try {
+                internalMode = std::stoi(ARGS[0]);
+            } catch (std::exception& e) { internalMode = 0; }
+            try {
+                clientMode = std::stoi(ARGS[1]);
+            } catch (std::exception& e) { clientMode = 0; }
+            requestedFSState = sFullscreenState{.internal = (eFullscreenMode)internalMode, .client = (eFullscreenMode)clientMode};
+        } else if (r.szRule.starts_with("suppressevent")) {
+            CVarList vars(r.szRule, 0, 's', true);
+            for (size_t i = 1; i < vars.size(); ++i) {
+                if (vars[i] == "fullscreen")
+                    PWINDOW->m_eSuppressedEvents |= SUPPRESS_FULLSCREEN;
+                else if (vars[i] == "maximize")
+                    PWINDOW->m_eSuppressedEvents |= SUPPRESS_MAXIMIZE;
+                else if (vars[i] == "activate")
+                    PWINDOW->m_eSuppressedEvents |= SUPPRESS_ACTIVATE;
+                else if (vars[i] == "activatefocus")
+                    PWINDOW->m_eSuppressedEvents |= SUPPRESS_ACTIVATE_FOCUSONLY;
                else
-                    requestedWorkspace = WORKSPACERQ;
+                    Debug::log(ERR, "Error while parsing suppressevent windowrule: unknown event type {}", vars[i]);
+            }
+        } else if (r.szRule == "pin") {
+            PWINDOW->m_bPinned = true;
+        } else if (r.szRule == "fullscreen") {
+            requestedInternalFSMode = FSMODE_FULLSCREEN;
+        } else if (r.szRule == "maximize") {
+            requestedInternalFSMode = FSMODE_MAXIMIZED;
+        } else if (r.szRule == "stayfocused") {
+            PWINDOW->m_bStayFocused = true;
+        } else if (r.szRule.starts_with("group")) {
+            if (PWINDOW->m_eGroupRules & GROUP_OVERRIDE)
+                continue;

-                const auto JUSTWORKSPACE = WORKSPACERQ.contains(' ') ? WORKSPACERQ.substr(0, WORKSPACERQ.find_first_of(' ')) : WORKSPACERQ;
+            // `group` is a shorthand of `group set`
+            if (trim(r.szRule) == "group") {
+                PWINDOW->m_eGroupRules |= GROUP_SET;
+                continue;
+            }

-                if (JUSTWORKSPACE == PWORKSPACE->m_szName || JUSTWORKSPACE == "name:" + PWORKSPACE->m_szName)
-                    requestedWorkspace = "";
+            CVarList    vars(r.szRule, 0, 's');
+            std::string vPrev = "";

-                Debug::log(LOG, "Rule workspace matched by {}, {} applied.", PWINDOW, r->szValue);
-                requestedFSMonitor = MONITOR_INVALID;
-                break;
-            }
-            case CWindowRule::RULE_FLOAT: {
-                PWINDOW->m_bIsFloating = true;
-                break;
-            }
-            case CWindowRule::RULE_TILE: {
-                PWINDOW->m_bIsFloating = false;
-                break;
-            }
-            case CWindowRule::RULE_PSEUDO: {
-                PWINDOW->m_bIsPseudotiled = true;
-                break;
-            }
-            case CWindowRule::RULE_NOINITIALFOCUS: {
-                PWINDOW->m_bNoInitialFocus = true;
-                break;
-            }
-            case CWindowRule::RULE_FULLSCREENSTATE: {
-                const auto ARGS = CVarList(r->szRule.substr(r->szRule.find_first_of(' ') + 1), 2, ' ');
-                int        internalMode, clientMode;
-                try {
-                    internalMode = std::stoi(ARGS[0]);
-                } catch (std::exception& e) { internalMode = 0; }
-                try {
-                    clientMode = std::stoi(ARGS[1]);
-                } catch (std::exception& e) { clientMode = 0; }
-                requestedFSState = SFullscreenState{.internal = (eFullscreenMode)internalMode, .client = (eFullscreenMode)clientMode};
-                break;
-            }
-            case CWindowRule::RULE_SUPPRESSEVENT: {
-                CVarList vars(r->szRule, 0, 's', true);
-                for (size_t i = 1; i < vars.size(); ++i) {
-                    if (vars[i] == "fullscreen")
-                        PWINDOW->m_eSuppressedEvents |= SUPPRESS_FULLSCREEN;
-                    else if (vars[i] == "maximize")
-                        PWINDOW->m_eSuppressedEvents |= SUPPRESS_MAXIMIZE;
-                    else if (vars[i] == "activate")
-                        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]);
-                }
-                break;
-            }
-            case CWindowRule::RULE_PIN: {
-                PWINDOW->m_bPinned = true;
-                break;
-            }
-            case CWindowRule::RULE_FULLSCREEN: {
-                requestedInternalFSMode = FSMODE_FULLSCREEN;
-                break;
-            }
-            case CWindowRule::RULE_MAXIMIZE: {
-                requestedInternalFSMode = FSMODE_MAXIMIZED;
-                break;
-            }
-            case CWindowRule::RULE_STAYFOCUSED: {
-                PWINDOW->m_bStayFocused = true;
-                break;
-            }
-            case CWindowRule::RULE_GROUP: {
-                if (PWINDOW->m_eGroupRules & GROUP_OVERRIDE)
+            for (auto const& v : vars) {
+                if (v == "group")
                    continue;

-                // `group` is a shorthand of `group set`
-                if (trim(r->szRule) == "group") {
+                if (v == "set") {
                    PWINDOW->m_eGroupRules |= GROUP_SET;
-                    continue;
+                } else if (v == "new") {
+                    // shorthand for `group barred set`
+                    PWINDOW->m_eGroupRules |= (GROUP_SET | GROUP_BARRED);
+                } else if (v == "lock") {
+                    PWINDOW->m_eGroupRules |= GROUP_LOCK;
+                } else if (v == "invade") {
+                    PWINDOW->m_eGroupRules |= GROUP_INVADE;
+                } else if (v == "barred") {
+                    PWINDOW->m_eGroupRules |= GROUP_BARRED;
+                } else if (v == "deny") {
+                    PWINDOW->m_sGroupData.deny = true;
+                } else if (v == "override") {
+                    // Clear existing rules
+                    PWINDOW->m_eGroupRules = GROUP_OVERRIDE;
+                } else if (v == "unset") {
+                    // Clear existing rules and stop processing
+                    PWINDOW->m_eGroupRules = GROUP_OVERRIDE;
+                    break;
+                } else if (v == "always") {
+                    if (vPrev == "set" || vPrev == "group")
+                        PWINDOW->m_eGroupRules |= GROUP_SET_ALWAYS;
+                    else if (vPrev == "lock")
+                        PWINDOW->m_eGroupRules |= GROUP_LOCK_ALWAYS;
+                    else
+                        Debug::log(ERR, "windowrule `group` does not support `{} always`", vPrev);
                }
-
-                CVarList    vars(r->szRule, 0, 's');
-                std::string vPrev = "";
-
-                for (auto const& v : vars) {
-                    if (v == "group")
-                        continue;
-
-                    if (v == "set") {
-                        PWINDOW->m_eGroupRules |= GROUP_SET;
-                    } else if (v == "new") {
-                        // shorthand for `group barred set`
-                        PWINDOW->m_eGroupRules |= (GROUP_SET | GROUP_BARRED);
-                    } else if (v == "lock") {
-                        PWINDOW->m_eGroupRules |= GROUP_LOCK;
-                    } else if (v == "invade") {
-                        PWINDOW->m_eGroupRules |= GROUP_INVADE;
-                    } else if (v == "barred") {
-                        PWINDOW->m_eGroupRules |= GROUP_BARRED;
-                    } else if (v == "deny") {
-                        PWINDOW->m_sGroupData.deny = true;
-                    } else if (v == "override") {
-                        // Clear existing rules
-                        PWINDOW->m_eGroupRules = GROUP_OVERRIDE;
-                    } else if (v == "unset") {
-                        // Clear existing rules and stop processing
-                        PWINDOW->m_eGroupRules = GROUP_OVERRIDE;
-                        break;
-                    } else if (v == "always") {
-                        if (vPrev == "set" || vPrev == "group")
-                            PWINDOW->m_eGroupRules |= GROUP_SET_ALWAYS;
-                        else if (vPrev == "lock")
-                            PWINDOW->m_eGroupRules |= GROUP_LOCK_ALWAYS;
-                        else
-                            Debug::log(ERR, "windowrule `group` does not support `{} always`", vPrev);
-                    }
-                    vPrev = v;
-                }
-                break;
+                vPrev = v;
            }
-            case CWindowRule::RULE_CONTENT: {
-                const CVarList VARS(r->szRule, 0, ' ');
-                try {
-                    PWINDOW->setContentType(NContentType::fromString(VARS[1]));
-                } catch (std::exception& e) { Debug::log(ERR, "Rule \"{}\" failed with: {}", r->szRule, e.what()); }
-                break;
-            }
-            default: break;
        }
-
        PWINDOW->applyDynamicRule(r);
    }

@@ -349,51 +309,20 @@ void Events::listener_mapWindow(void* owner, void* data) {
            if (!workspaceSilent) {
                if (pWorkspace->m_bIsSpecialWorkspace)
                    pWorkspace->m_pMonitor->setSpecialWorkspace(pWorkspace);
-                else if (PMONITOR->activeWorkspaceID() != REQUESTEDWORKSPACEID && !PWINDOW->m_bNoInitialFocus)
+                else if (PMONITOR->activeWorkspaceID() != REQUESTEDWORKSPACEID)
                    g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspaceName);

                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.
    const auto SWALLOWER  = PWINDOW->getSwallower();
    PWINDOW->m_pSwallowed = SWALLOWER;
-    if (PWINDOW->m_pSwallowed)
-        PWINDOW->m_pSwallowed->m_bCurrentlySwallowed = true;

    if (PWINDOW->m_bIsFloating) {
        g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
@@ -401,139 +330,131 @@ void Events::listener_mapWindow(void* owner, void* data) {

        // size and move rules
        for (auto const& r : PWINDOW->m_vMatchedRules) {
-            switch (r->ruleType) {
-                case CWindowRule::RULE_SIZE: {
-                    try {
-                        auto stringToFloatClamp = [](const std::string& VALUE, const float CURR, const float REL) {
-                            if (VALUE.starts_with('<'))
-                                return std::min(CURR, stringToPercentage(VALUE.substr(1, VALUE.length() - 1), REL));
-                            else if (VALUE.starts_with('>'))
-                                return std::max(CURR, stringToPercentage(VALUE.substr(1, VALUE.length() - 1), REL));
+            if (r.szRule.starts_with("size")) {
+                try {

-                            return stringToPercentage(VALUE, REL);
-                        };
+                    auto stringToFloatClamp = [](const std::string& VALUE, const float CURR, const float REL) {
+                        if (VALUE.starts_with('<'))
+                            return std::min(CURR, stringToPercentage(VALUE.substr(1, VALUE.length() - 1), REL));
+                        else if (VALUE.starts_with('>'))
+                            return std::max(CURR, stringToPercentage(VALUE.substr(1, VALUE.length() - 1), REL));

-                        const auto  VALUE    = r->szRule.substr(r->szRule.find(' ') + 1);
-                        const auto  SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
-                        const auto  SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);
+                        return stringToPercentage(VALUE, REL);
+                    };

-                        const auto  MAXSIZE = PWINDOW->requestedMaxSize();
+                    const auto  VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
+                    const auto  SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
+                    const auto  SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);

-                        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);
+                    const auto  MAXSIZE = PWINDOW->requestedMaxSize();

-                        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);
+                    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);

-                        Debug::log(LOG, "Rule size, applying to {}", PWINDOW);
+                    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);

-                        PWINDOW->clampWindowSize(Vector2D{SIZEXSTR.starts_with("<") ? 0 : SIZEX, SIZEYSTR.starts_with("<") ? 0 : SIZEY}, Vector2D{SIZEX, SIZEY});
+                    Debug::log(LOG, "Rule size, applying to {}", PWINDOW);

-                        PWINDOW->setHidden(false);
-                    } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r->szRule, r->szValue); }
-                    break;
-                }
-                case CWindowRule::RULE_MOVE: {
-                    try {
-                        auto       value = r->szRule.substr(r->szRule.find(' ') + 1);
+                    PWINDOW->clampWindowSize(Vector2D{SIZEXSTR.starts_with("<") ? 0 : SIZEX, SIZEYSTR.starts_with("<") ? 0 : SIZEY}, Vector2D{SIZEX, SIZEY});

-                        const bool ONSCREEN = value.starts_with("onscreen");
+                    PWINDOW->setHidden(false);
+                } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r.szRule, r.szValue); }
+            } else if (r.szRule.starts_with("move")) {
+                try {
+                    auto       value = r.szRule.substr(r.szRule.find(' ') + 1);

-                        if (ONSCREEN)
-                            value = value.substr(value.find_first_of(' ') + 1);
+                    const bool ONSCREEN = value.starts_with("onscreen");

-                        const bool CURSOR = value.starts_with("cursor");
+                    if (ONSCREEN)
+                        value = value.substr(value.find_first_of(' ') + 1);
+
+                    const bool CURSOR = value.starts_with("cursor");
+
+                    if (CURSOR)
+                        value = value.substr(value.find_first_of(' ') + 1);
+
+                    const auto POSXSTR = value.substr(0, value.find(' '));
+                    const auto POSYSTR = value.substr(value.find(' ') + 1);
+
+                    int        posX = 0;
+                    int        posY = 0;
+
+                    if (POSXSTR.starts_with("100%-")) {
+                        const bool subtractWindow = POSXSTR.starts_with("100%-w-");
+                        const auto POSXRAW        = (subtractWindow) ? POSXSTR.substr(7) : POSXSTR.substr(5);
+                        posX =
+                            PMONITOR->vecSize.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
+
+                        if (subtractWindow)
+                            posX -= PWINDOW->m_vRealSize.goal().x;

                        if (CURSOR)
-                            value = value.substr(value.find_first_of(' ') + 1);
-
-                        const auto POSXSTR = value.substr(0, value.find(' '));
-                        const auto POSYSTR = value.substr(value.find(' ') + 1);
-
-                        int        posX = 0;
-                        int        posY = 0;
-
-                        if (POSXSTR.starts_with("100%-")) {
-                            const bool subtractWindow = POSXSTR.starts_with("100%-w-");
-                            const auto POSXRAW        = (subtractWindow) ? POSXSTR.substr(7) : POSXSTR.substr(5);
-                            posX                      = PMONITOR->vecSize.x -
-                                (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
-
-                            if (subtractWindow)
-                                posX -= PWINDOW->m_vRealSize->goal().x;
-
-                            if (CURSOR)
-                                Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
-                        } else if (!CURSOR) {
-                            posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x;
+                            Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
+                    } else if (!CURSOR) {
+                        posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x;
+                    } else {
+                        // cursor
+                        if (POSXSTR == "cursor") {
+                            posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x;
                        } else {
-                            // cursor
-                            if (POSXSTR == "cursor") {
-                                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);
-                            }
+                            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);
                        }
+                    }

-                        if (POSYSTR.starts_with("100%-")) {
-                            const bool subtractWindow = POSYSTR.starts_with("100%-w-");
-                            const auto POSYRAW        = (subtractWindow) ? POSYSTR.substr(7) : POSYSTR.substr(5);
-                            posY                      = PMONITOR->vecSize.y -
-                                (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
+                    if (POSYSTR.starts_with("100%-")) {
+                        const bool subtractWindow = POSYSTR.starts_with("100%-w-");
+                        const auto POSYRAW        = (subtractWindow) ? POSYSTR.substr(7) : POSYSTR.substr(5);
+                        posY =
+                            PMONITOR->vecSize.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);

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

-                            if (CURSOR)
-                                Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
-                        } else if (!CURSOR) {
-                            posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y;
+                        if (CURSOR)
+                            Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
+                    } else if (!CURSOR) {
+                        posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y;
+                    } else {
+                        // cursor
+                        if (POSYSTR == "cursor") {
+                            posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y;
                        } else {
-                            // cursor
-                            if (POSYSTR == "cursor") {
-                                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);
-                            }
+                            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);
                        }
+                    }

-                        if (ONSCREEN) {
-                            int borderSize = PWINDOW->getRealBorderSize();
+                    if (ONSCREEN) {
+                        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));
+                        posX = std::clamp(posX, (int)(PMONITOR->vecReservedTopLeft.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));
-                        }
+                        posY = std::clamp(posY, (int)(PMONITOR->vecReservedTopLeft.y + borderSize),
+                                          (int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_vRealSize.goal().y - borderSize));
+                    }

-                        Debug::log(LOG, "Rule move, applying to {}", PWINDOW);
+                    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); }
-                    break;
-                }
-                case CWindowRule::RULE_CENTER: {
-                    auto       RESERVEDOFFSET = Vector2D();
-                    const auto ARGS           = CVarList(r->szRule, 2, ' ');
-                    if (ARGS[1] == "1")
-                        RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;
+                    PWINDOW->setHidden(false);
+                } catch (...) { Debug::log(LOG, "Rule move failed, rule: {} -> {}", r.szRule, r.szValue); }
+            } else if (r.szRule.starts_with("center")) {
+                auto       RESERVEDOFFSET = Vector2D();
+                const auto ARGS           = CVarList(r.szRule, 2, ' ');
+                if (ARGS[1] == "1")
+                    RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;

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

        // 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 {
@@ -542,31 +463,30 @@ void Events::listener_mapWindow(void* owner, void* data) {
        bool setPseudo = false;

        for (auto const& r : PWINDOW->m_vMatchedRules) {
-            if (r->ruleType != CWindowRule::RULE_SIZE)
-                continue;
+            if (r.szRule.starts_with("size")) {
+                try {
+                    const auto  VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
+                    const auto  SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
+                    const auto  SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);

-            try {
-                const auto  VALUE    = r->szRule.substr(r->szRule.find(' ') + 1);
-                const auto  SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
-                const auto  SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);
+                    const auto  MAXSIZE = PWINDOW->requestedMaxSize();

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

-                const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->vecSize.x) : stringToPercentage(SIZEXSTR, PMONITOR->vecSize.x);
+                    const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) : stringToPercentage(SIZEYSTR, PMONITOR->vecSize.y);

-                const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) : stringToPercentage(SIZEYSTR, PMONITOR->vecSize.y);
+                    Debug::log(LOG, "Rule size (tiled), applying to {}", PWINDOW);

-                Debug::log(LOG, "Rule size (tiled), applying to {}", PWINDOW);
+                    setPseudo              = true;
+                    PWINDOW->m_vPseudoSize = Vector2D(SIZEX, SIZEY);

-                setPseudo              = true;
-                PWINDOW->m_vPseudoSize = Vector2D(SIZEX, SIZEY);
-
-                PWINDOW->setHidden(false);
-            } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r->szRule, r->szValue); }
+                    PWINDOW->setHidden(false);
+                } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r.szRule, r.szValue); }
+            }
        }

        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();
@@ -589,18 +509,18 @@ void Events::listener_mapWindow(void* owner, void* data) {
        else if (*PNEWTAKESOVERFS == 1)
            requestedInternalFSMode = PWINDOW->m_pWorkspace->m_efFullscreenMode;
        else if (*PNEWTAKESOVERFS == 2)
-            g_pCompositor->setWindowFullscreenInternal(PWINDOW->m_pWorkspace->getFullscreenWindow(), FSMODE_NONE);
+            g_pCompositor->setWindowFullscreenInternal(g_pCompositor->getFullscreenWindowOnWorkspace(PWINDOW->m_pWorkspace->m_iID), FSMODE_NONE);
    }

    if (!PWINDOW->m_sWindowData.noFocus.valueOrDefault() && !PWINDOW->m_bNoInitialFocus &&
        (!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))
@@ -611,15 +531,15 @@ void Events::listener_mapWindow(void* owner, void* data) {
    if (!PWINDOW->m_bNoInitialFocus && (requestedInternalFSMode.has_value() || requestedClientFSMode.has_value() || requestedFSState.has_value())) {
        // fix fullscreen on requested (basically do a switcheroo)
        if (PWINDOW->m_pWorkspace->m_bHasFullscreenWindow)
-            g_pCompositor->setWindowFullscreenInternal(PWINDOW->m_pWorkspace->getFullscreenWindow(), FSMODE_NONE);
+            g_pCompositor->setWindowFullscreenInternal(g_pCompositor->getFullscreenWindowOnWorkspace(PWINDOW->m_pWorkspace->m_iID), 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());
        } else if (requestedInternalFSMode.has_value() && requestedClientFSMode.has_value() && !PWINDOW->m_sWindowData.syncFullscreen.valueOrDefault())
-            g_pCompositor->setWindowFullscreenState(PWINDOW, SFullscreenState{.internal = requestedInternalFSMode.value(), .client = requestedClientFSMode.value()});
+            g_pCompositor->setWindowFullscreenState(PWINDOW, sFullscreenState{.internal = requestedInternalFSMode.value(), .client = requestedClientFSMode.value()});
        else if (requestedInternalFSMode.has_value())
            g_pCompositor->setWindowFullscreenInternal(PWINDOW, requestedInternalFSMode.value());
        else if (requestedClientFSMode.has_value())
@@ -649,7 +569,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)});
@@ -662,17 +582,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(setVector2DAnimToMove);
-    PWINDOW->m_vRealSize->setCallbackOnEnd(setVector2DAnimToMove);
+    PWINDOW->m_vRealPosition.setCallbackOnEnd(setAnimToMove);
+    PWINDOW->m_vRealSize.setCallbackOnEnd(setAnimToMove);

    // 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);
@@ -683,8 +603,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
    // fix some xwayland apps that don't behave nicely
    PWINDOW->m_vReportedSize = PWINDOW->m_vPendingReportedSize;

-    if (PWINDOW->m_pWorkspace)
-        PWINDOW->m_pWorkspace->updateWindows();
+    g_pCompositor->updateWorkspaceWindows(PWINDOW->workspaceID());

    if (PMONITOR && PWINDOW->isX11OverrideRedirect())
        PWINDOW->m_fX11SurfaceScaledBy = PMONITOR->scale;
@@ -708,40 +627,30 @@ 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();
    }

    g_pEventManager->postEvent(SHyprIPCEvent{"closewindow", std::format("{:x}", PWINDOW)});
    EMIT_HOOK_EVENT("closeWindow", PWINDOW);

-    if (PWINDOW->m_bIsFloating && !PWINDOW->m_bIsX11 &&
-        std::any_of(PWINDOW->m_vMatchedRules.begin(), PWINDOW->m_vMatchedRules.end(), [](const auto& r) { return r->ruleType == CWindowRule::RULE_PERSISTENTSIZE; })) {
-        Debug::log(LOG, "storing floating size {}x{} for window {}::{} on close", PWINDOW->m_vRealSize->value().x, PWINDOW->m_vRealSize->value().y, PWINDOW->m_szClass,
-                   PWINDOW->m_szTitle);
-        g_pConfigManager->storeFloatingSize(PWINDOW, PWINDOW->m_vRealSize->value());
-    }
-
    PROTO::toplevelExport->onWindowUnmap(PWINDOW);

    if (PWINDOW->isFullscreen())
        g_pCompositor->setWindowFullscreenInternal(PWINDOW, FSMODE_NONE);

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

    // swallowing
    if (valid(PWINDOW->m_pSwallowed)) {
-        if (PWINDOW->m_pSwallowed->m_bCurrentlySwallowed) {
-            PWINDOW->m_pSwallowed->m_bCurrentlySwallowed = false;
-            PWINDOW->m_pSwallowed->setHidden(false);
+        PWINDOW->m_pSwallowed->setHidden(false);

-            if (PWINDOW->m_sGroupData.pNextWindow.lock())
-                PWINDOW->m_pSwallowed->m_bGroupSwallowed = true; // flag for the swallowed window to be created into the group where it belongs when auto_group = false.
+        if (PWINDOW->m_sGroupData.pNextWindow.lock())
+            PWINDOW->m_pSwallowed->m_bGroupSwallowed = true; // flag for the swallowed window to be created into the group where it belongs when auto_group = false.

-            g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW->m_pSwallowed.lock());
-        }
+        g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW->m_pSwallowed.lock());

        PWINDOW->m_pSwallowed->m_bGroupSwallowed = false;
        PWINDOW->m_pSwallowed.reset();
@@ -790,7 +699,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
                g_pCompositor->setWindowFullscreenInternal(PWINDOWCANDIDATE, CURRENTFSMODE);
        }

-        if (!PWINDOWCANDIDATE && PWINDOW->m_pWorkspace && PWINDOW->m_pWorkspace->getWindows() == 0)
+        if (!PWINDOWCANDIDATE && g_pCompositor->getWindowsOnWorkspace(PWINDOW->workspaceID()) == 0)
            g_pInputManager->refocus();

        g_pInputManager->sendMotionEventsToFocused();
@@ -809,19 +718,18 @@ 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();

    // force report all sizes (QT sometimes has an issue with this)
-    if (PWINDOW->m_pWorkspace)
-        PWINDOW->m_pWorkspace->forceReportSizesToWindows();
+    g_pCompositor->forceReportSizesToWindowsOnWorkspace(PWINDOW->workspaceID());

    // update lastwindow after focus
    PWINDOW->onUnmap();
@@ -864,7 +772,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) {
@@ -880,7 +788,7 @@ void Events::listener_commitWindow(void* owner, void* data) {

    // tearing: if solitary, redraw it. This still might be a single surface window
    if (PMONITOR && PMONITOR->solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear && PWINDOW->m_pWLSurface->resource()->current.texture) {
-        CRegion damageBox{PWINDOW->m_pWLSurface->resource()->current.accumulateBufferDamage()};
+        CRegion damageBox{PWINDOW->m_pWLSurface->resource()->accumulateCurrentBufferDamage()};

        if (!damageBox.empty()) {
            if (PMONITOR->tearingState.busy) {
@@ -924,6 +832,15 @@ 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();

@@ -955,8 +872,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);
@@ -964,7 +881,7 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
        PWINDOW->setHidden(true);

    if (PWINDOW->isFullscreen() || !PWINDOW->m_bIsFloating) {
-        PWINDOW->sendWindowSize(true);
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal(), true);
        g_pHyprRenderer->damageWindow(PWINDOW);
        return;
    }
@@ -978,27 +895,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
@@ -0,0 +1,92 @@
+#include "AnimatedVariable.hpp"
+#include "../managers/AnimationManager.hpp"
+#include "../config/ConfigManager.hpp"
+
+CBaseAnimatedVariable::CBaseAnimatedVariable(ANIMATEDVARTYPE type) : m_Type(type) {
+    ; // dummy var
+}
+
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, AVARDAMAGEPOLICY policy) {
+    m_eDamagePolicy = policy;
+    m_pConfig       = pAnimConfig;
+    m_pWindow       = pWindow;
+
+    m_bDummy = false;
+}
+
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, AVARDAMAGEPOLICY policy) {
+    m_eDamagePolicy = policy;
+    m_pConfig       = pAnimConfig;
+    m_pLayer        = pLayer;
+
+    m_bDummy = false;
+}
+
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLWORKSPACE pWorkspace, AVARDAMAGEPOLICY policy) {
+    m_eDamagePolicy = policy;
+    m_pConfig       = pAnimConfig;
+    m_pWorkspace    = pWorkspace;
+
+    m_bDummy = false;
+}
+
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, AVARDAMAGEPOLICY 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,49 +1,59 @@
 #pragma once

-#include <hyprutils/animation/AnimatedVariable.hpp>
-
+#include <functional>
+#include <any>
+#include <chrono>
+#include <type_traits>
+#include "math/Math.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 {
+enum ANIMATEDVARTYPE {
    AVARTYPE_INVALID = -1,
    AVARTYPE_FLOAT,
    AVARTYPE_VECTOR,
    AVARTYPE_COLOR
 };

-// Utility to bind a type with its corresponding eAnimatedVarType
+// Utility to bind a type with its corresponding ANIMATEDVARTYPE
 template <class T>
-// NOLINTNEXTLINE(readability-identifier-naming)
-struct STypeToAnimatedVarType_t {
-    static constexpr eAnimatedVarType value = AVARTYPE_INVALID;
+struct typeToANIMATEDVARTYPE_t {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_INVALID;
 };

 template <>
-struct STypeToAnimatedVarType_t<float> {
-    static constexpr eAnimatedVarType value = AVARTYPE_FLOAT;
+struct typeToANIMATEDVARTYPE_t<float> {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_FLOAT;
 };

 template <>
-struct STypeToAnimatedVarType_t<Vector2D> {
-    static constexpr eAnimatedVarType value = AVARTYPE_VECTOR;
+struct typeToANIMATEDVARTYPE_t<Vector2D> {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_VECTOR;
 };

 template <>
-struct STypeToAnimatedVarType_t<CHyprColor> {
-    static constexpr eAnimatedVarType value = AVARTYPE_COLOR;
+struct typeToANIMATEDVARTYPE_t<CColor> {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_COLOR;
 };

 template <class T>
-inline constexpr eAnimatedVarType typeToeAnimatedVarType = STypeToAnimatedVarType_t<T>::value;
+inline constexpr ANIMATEDVARTYPE typeToANIMATEDVARTYPE = typeToANIMATEDVARTYPE_t<T>::value;
+
+enum AVARDAMAGEPOLICY {
+    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>
@@ -53,21 +63,247 @@ concept OneOf = (... or std::same_as<T, U>);
 // This is mainly to get better errors if we put a type that's not supported
 // Otherwise template errors are ugly
 template <class T>
-concept Animable = OneOf<T, Vector2D, float, CHyprColor>;
+concept Animable = OneOf<T, Vector2D, float, CColor>;

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

-    eAVarDamagePolicy eDamagePolicy = AVARDAMAGE_NONE;
+    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
+    inline bool isBeingAnimated() {
+        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       = 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       = 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 = 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;
+
+    AVARDAMAGEPOLICY                      m_eDamagePolicy = AVARDAMAGE_NONE;
+    ANIMATEDVARTYPE                       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;
 };

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

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

-template <Animable VarType>
-using PHLANIMVARREF = WP<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;
+};
--- a/src/helpers/BezierCurve.cpp
+++ b/src/helpers/BezierCurve.cpp
@@ -0,0 +1,79 @@
+#include "BezierCurve.hpp"
+#include "../debug/Log.hpp"
+#include "../macros.hpp"
+
+#include <chrono>
+#include <algorithm>
+
+void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
+    m_dPoints.clear();
+
+    const auto BEGIN = std::chrono::high_resolution_clock::now();
+
+    m_dPoints.emplace_back(Vector2D(0, 0));
+
+    for (auto const& p : *pVec) {
+        m_dPoints.push_back(p);
+    }
+
+    m_dPoints.emplace_back(Vector2D(1, 1));
+
+    RASSERT(m_dPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: {})", m_dPoints.size());
+
+    // bake BAKEDPOINTS points for faster lookups
+    // T -> X ( / BAKEDPOINTS )
+    for (int i = 0; i < BAKEDPOINTS; ++i) {
+        m_aPointsBaked[i] = Vector2D(getXForT((i + 1) / (float)BAKEDPOINTS), getYForT((i + 1) / (float)BAKEDPOINTS));
+    }
+
+    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::getYForT(float t) {
+    return 3 * t * pow(1 - t, 2) * m_dPoints[1].y + 3 * pow(t, 2) * (1 - t) * m_dPoints[2].y + pow(t, 3);
+}
+
+float CBezierCurve::getXForT(float t) {
+    return 3 * t * pow(1 - t, 2) * m_dPoints[1].x + 3 * pow(t, 2) * (1 - t) * m_dPoints[2].x + pow(t, 3);
+}
+
+// Todo: this probably can be done better and faster
+float CBezierCurve::getYForPoint(float x) {
+    if (x >= 1.f)
+        return 1.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
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <deque>
+#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 t);
+    float getXForT(float t);
+    float getYForPoint(float x);
+
+  private:
+    // this INCLUDES the 0,0 and 1,1 points.
+    std::deque<Vector2D>              m_dPoints;
+
+    std::array<Vector2D, BAKEDPOINTS> m_aPointsBaked;
+};
--- a/src/helpers/ByteOperations.hpp
+++ b/src/helpers/ByteOperations.hpp
@@ -30,27 +30,25 @@ constexpr LD operator""_TB(const LD BYTES) {
    return BYTES * 1024 * 1024 * 1024 * 1024;
 }

-//NOLINTBEGIN
 template <typename T>
-using internal_hl_acceptable_byte_operation_type = typename std::enable_if<std::is_trivially_constructible<T, ULL>::value || std::is_trivially_constructible<T, LD>::value>::type;
+using __acceptable_byte_operation_type = typename std::enable_if<std::is_trivially_constructible<T, ULL>::value || std::is_trivially_constructible<T, LD>::value>::type;

-template <typename X, typename = internal_hl_acceptable_byte_operation_type<X>>
+template <typename X, typename = __acceptable_byte_operation_type<X>>
 constexpr X kBtoBytes(const X kB) {
    return kB * 1024;
 }
-template <typename X, typename = internal_hl_acceptable_byte_operation_type<X>>
+template <typename X, typename = __acceptable_byte_operation_type<X>>
 constexpr X MBtoBytes(const X MB) {
    return MB * 1024 * 1024;
 }
-template <typename X, typename = internal_hl_acceptable_byte_operation_type<X>>
+template <typename X, typename = __acceptable_byte_operation_type<X>>
 constexpr X GBtoBytes(const X GB) {
    return GB * 1024 * 1024 * 1024;
 }
-template <typename X, typename = internal_hl_acceptable_byte_operation_type<X>>
+template <typename X, typename = __acceptable_byte_operation_type<X>>
 constexpr X TBtoBytes(const X TB) {
    return TB * 1024 * 1024 * 1024 * 1024;
 }
-//NOLINTEND

 #undef ULL
 #undef LD
--- a/src/helpers/Color.cpp
+++ b/src/helpers/Color.cpp
@@ -5,45 +5,22 @@
 #define GREEN(c) ((double)(((c) >> 8) & 0xff) / 255.0)
 #define BLUE(c)  ((double)(((c)) & 0xff) / 255.0)

-CHyprColor::CHyprColor() = default;
+CColor::CColor() {}

-CHyprColor::CHyprColor(float r_, float g_, float b_, float a_) : r(r_), g(g_), b(b_), a(a_) {
-    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+CColor::CColor(float r, float g, float b, float a) {
+    this->r = r;
+    this->g = g;
+    this->b = b;
+    this->a = a;
 }

-CHyprColor::CHyprColor(uint64_t hex) : r(RED(hex)), g(GREEN(hex)), b(BLUE(hex)), a(ALPHA(hex)) {
-    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+CColor::CColor(uint64_t hex) {
+    this->r = RED(hex);
+    this->g = GREEN(hex);
+    this->b = BLUE(hex);
+    this->a = ALPHA(hex);
 }

-CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
-    const auto SRGB = color.asRgb();
-    r               = SRGB.r;
-    g               = SRGB.g;
-    b               = SRGB.b;
-
-    okLab = color.asOkLab();
-}
-
-uint32_t CHyprColor::getAsHex() const {
+uint32_t CColor::getAsHex() const {
    return (uint32_t)(a * 255.f) * 0x1000000 + (uint32_t)(r * 255.f) * 0x10000 + (uint32_t)(g * 255.f) * 0x100 + (uint32_t)(b * 255.f) * 0x1;
-}
-
-Hyprgraphics::CColor::SSRGB CHyprColor::asRGB() const {
-    return {r, g, b};
-}
-
-Hyprgraphics::CColor::SOkLab CHyprColor::asOkLab() const {
-    return okLab;
-}
-
-Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const {
-    return Hyprgraphics::CColor(okLab).asHSL();
-}
-
-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
@@ -1,62 +1,35 @@
 #pragma once

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

-class CHyprColor {
+class CColor {
  public:
-    CHyprColor();
-    CHyprColor(float r, float g, float b, float a);
-    CHyprColor(const Hyprgraphics::CColor& col, float a);
-    CHyprColor(uint64_t);
+    CColor();
+    CColor(float r, float g, float b, float a);
+    CColor(uint64_t);
+
+    float r = 0, g = 0, b = 0, a = 1.f;

    // AR32
-    uint32_t                     getAsHex() const;
-    Hyprgraphics::CColor::SSRGB  asRGB() const;
-    Hyprgraphics::CColor::SOkLab asOkLab() const;
-    Hyprgraphics::CColor::SHSL   asHSL() const;
-    CHyprColor                   stripA() const;
-    CHyprColor                   modifyA(float newa) const;
+    uint32_t getAsHex() const;

-    //
-    bool operator==(const CHyprColor& c2) const {
-        return c2.r == r && c2.g == g && c2.b == b && c2.a == a;
+    CColor   operator-(const CColor& c2) const {
+        return CColor(r - c2.r, g - c2.g, b - c2.b, a - c2.a);
    }

-    // stubs for the AnimationMgr
-    CHyprColor operator-(const CHyprColor& c2) const {
-        RASSERT(false, "CHyprColor: - is a STUB");
-        return {};
+    CColor operator+(const CColor& c2) const {
+        return CColor(r + c2.r, g + c2.g, b + c2.b, a + c2.a);
    }

-    CHyprColor operator+(const CHyprColor& c2) const {
-        RASSERT(false, "CHyprColor: + is a STUB");
-        return {};
+    CColor operator*(const float& v) const {
+        return CColor(r * v, g * v, b * v, a * v);
    }

-    CHyprColor operator*(const float& c2) const {
-        RASSERT(false, "CHyprColor: * is a STUB");
-        return {};
+    bool operator==(const CColor& c2) const {
+        return r == c2.r && g == c2.g && b == c2.b && a == c2.a;
    }

-    double r = 0, g = 0, b = 0, a = 0;
-
-  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);
+    CColor stripA() const {
+        return {r, g, b, 1};
+    }
 };
--- a/src/helpers/Format.cpp
+++ b/src/helpers/Format.cpp
@@ -231,7 +231,7 @@ inline const std::vector<SPixelFormat> GLES3_FORMATS = {
    },
 };

-SHMFormat NFormatUtils::drmToShm(DRMFormat drm) {
+SHMFormat FormatUtils::drmToShm(DRMFormat drm) {
    switch (drm) {
        case DRM_FORMAT_XRGB8888: return WL_SHM_FORMAT_XRGB8888;
        case DRM_FORMAT_ARGB8888: return WL_SHM_FORMAT_ARGB8888;
@@ -241,7 +241,7 @@ SHMFormat NFormatUtils::drmToShm(DRMFormat drm) {
    return drm;
 }

-DRMFormat NFormatUtils::shmToDRM(SHMFormat shm) {
+DRMFormat FormatUtils::shmToDRM(SHMFormat shm) {
    switch (shm) {
        case WL_SHM_FORMAT_XRGB8888: return DRM_FORMAT_XRGB8888;
        case WL_SHM_FORMAT_ARGB8888: return DRM_FORMAT_ARGB8888;
@@ -251,7 +251,7 @@ DRMFormat NFormatUtils::shmToDRM(SHMFormat shm) {
    return shm;
 }

-const SPixelFormat* NFormatUtils::getPixelFormatFromDRM(DRMFormat drm) {
+const SPixelFormat* FormatUtils::getPixelFormatFromDRM(DRMFormat drm) {
    for (auto const& fmt : GLES3_FORMATS) {
        if (fmt.drmFormat == drm)
            return &fmt;
@@ -260,7 +260,7 @@ const SPixelFormat* NFormatUtils::getPixelFormatFromDRM(DRMFormat drm) {
    return nullptr;
 }

-const SPixelFormat* NFormatUtils::getPixelFormatFromGL(uint32_t glFormat, uint32_t glType, bool alpha) {
+const SPixelFormat* FormatUtils::getPixelFormatFromGL(uint32_t glFormat, uint32_t glType, bool alpha) {
    for (auto const& fmt : GLES3_FORMATS) {
        if (fmt.glFormat == (int)glFormat && fmt.glType == (int)glType && fmt.withAlpha == alpha)
            return &fmt;
@@ -269,23 +269,23 @@ const SPixelFormat* NFormatUtils::getPixelFormatFromGL(uint32_t glFormat, uint32
    return nullptr;
 }

-bool NFormatUtils::isFormatOpaque(DRMFormat drm) {
-    const auto FMT = NFormatUtils::getPixelFormatFromDRM(drm);
+bool FormatUtils::isFormatOpaque(DRMFormat drm) {
+    const auto FMT = FormatUtils::getPixelFormatFromDRM(drm);
    if (!FMT)
        return false;

    return !FMT->withAlpha;
 }

-int NFormatUtils::pixelsPerBlock(const SPixelFormat* const fmt) {
+int FormatUtils::pixelsPerBlock(const SPixelFormat* const fmt) {
    return fmt->blockSize.x * fmt->blockSize.y > 0 ? fmt->blockSize.x * fmt->blockSize.y : 1;
 }

-int NFormatUtils::minStride(const SPixelFormat* const fmt, int32_t width) {
+int FormatUtils::minStride(const SPixelFormat* const fmt, int32_t width) {
    return std::ceil((width * fmt->bytesPerBlock) / pixelsPerBlock(fmt));
 }

-uint32_t NFormatUtils::drmFormatToGL(DRMFormat drm) {
+uint32_t FormatUtils::drmFormatToGL(DRMFormat drm) {
    switch (drm) {
        case DRM_FORMAT_XRGB8888:
        case DRM_FORMAT_XBGR8888: return GL_RGBA; // doesn't matter, opengl is gucci in this case.
@@ -302,7 +302,7 @@ uint32_t NFormatUtils::drmFormatToGL(DRMFormat drm) {
    return GL_RGBA;
 }

-uint32_t NFormatUtils::glFormatToType(uint32_t gl) {
+uint32_t FormatUtils::glFormatToType(uint32_t gl) {
    return gl != GL_RGBA ?
 #ifdef GLES2
        GL_UNSIGNED_INT_2_10_10_10_REV_EXT :
@@ -312,14 +312,14 @@ uint32_t NFormatUtils::glFormatToType(uint32_t gl) {
        GL_UNSIGNED_BYTE;
 }

-std::string NFormatUtils::drmFormatName(DRMFormat drm) {
+std::string FormatUtils::drmFormatName(DRMFormat drm) {
    auto        n    = drmGetFormatName(drm);
    std::string name = n;
    free(n);
    return name;
 }

-std::string NFormatUtils::drmModifierName(uint64_t mod) {
+std::string FormatUtils::drmModifierName(uint64_t mod) {
    auto        n    = drmGetFormatModifierName(mod);
    std::string name = n;
    free(n);
--- a/src/helpers/Format.hpp
+++ b/src/helpers/Format.hpp
@@ -22,7 +22,7 @@ struct SPixelFormat {

 typedef Aquamarine::SDRMFormat SDRMFormat;

-namespace NFormatUtils {
+namespace FormatUtils {
    SHMFormat           drmToShm(DRMFormat drm);
    DRMFormat           shmToDRM(SHMFormat shm);

--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -3,13 +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>
-#include <filesystem>
 #include <set>
 #include <sys/utsname.h>
 #include <sys/mman.h>
@@ -21,9 +17,7 @@
 #include <execinfo.h>
 #endif
 #include <hyprutils/string/String.hpp>
-#include <hyprutils/os/Process.hpp>
 using namespace Hyprutils::String;
-using namespace Hyprutils::OS;

 #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 #include <sys/sysctl.h>
@@ -49,6 +43,97 @@ using namespace Hyprutils::OS;
 #endif
 #endif

+static const float transforms[][9] = {
+    {
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        1.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        -1.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        1.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        -1.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+};
+
 std::string absolutePath(const std::string& rawpath, const std::string& currentPath) {
    auto value = rawpath;

@@ -73,6 +158,26 @@ 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) {
@@ -156,7 +261,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
        WORKSPACEID id = next ? g_pCompositor->m_pLastMonitor->activeWorkspaceID() : 0;
        while (++id < LONG_MAX) {
            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(id);
-            if (!invalidWSes.contains(id) && (!PWORKSPACE || PWORKSPACE->getWindows() == 0)) {
+            if (!invalidWSes.contains(id) && (!PWORKSPACE || g_pCompositor->getWindowsOnWorkspace(id) == 0)) {
                result.id = id;
                return result;
            }
@@ -170,7 +275,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
        if (!valid(PWORKSPACE))
            return {WORKSPACE_INVALID};

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

        if (!PLASTWORKSPACE)
            return {WORKSPACE_INVALID};
@@ -478,12 +583,18 @@ float vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Ve

 // Execute a shell command and get the output
 std::string execAndGet(const char* cmd) {
-    CProcess proc("/bin/sh", {"-c", cmd});
-
-    if (!proc.runSync())
-        return "error";
-
-    return proc.stdOut();
+    std::array<char, 128> buffer;
+    std::string           result;
+    using PcloseType = int (*)(FILE*);
+    const std::unique_ptr<FILE, PcloseType> pipe(popen(cmd, "r"), static_cast<PcloseType>(pclose));
+    if (!pipe) {
+        Debug::log(ERR, "execAndGet: failed in pipe");
+        return "";
+    }
+    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
+        result += buffer.data();
+    }
+    return result;
 }

 void logSystemInfo() {
@@ -501,26 +612,9 @@ void logSystemInfo() {
 #if defined(__DragonFly__) || defined(__FreeBSD__)
    const std::string GPUINFO = execAndGet("pciconf -lv | grep -F -A4 vga");
 #elif defined(__arm__) || defined(__aarch64__)
-    std::string                 GPUINFO;
-    const std::filesystem::path dev_tree = "/proc/device-tree";
-    try {
-        if (std::filesystem::exists(dev_tree) && std::filesystem::is_directory(dev_tree)) {
-            std::for_each(std::filesystem::directory_iterator(dev_tree), std::filesystem::directory_iterator{}, [&](const std::filesystem::directory_entry& entry) {
-                if (std::filesystem::is_directory(entry) && entry.path().filename().string().starts_with("soc")) {
-                    std::for_each(std::filesystem::directory_iterator(entry.path()), std::filesystem::directory_iterator{}, [&](const std::filesystem::directory_entry& sub_entry) {
-                        if (std::filesystem::is_directory(sub_entry) && sub_entry.path().filename().string().starts_with("gpu")) {
-                            std::filesystem::path file_path = sub_entry.path() / "compatible";
-                            std::ifstream         file(file_path);
-                            if (file)
-                                GPUINFO.append(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
-                        }
-                    });
-                }
-            });
-        }
-    } catch (...) { GPUINFO = "error"; }
+    const std::string GPUINFO = execAndGet("cat /proc/device-tree/soc*/gpu*/compatible");
 #else
-    const std::string GPUINFO = execAndGet("lspci -vnn | grep -E '(VGA|Display|3D)'");
+    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
 #endif
    Debug::log(LOG, "GPU information:\n{}\n", GPUINFO);

@@ -531,7 +625,7 @@ void logSystemInfo() {
    // log etc
    Debug::log(LOG, "os-release:");

-    Debug::log(NONE, "{}", NFsUtils::readFileAsString("/etc/os-release").value_or("error"));
+    Debug::log(NONE, "{}", execAndGet("cat /etc/os-release"));
 }

 int64_t getPPIDof(int64_t pid) {
@@ -583,91 +677,44 @@ int64_t getPPIDof(int64_t pid) {
 #endif
 }

-std::expected<int64_t, std::string> configStringToInt(const std::string& VALUE) {
-    auto parseHex = [](const std::string& value) -> std::expected<int64_t, std::string> {
-        try {
-            size_t position;
-            auto   result = stoll(value, &position, 16);
-            if (position == value.size())
-                return result;
-        } catch (const std::exception&) {}
-        return std::unexpected("invalid hex " + value);
-    };
+int64_t configStringToInt(const std::string& VALUE) {
    if (VALUE.starts_with("0x")) {
        // Values with 0x are hex
-        return parseHex(VALUE);
+        const auto VALUEWITHOUTHEX = VALUE.substr(2);
+        return stol(VALUEWITHOUTHEX, nullptr, 16);
    } else if (VALUE.starts_with("rgba(") && VALUE.ends_with(')')) {
-        const auto VALUEWITHOUTFUNC = trim(VALUE.substr(5, VALUE.length() - 6));
+        const auto VALUEWITHOUTFUNC = VALUE.substr(5, VALUE.length() - 6);

-        // try doing it the comma way first
-        if (std::count(VALUEWITHOUTFUNC.begin(), VALUEWITHOUTFUNC.end(), ',') == 3) {
-            // cool
-            std::string rolling = VALUEWITHOUTFUNC;
-            auto        r       = configStringToInt(trim(rolling.substr(0, rolling.find(','))));
-            rolling             = rolling.substr(rolling.find(',') + 1);
-            auto g              = configStringToInt(trim(rolling.substr(0, rolling.find(','))));
-            rolling             = rolling.substr(rolling.find(',') + 1);
-            auto b              = configStringToInt(trim(rolling.substr(0, rolling.find(','))));
-            rolling             = rolling.substr(rolling.find(',') + 1);
-            uint8_t a           = 0;
-
-            if (!r || !g || !b)
-                return std::unexpected("failed parsing " + VALUEWITHOUTFUNC);
-
-            try {
-                a = std::round(std::stof(trim(rolling.substr(0, rolling.find(',')))) * 255.f);
-            } catch (std::exception& e) { return std::unexpected("failed parsing " + VALUEWITHOUTFUNC); }
-
-            return a * (Hyprlang::INT)0x1000000 + *r * (Hyprlang::INT)0x10000 + *g * (Hyprlang::INT)0x100 + *b;
-        } else if (VALUEWITHOUTFUNC.length() == 8) {
-            const auto RGBA = parseHex(VALUEWITHOUTFUNC);
-
-            if (!RGBA)
-                return RGBA;
-            // now we need to RGBA -> ARGB. The config holds ARGB only.
-            return (*RGBA >> 8) + 0x1000000 * (*RGBA & 0xFF);
+        if (trim(VALUEWITHOUTFUNC).length() != 8) {
+            Debug::log(WARN, "invalid length {} for rgba", VALUEWITHOUTFUNC.length());
+            throw std::invalid_argument("rgba() expects length of 8 characters (4 bytes)");
        }

-        return std::unexpected("rgba() expects length of 8 characters (4 bytes) or 4 comma separated values");
+        const auto RGBA = std::stol(VALUEWITHOUTFUNC, nullptr, 16);

+        // now we need to RGBA -> ARGB. The config holds ARGB only.
+        return (RGBA >> 8) + 0x1000000 * (RGBA & 0xFF);
    } else if (VALUE.starts_with("rgb(") && VALUE.ends_with(')')) {
-        const auto VALUEWITHOUTFUNC = trim(VALUE.substr(4, VALUE.length() - 5));
+        const auto VALUEWITHOUTFUNC = VALUE.substr(4, VALUE.length() - 5);

-        // try doing it the comma way first
-        if (std::count(VALUEWITHOUTFUNC.begin(), VALUEWITHOUTFUNC.end(), ',') == 2) {
-            // cool
-            std::string rolling = VALUEWITHOUTFUNC;
-            auto        r       = configStringToInt(trim(rolling.substr(0, rolling.find(','))));
-            rolling             = rolling.substr(rolling.find(',') + 1);
-            auto g              = configStringToInt(trim(rolling.substr(0, rolling.find(','))));
-            rolling             = rolling.substr(rolling.find(',') + 1);
-            auto b              = configStringToInt(trim(rolling.substr(0, rolling.find(','))));
-
-            if (!r || !g || !b)
-                return std::unexpected("failed parsing " + VALUEWITHOUTFUNC);
-
-            return (Hyprlang::INT)0xFF000000 + *r * (Hyprlang::INT)0x10000 + *g * (Hyprlang::INT)0x100 + *b;
-        } else if (VALUEWITHOUTFUNC.length() == 6) {
-            auto r = parseHex(VALUEWITHOUTFUNC);
-            return r ? *r + 0xFF000000 : r;
+        if (trim(VALUEWITHOUTFUNC).length() != 6) {
+            Debug::log(WARN, "invalid length {} for rgb", VALUEWITHOUTFUNC.length());
+            throw std::invalid_argument("rgb() expects length of 6 characters (3 bytes)");
        }

-        return std::unexpected("rgb() expects length of 6 characters (3 bytes) or 3 comma separated values");
+        const auto RGB = std::stol(VALUEWITHOUTFUNC, nullptr, 16);
+
+        return RGB + 0xFF000000; // 0xFF for opaque
    } else if (VALUE.starts_with("true") || VALUE.starts_with("on") || VALUE.starts_with("yes")) {
        return 1;
    } else if (VALUE.starts_with("false") || VALUE.starts_with("off") || VALUE.starts_with("no")) {
        return 0;
    }

-    if (VALUE.empty() || !isNumber(VALUE, false))
-        return std::unexpected("cannot parse \"" + VALUE + "\" as an int.");
+    if (VALUE.empty() || !isNumber(VALUE))
+        return 0;

-    try {
-        const auto RES = std::stoll(VALUE);
-        return RES;
-    } catch (std::exception& e) { return std::unexpected(std::string{"stoll threw: "} + e.what()); }
-
-    return std::unexpected("parse error");
+    return std::stoll(VALUE);
 }

 Vector2D configStringToVector2D(const std::string& VALUE) {
@@ -745,48 +792,50 @@ bool envEnabled(const std::string& env) {
    return std::string(ENV) == "1";
 }

-std::pair<CFileDescriptor, std::string> openExclusiveShm() {
+std::pair<int, std::string> openExclusiveShm() {
    // Only absolute paths can be shared across different shm_open() calls
    std::string name = "/" + g_pTokenManager->getRandomUUID();

    for (size_t i = 0; i < 69; ++i) {
-        CFileDescriptor fd{shm_open(name.c_str(), O_RDWR | O_CREAT | O_EXCL, 0600)};
-        if (fd.isValid())
-            return {std::move(fd), name};
+        int fd = shm_open(name.c_str(), O_RDWR | O_CREAT | O_EXCL, 0600);
+        if (fd >= 0)
+            return {fd, name};
    }

-    return {{}, ""};
+    return {-1, ""};
 }

-CFileDescriptor allocateSHMFile(size_t len) {
+int allocateSHMFile(size_t len) {
    auto [fd, name] = openExclusiveShm();
-    if (!fd.isValid())
-        return {};
+    if (fd < 0)
+        return -1;

    shm_unlink(name.c_str());

    int ret;
    do {
-        ret = ftruncate(fd.get(), len);
+        ret = ftruncate(fd, len);
    } while (ret < 0 && errno == EINTR);

    if (ret < 0) {
-        return {};
+        close(fd);
+        return -1;
    }

-    return std::move(fd);
+    return fd;
 }

-bool allocateSHMFilePair(size_t size, CFileDescriptor& rw_fd_ptr, CFileDescriptor& ro_fd_ptr) {
+bool allocateSHMFilePair(size_t size, int* rw_fd_ptr, int* ro_fd_ptr) {
    auto [fd, name] = openExclusiveShm();
-    if (!fd.isValid()) {
+    if (fd < 0) {
        return false;
    }

    // CLOEXEC is guaranteed to be set by shm_open
-    CFileDescriptor ro_fd{shm_open(name.c_str(), O_RDONLY, 0)};
-    if (!ro_fd.isValid()) {
+    int ro_fd = shm_open(name.c_str(), O_RDONLY, 0);
+    if (ro_fd < 0) {
        shm_unlink(name.c_str());
+        close(fd);
        return false;
    }

@@ -794,20 +843,24 @@ bool allocateSHMFilePair(size_t size, CFileDescriptor& rw_fd_ptr, CFileDescripto

    // Make sure the file cannot be re-opened in read-write mode (e.g. via
    // "/proc/self/fd/" on Linux)
-    if (fchmod(fd.get(), 0) != 0) {
+    if (fchmod(fd, 0) != 0) {
+        close(fd);
+        close(ro_fd);
        return false;
    }

    int ret;
    do {
-        ret = ftruncate(fd.get(), size);
+        ret = ftruncate(fd, size);
    } while (ret < 0 && errno == EINTR);
    if (ret < 0) {
+        close(fd);
+        close(ro_fd);
        return false;
    }

-    rw_fd_ptr = std::move(fd);
-    ro_fd_ptr = std::move(ro_fd);
+    *rw_fd_ptr = fd;
+    *ro_fd_ptr = ro_fd;
    return true;
 }

@@ -816,4 +869,4 @@ float stringToPercentage(const std::string& VALUE, const float REL) {
        return (std::stof(VALUE.substr(0, VALUE.length() - 1)) * REL) / 100.f;
    else
        return std::stof(VALUE);
-}
+};
--- a/src/helpers/MiscFunctions.hpp
+++ b/src/helpers/MiscFunctions.hpp
@@ -1,11 +1,11 @@
 #pragma once

 #include <optional>
+#include <string>
 #include <wayland-server.h>
+#include "math/Math.hpp"
 #include <vector>
 #include <format>
-#include <expected>
-#include <hyprutils/os/FileDescriptor.hpp>
 #include "../SharedDefs.hpp"
 #include "../macros.hpp"

@@ -19,26 +19,28 @@ struct SWorkspaceIDName {
    std::string name;
 };

-std::string                         absolutePath(const std::string&, const std::string&);
-std::string                         escapeJSONStrings(const std::string& str);
-bool                                isDirection(const std::string&);
-bool                                isDirection(const char&);
-SWorkspaceIDName                    getWorkspaceIDNameFromString(const std::string&);
-std::optional<std::string>          cleanCmdForWorkspace(const std::string&, std::string);
-float                               vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
-void                                logSystemInfo();
-std::string                         execAndGet(const char*);
-int64_t                             getPPIDof(int64_t pid);
-std::expected<int64_t, std::string> configStringToInt(const std::string&);
-Vector2D                            configStringToVector2D(const std::string&);
-std::optional<float>                getPlusMinusKeywordResult(std::string in, float relative);
-double                              normalizeAngleRad(double ang);
-std::vector<SCallstackFrameInfo>    getBacktrace();
-void                                throwError(const std::string& err);
-bool                                envEnabled(const std::string& env);
-Hyprutils::OS::CFileDescriptor      allocateSHMFile(size_t len);
-bool                                allocateSHMFilePair(size_t size, Hyprutils::OS::CFileDescriptor& rw_fd_ptr, Hyprutils::OS::CFileDescriptor& ro_fd_ptr);
-float                               stringToPercentage(const std::string& VALUE, const float REL);
+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&);
+SWorkspaceIDName                 getWorkspaceIDNameFromString(const std::string&);
+std::optional<std::string>       cleanCmdForWorkspace(const std::string&, std::string);
+float                            vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
+void                             logSystemInfo();
+std::string                      execAndGet(const char*);
+int64_t                          getPPIDof(int64_t pid);
+int64_t                          configStringToInt(const std::string&);
+Vector2D                         configStringToVector2D(const std::string&);
+std::optional<float>             getPlusMinusKeywordResult(std::string in, float relative);
+double                           normalizeAngleRad(double ang);
+std::vector<SCallstackFrameInfo> getBacktrace();
+void                             throwError(const std::string& err);
+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);

 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,8 +1,6 @@
 #include "Monitor.hpp"
 #include "MiscFunctions.hpp"
-#include "../macros.hpp"
 #include "math/Math.hpp"
-#include "../protocols/ColorManagement.hpp"
 #include "sync/SyncReleaser.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
@@ -18,25 +16,15 @@
 #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;
-using namespace Hyprutils::OS;
-using enum NContentType::eContentType;

-static int ratHandler(void* data) {
+int ratHandler(void* data) {
    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->self.lock());

    return 1;
@@ -51,13 +39,11 @@ CMonitor::~CMonitor() {
 }

 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());
+        inTimeline  = CSyncTimeline::create(output->getBackend()->drmFD());
+        outTimeline = CSyncTimeline::create(output->getBackend()->drmFD());
    }

    listeners.frame  = output->events.frame.registerListener([this](std::any d) { onMonitorFrame(); });
@@ -98,7 +84,7 @@ void CMonitor::onConnect(bool noRule) {
                return;

            Debug::log(LOG, "Reapplying monitor rule for {} from a state request", szName);
-            applyMonitorRule(&activeMonitorRule, true);
+            g_pHyprRenderer->applyMonitorRule(self.lock(), &activeMonitorRule, true);
            return;
        }

@@ -112,7 +98,7 @@ void CMonitor::onConnect(bool noRule) {
        SMonitorRule rule = activeMonitorRule;
        rule.resolution   = SIZE;

-        applyMonitorRule(&rule);
+        g_pHyprRenderer->applyMonitorRule(self.lock(), &rule);
    });

    tearingState.canTear = output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
@@ -185,7 +171,7 @@ void CMonitor::onConnect(bool noRule) {

    // set mode, also applies
    if (!noRule)
-        applyMonitorRule(&monitorRule, true);
+        g_pHyprRenderer->applyMonitorRule(self.lock(), &monitorRule, true);

    if (!state.commit())
        Debug::log(WARN, "state.commit() failed in CMonitor::onCommit");
@@ -252,7 +238,6 @@ void CMonitor::onConnect(bool noRule) {
 }

 void CMonitor::onDisconnect(bool destroy) {
-    EMIT_HOOK_EVENT("preMonitorRemoved", self.lock());
    CScopeGuard x = {[this]() {
        if (g_pCompositor->m_bIsShuttingDown)
            return;
@@ -327,7 +312,7 @@ void CMonitor::onDisconnect(bool destroy) {
        g_pCompositor->warpCursorTo(BACKUPMON->vecPosition + BACKUPMON->vecTransformedSize / 2.F, true);

        // move workspaces
-        std::vector<PHLWORKSPACE> wspToMove;
+        std::deque<PHLWORKSPACE> wspToMove;
        for (auto const& w : g_pCompositor->m_vWorkspaces) {
            if (w->m_pMonitor == self || !w->m_pMonitor)
                wspToMove.push_back(w);
@@ -374,464 +359,6 @@ 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 && RULE->cmType == cmType && RULE->sdrSaturation == sdrSaturation &&
-        RULE->sdrBrightness == sdrBrightness && !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;
-
-    auto oldImageDescription = imageDescription;
-    cmType                   = RULE->cmType;
-    switch (cmType) {
-        case CM_AUTO: cmType = enabled10bit && output->parsedEDID.supportsBT2020 ? CM_WIDE : CM_SRGB; break;
-        case CM_EDID: cmType = output->parsedEDID.chromaticityCoords.has_value() ? CM_EDID : CM_SRGB; break;
-        case CM_HDR:
-        case CM_HDR_EDID:
-            cmType = output->parsedEDID.supportsBT2020 && output->parsedEDID.hdrMetadata.has_value() && output->parsedEDID.hdrMetadata->supportsPQ ? cmType : CM_SRGB;
-            break;
-        default: break;
-    }
-    switch (cmType) {
-        case CM_SRGB: imageDescription = {}; break; // assumes SImageDescirption defaults to sRGB
-        case CM_WIDE:
-            imageDescription = {.primariesNameSet = true,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020)};
-            break;
-        case CM_EDID:
-            imageDescription = {.primariesNameSet = false,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = {
-                                           .red   = {.x = output->parsedEDID.chromaticityCoords->red.x, .y = output->parsedEDID.chromaticityCoords->red.y},
-                                           .green = {.x = output->parsedEDID.chromaticityCoords->green.x, .y = output->parsedEDID.chromaticityCoords->green.y},
-                                           .blue  = {.x = output->parsedEDID.chromaticityCoords->blue.x, .y = output->parsedEDID.chromaticityCoords->blue.y},
-                                           .white = {.x = output->parsedEDID.chromaticityCoords->white.x, .y = output->parsedEDID.chromaticityCoords->white.y},
-                                }};
-            break;
-        case CM_HDR:
-            imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
-                                .primariesNameSet = true,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
-                                .luminances       = {.min = 0, .max = 10000, .reference = 203}};
-            break;
-        case CM_HDR_EDID:
-            imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
-                                .primariesNameSet = false,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = output->parsedEDID.chromaticityCoords.has_value() ?
-                                           NColorManagement::SPCPRimaries{
-                                               .red   = {.x = output->parsedEDID.chromaticityCoords->red.x, .y = output->parsedEDID.chromaticityCoords->red.y},
-                                               .green = {.x = output->parsedEDID.chromaticityCoords->green.x, .y = output->parsedEDID.chromaticityCoords->green.y},
-                                               .blue  = {.x = output->parsedEDID.chromaticityCoords->blue.x, .y = output->parsedEDID.chromaticityCoords->blue.y},
-                                               .white = {.x = output->parsedEDID.chromaticityCoords->white.x, .y = output->parsedEDID.chromaticityCoords->white.y},
-                                    } :
-                                           NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
-                                .luminances       = {.min       = output->parsedEDID.hdrMetadata->desiredContentMinLuminance,
-                                                     .max       = output->parsedEDID.hdrMetadata->desiredContentMaxLuminance,
-                                                     .reference = output->parsedEDID.hdrMetadata->desiredMaxFrameAverageLuminance}};
-
-            break;
-        default: UNREACHABLE();
-    }
-    if (oldImageDescription != imageDescription)
-        PROTO::colorManagement->onMonitorImageDescriptionChanged(self);
-
-    sdrSaturation = RULE->sdrSaturation;
-    sdrBrightness = RULE->sdrBrightness;
-
-    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) {
@@ -841,18 +368,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);
 }

@@ -861,8 +388,8 @@ bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
    static auto PMINRR   = CConfigValue<Hyprlang::INT>("cursor:min_refresh_rate");

    // skip scheduling extra frames for fullsreen apps with vrr
-    const bool shouldSkip = activeWorkspace && activeWorkspace->m_bHasFullscreenWindow && activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN &&
-        (*PNOBREAK == 1 || (*PNOBREAK == 2 && activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && output->state->state().adaptiveSync;
+    bool shouldSkip =
+        *PNOBREAK && output->state->state().adaptiveSync && activeWorkspace && activeWorkspace->m_bHasFullscreenWindow && activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN;

    // keep requested minimum refresh rate
    if (shouldSkip && *PMINRR && lastPresentationTimer.getMillis() > 1000.0f / *PMINRR) {
@@ -883,7 +410,7 @@ bool CMonitor::matchesStaticSelector(const std::string& selector) const {
        // match by description
        const auto DESCRIPTIONSELECTOR = selector.substr(5);

-        return szDescription.starts_with(DESCRIPTIONSELECTOR) || szShortDescription.starts_with(DESCRIPTIONSELECTOR);
+        return DESCRIPTIONSELECTOR == szShortDescription || DESCRIPTIONSELECTOR == szDescription;
    } else {
        // match by selector
        return szName == selector;
@@ -1001,7 +528,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {

        setupDefaultWS(RULE);

-        applyMonitorRule((SMonitorRule*)&RULE, true); // will apply the offset and stuff
+        g_pHyprRenderer->applyMonitorRule(self.lock(), (SMonitorRule*)&RULE, true); // will apply the offset and stuff
    } else {
        PHLMONITOR BACKUPMON = nullptr;
        for (auto const& m : g_pCompositor->m_vMonitors) {
@@ -1012,7 +539,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
        }

        // move all the WS
-        std::vector<PHLWORKSPACE> wspToMove;
+        std::deque<PHLWORKSPACE> wspToMove;
        for (auto const& w : g_pCompositor->m_vWorkspaces) {
            if (w->m_pMonitor == self || !w->m_pMonitor)
                wspToMove.push_back(w);
@@ -1080,17 +607,15 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
    if (pWorkspace == activeWorkspace)
        return;

-    const auto POLDWORKSPACE = activeWorkspace;
-    if (POLDWORKSPACE)
-        POLDWORKSPACE->m_bVisible = false;
-    pWorkspace->m_bVisible = true;
+    const auto POLDWORKSPACE  = activeWorkspace;
+    POLDWORKSPACE->m_bVisible = false;
+    pWorkspace->m_bVisible    = true;

    activeWorkspace = pWorkspace;

    if (!internal) {
-        const auto ANIMTOLEFT = POLDWORKSPACE && pWorkspace->m_iID > POLDWORKSPACE->m_iID;
-        if (POLDWORKSPACE)
-            POLDWORKSPACE->startAnim(false, ANIMTOLEFT);
+        const auto ANIMTOLEFT = pWorkspace->m_iID > POLDWORKSPACE->m_iID;
+        POLDWORKSPACE->startAnim(false, ANIMTOLEFT);
        pWorkspace->startAnim(true, ANIMTOLEFT);

        // move pinned windows
@@ -1102,17 +627,17 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
        if (!noFocus && !g_pCompositor->m_pLastMonitor->activeSpecialWorkspace &&
            !(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_pMonitor == self)) {
            static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
-            auto        pWindow      = pWorkspace->m_bHasFullscreenWindow ? pWorkspace->getFullscreenWindow() : pWorkspace->getLastFocusedWindow();
+            auto        pWindow      = pWorkspace->getLastFocusedWindow();

            if (!pWindow) {
                if (*PFOLLOWMOUSE == 1)
                    pWindow = g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING);

                if (!pWindow)
-                    pWindow = pWorkspace->getTopLeftWindow();
+                    pWindow = g_pCompositor->getTopLeftWindowOnWorkspace(pWorkspace->m_iID);

                if (!pWindow)
-                    pWindow = pWorkspace->getFirstWindow();
+                    pWindow = g_pCompositor->getFirstWindowOnWorkspace(pWorkspace->m_iID);
            }

            g_pCompositor->focusWindow(pWindow);
@@ -1156,7 +681,6 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
            activeSpecialWorkspace->m_bVisible = false;
            activeSpecialWorkspace->startAnim(false, false);
            g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + szName});
-            g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + szName});
        }
        activeSpecialWorkspace.reset();

@@ -1186,13 +710,12 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
    bool animate = true;
    //close if open elsewhere
    const auto PMONITORWORKSPACEOWNER = pWorkspace->m_pMonitor.lock();
-    if (const auto PMWSOWNER = pWorkspace->m_pMonitor.lock(); PMWSOWNER && PMWSOWNER->activeSpecialWorkspace == pWorkspace) {
-        PMWSOWNER->activeSpecialWorkspace.reset();
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMWSOWNER->ID);
-        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMWSOWNER->szName});
-        g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + PMWSOWNER->szName});
+    if (PMONITORWORKSPACEOWNER->activeSpecialWorkspace == pWorkspace) {
+        PMONITORWORKSPACEOWNER->activeSpecialWorkspace.reset();
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITORWORKSPACEOWNER->ID);
+        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMONITORWORKSPACEOWNER->szName});

-        const auto PACTIVEWORKSPACE = PMWSOWNER->activeWorkspace;
+        const auto PACTIVEWORKSPACE = PMONITORWORKSPACEOWNER->activeWorkspace;
        g_pCompositor->updateFullscreenFadeOnWorkspace(PACTIVEWORKSPACE);

        animate = false;
@@ -1215,16 +738,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;
            }
        }
    }
@@ -1239,7 +762,6 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
    }

    g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_szName + "," + szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_iID) + "," + pWorkspace->m_szName + "," + szName});

    g_pHyprRenderer->damageMonitor(self.lock());

@@ -1258,29 +780,6 @@ 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;
 }
@@ -1341,43 +840,23 @@ bool CMonitor::attemptDirectScanout() {

    const auto PSURFACE = g_pXWaylandManager->getWindowSurface(PCANDIDATE);

-    if (!PSURFACE || !PSURFACE->current.texture || !PSURFACE->current.buffer)
-        return false;
-
-    if (PSURFACE->current.bufferSize != vecPixelSize || PSURFACE->current.transform != transform)
+    if (!PSURFACE || !PSURFACE->current.buffer || PSURFACE->current.bufferSize != vecPixelSize || PSURFACE->current.transform != transform)
        return false;

    // we can't scanout shm buffers.
-    const auto params = PSURFACE->current.buffer->buffer->dmabuf();
-    if (!params.success || !PSURFACE->current.texture->m_pEglImage /* dmabuf */)
+    if (!PSURFACE->current.buffer || !PSURFACE->current.buffer->buffer || !PSURFACE->current.texture || !PSURFACE->current.texture->m_pEglImage /* dmabuf */)
        return false;

-    Debug::log(TRACE, "attemptDirectScanout: surface {:x} passed, will attempt, buffer {}", (uintptr_t)PSURFACE.get(), (uintptr_t)PSURFACE->current.buffer->buffer.get());
-
-    auto PBUFFER = PSURFACE->current.buffer->buffer;
-
-    if (PBUFFER == output->state->state().buffer) {
-        if (scanoutNeedsCursorUpdate) {
-            if (!state.test()) {
-                Debug::log(TRACE, "attemptDirectScanout: failed basic test");
-                return false;
-            }
-
-            if (!output->commit()) {
-                Debug::log(TRACE, "attemptDirectScanout: failed to commit cursor update");
-                lastScanout.reset();
-                return false;
-            }
-
-            scanoutNeedsCursorUpdate = false;
-        }
-
-        return true;
-    }
+    Debug::log(TRACE, "attemptDirectScanout: surface {:x} passed, will attempt", (uintptr_t)PSURFACE.get());

    // FIXME: make sure the buffer actually follows the available scanout dmabuf formats
    // and comes from the appropriate device. This may implode on multi-gpu!!

+    const auto params = PSURFACE->current.buffer->buffer->dmabuf();
+    // scanout buffer isn't dmabuf, so no scanout
+    if (!params.success)
+        return false;
+
    // entering into scanout, so save monitor format
    if (lastScanout.expired())
        prevDrmFormat = drmFormat;
@@ -1387,7 +866,7 @@ bool CMonitor::attemptDirectScanout() {
        drmFormat = params.format;
    }

-    output->state->setBuffer(PBUFFER);
+    output->state->setBuffer(PSURFACE->current.buffer->buffer.lock());
    output->state->setPresentationMode(tearingState.activelyTearing ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
                                                                      Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);

@@ -1396,28 +875,34 @@ bool CMonitor::attemptDirectScanout() {
        return false;
    }

+    auto explicitOptions = g_pHyprRenderer->getExplicitSyncSettings();
+
+    // wait for the explicit fence if present, and if kms explicit is allowed
+    bool DOEXPLICIT = PSURFACE->syncobj && PSURFACE->syncobj->current.acquireTimeline && PSURFACE->syncobj->current.acquireTimeline->timeline && explicitOptions.explicitKMSEnabled;
+    int  explicitWaitFD = -1;
+    if (DOEXPLICIT) {
+        explicitWaitFD = PSURFACE->syncobj->current.acquireTimeline->timeline->exportAsSyncFileFD(PSURFACE->syncobj->current.acquirePoint);
+        if (explicitWaitFD < 0)
+            Debug::log(TRACE, "attemptDirectScanout: failed to acquire an explicit wait fd");
+    }
+    DOEXPLICIT = DOEXPLICIT && explicitWaitFD >= 0;
+
+    auto     cleanup = CScopeGuard([explicitWaitFD, this]() {
+        output->state->resetExplicitFences();
+        if (explicitWaitFD >= 0)
+            close(explicitWaitFD);
+    });
+
    timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    PSURFACE->presentFeedback(&now, self.lock());

-    output->state->addDamage(PSURFACE->current.accumulateBufferDamage());
+    output->state->addDamage(CBox{{}, vecPixelSize});
    output->state->resetExplicitFences();

-    auto cleanup = CScopeGuard([this]() { output->state->resetExplicitFences(); });
-
-    auto explicitOptions = g_pHyprRenderer->getExplicitSyncSettings(output);
-
-    bool DOEXPLICIT = PSURFACE->syncobj && PSURFACE->current.buffer && PSURFACE->current.buffer->acquire && explicitOptions.explicitKMSEnabled;
    if (DOEXPLICIT) {
-        // wait for surface's explicit fence if present
-        inFence = PSURFACE->current.buffer->acquire->exportAsFD();
-        if (inFence.isValid()) {
-            Debug::log(TRACE, "attemptDirectScanout: setting IN_FENCE for aq to {}", inFence.get());
-            output->state->setExplicitInFence(inFence.get());
-        } else {
-            Debug::log(TRACE, "attemptDirectScanout: failed to acquire an sync file fd for aq IN_FENCE");
-            DOEXPLICIT = false;
-        }
+        Debug::log(TRACE, "attemptDirectScanout: setting IN_FENCE for aq to {}", explicitWaitFD);
+        output->state->setExplicitInFence(explicitWaitFD);
    }

    bool ok = output->commit();
@@ -1429,27 +914,29 @@ bool CMonitor::attemptDirectScanout() {
        ok = output->commit();
    }

-    if (!ok) {
+    if (ok) {
+        if (lastScanout.expired()) {
+            lastScanout = PCANDIDATE;
+            Debug::log(LOG, "Entered a direct scanout to {:x}: \"{}\"", (uintptr_t)PCANDIDATE.get(), PCANDIDATE->m_szTitle);
+        }
+
+        // delay explicit sync feedback until kms release of the buffer
+        if (DOEXPLICIT) {
+            Debug::log(TRACE, "attemptDirectScanout: Delaying explicit sync release feedback until kms release");
+            PSURFACE->current.buffer->releaser->drop();
+
+            PSURFACE->current.buffer->buffer->hlEvents.backendRelease2 = PSURFACE->current.buffer->buffer->events.backendRelease.registerListener([PSURFACE](std::any d) {
+                const bool DOEXPLICIT = PSURFACE->syncobj && PSURFACE->syncobj->current.releaseTimeline && PSURFACE->syncobj->current.releaseTimeline->timeline;
+                if (DOEXPLICIT)
+                    PSURFACE->syncobj->current.releaseTimeline->timeline->signal(PSURFACE->syncobj->current.releasePoint);
+            });
+        }
+    } else {
        Debug::log(TRACE, "attemptDirectScanout: failed to scanout surface");
        lastScanout.reset();
        return false;
    }

-    if (lastScanout.expired()) {
-        lastScanout = PCANDIDATE;
-        Debug::log(LOG, "Entered a direct scanout to {:x}: \"{}\"", (uintptr_t)PCANDIDATE.get(), PCANDIDATE->m_szTitle);
-    }
-
-    scanoutNeedsCursorUpdate = false;
-
-    if (!PBUFFER->lockedByBackend || PBUFFER->hlEvents.backendRelease)
-        return true;
-
-    // lock buffer while DRM/KMS is using it, then release it when page flip happens since DRM/KMS should be done by then
-    // btw buffer's syncReleaser will take care of signaling release point, so we don't do that here
-    PBUFFER->lock();
-    PBUFFER->onBackendRelease([PBUFFER]() { PBUFFER->unlock(); });
-
    return true;
 }

@@ -1521,25 +1008,11 @@ void CMonitor::onMonitorFrame() {
        g_pHyprRenderer->renderMonitor(self.lock());
 }

-void CMonitor::onCursorMovedOnMonitor() {
-    if (!tearingState.activelyTearing || !solitaryClient || !g_pHyprRenderer->shouldRenderCursor())
-        return;
-
-    // submit a frame immediately. This will only update the cursor pos.
-    // output->state->setBuffer(output->state->state().buffer);
-    // output->state->addDamage(CRegion{});
-    // output->state->setPresentationMode(Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE);
-    // if (!output->commit())
-    //     Debug::log(ERR, "onCursorMovedOnMonitor: tearing and wanted to update cursor, failed.");
-
-    // FIXME: try to do the above. We currently can't just render because drm is a fucking bitch
-    // and throws a "nO pRoP cAn Be ChAnGeD dUrInG AsYnC fLiP" on crtc_x
-    // this will throw too but fix it if we use sw cursors
-
-    tearingState.frameScheduledWhileBusy = true;
+CMonitorState::CMonitorState(CMonitor* owner) {
+    m_pOwner = owner;
 }

-CMonitorState::CMonitorState(CMonitor* owner) : m_pOwner(owner) {
+CMonitorState::~CMonitorState() {
    ;
 }

--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -1,26 +1,22 @@
 #pragma once

 #include "../defines.hpp"
-#include <stack>
-#include <vector>
-#include "../SharedDefs.hpp"
-#include "MiscFunctions.hpp"
+#include <deque>
 #include "WLClasses.hpp"
+#include <vector>
 #include <array>
-
+#include <memory>
 #include <xf86drmMode.h>
 #include "Timer.hpp"
 #include "math/Math.hpp"
 #include <optional>
-#include "../protocols/types/ColorManagement.hpp"
 #include "signal/Signal.hpp"
 #include "DamageRing.hpp"
 #include <aquamarine/output/Output.hpp>
 #include <aquamarine/allocator/Swapchain.hpp>
-#include <hyprutils/os/FileDescriptor.hpp>

 // Enum for the different types of auto directions, e.g. auto-left, auto-up.
-enum eAutoDirs : uint8_t {
+enum eAutoDirs {
    DIR_AUTO_NONE = 0, /* None will be treated as right. */
    DIR_AUTO_UP,
    DIR_AUTO_DOWN,
@@ -28,41 +24,28 @@ enum eAutoDirs : uint8_t {
    DIR_AUTO_RIGHT
 };

-enum eCMType : uint8_t {
-    CM_AUTO = 0, // subject to change. srgb for 8bpc, wide for 10bpc if supported
-    CM_SRGB,     // default, sRGB primaries
-    CM_WIDE,     // wide color gamut, BT2020 primaries
-    CM_EDID,     // primaries from edid (known to be inaccurate)
-    CM_HDR,      // wide color gamut and HDR PQ transfer function
-    CM_HDR_EDID, // same as CM_HDR with edid primaries
-};
-
 struct SMonitorRule {
-    eAutoDirs           autoDir       = DIR_AUTO_NONE;
-    std::string         name          = "";
-    Vector2D            resolution    = Vector2D(1280, 720);
-    Vector2D            offset        = Vector2D(0, 0);
-    float               scale         = 1;
-    float               refreshRate   = 60; // Hz
-    bool                disabled      = false;
-    wl_output_transform transform     = WL_OUTPUT_TRANSFORM_NORMAL;
-    std::string         mirrorOf      = "";
-    bool                enable10bit   = false;
-    eCMType             cmType        = CM_SRGB;
-    float               sdrSaturation = 1.0f; // SDR -> HDR
-    float               sdrBrightness = 1.0f; // SDR -> HDR
-    drmModeModeInfo     drmMode       = {};
+    eAutoDirs           autoDir     = DIR_AUTO_NONE;
+    std::string         name        = "";
+    Vector2D            resolution  = Vector2D(1280, 720);
+    Vector2D            offset      = Vector2D(0, 0);
+    float               scale       = 1;
+    float               refreshRate = 60;
+    bool                disabled    = false;
+    wl_output_transform transform   = WL_OUTPUT_TRANSFORM_NORMAL;
+    std::string         mirrorOf    = "";
+    bool                enable10bit = false;
+    drmModeModeInfo     drmMode     = {};
    std::optional<int>  vrr;
 };

 class CMonitor;
 class CSyncTimeline;
-class CEGLSync;

 class CMonitorState {
  public:
    CMonitorState(CMonitor* owner);
-    ~CMonitorState() = default;
+    ~CMonitorState();

    bool commit();
    bool test();
@@ -106,8 +89,10 @@ class CMonitor {
    CDamageRing                 damage;

    SP<Aquamarine::IOutput>     output;
-    float                       refreshRate     = 60; // Hz
+    float                       refreshRate     = 60;
+    int                         framesToSkip    = 0;
    int                         forceFullFrames = 0;
+    bool                        noFrameSchedule = false;
    bool                        scheduledRecalc = false;
    wl_output_transform         transform       = WL_OUTPUT_TRANSFORM_NORMAL;
    float                       xwaylandScale   = 1.f;
@@ -121,9 +106,6 @@ class CMonitor {
    bool                        dpmsStatus       = true;
    bool                        vrrActive        = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
    bool                        enabled10bit     = false; // as above, this can be TRUE even if 10 bit failed.
-    eCMType                     cmType           = CM_SRGB;
-    float                       sdrSaturation    = 1.0f;
-    float                       sdrBrightness    = 1.0f;
    bool                        createdByUser    = false;
    bool                        isUnsafeFallback = false;

@@ -139,12 +121,11 @@ class CMonitor {
    SMonitorRule                activeMonitorRule;

    // explicit sync
-    SP<CSyncTimeline>              inTimeline;
-    Hyprutils::OS::CFileDescriptor inFence;
-    SP<CEGLSync>                   eglSync;
-    uint64_t                       inTimelinePoint = 0;
+    SP<CSyncTimeline> inTimeline;
+    SP<CSyncTimeline> outTimeline;
+    uint64_t          commitSeq = 0;

-    PHLMONITORREF                  self;
+    PHLMONITORREF     self;

    // mirroring
    PHLMONITORREF              pMirrorOf;
@@ -159,7 +140,6 @@ class CMonitor {

    // for direct scanout
    PHLWINDOWREF lastScanout;
-    bool         scanoutNeedsCursorUpdate = false;

    struct {
        bool canTear         = false;
@@ -181,39 +161,35 @@ class CMonitor {
    std::array<std::vector<PHLLSREF>, 4> m_aLayerSurfaceLayers;

    // 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);
-    bool                                shouldSkipScheduleFrameOnMouseEvent();
-    void                                setMirror(const std::string&);
-    bool                                isMirror();
-    bool                                matchesStaticSelector(const std::string& selector) const;
-    float                               getDefaultScale();
-    void                                changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal = false, bool noMouseMove = false, bool noFocus = false);
-    void                                changeWorkspace(const WORKSPACEID& id, bool internal = false, bool noMouseMove = false, bool noFocus = false);
-    void                                setSpecialWorkspace(const PHLWORKSPACE& pWorkspace);
-    void                                setSpecialWorkspace(const WORKSPACEID& id);
-    void                                moveTo(const Vector2D& pos);
-    Vector2D                            middle();
-    void                                updateMatrix();
-    WORKSPACEID                         activeWorkspaceID();
-    WORKSPACEID                         activeSpecialWorkspaceID();
-    CBox                                logicalBox();
-    void                                scheduleDone();
-    bool                                attemptDirectScanout();
-    void                                setCTM(const Mat3x3& ctm);
-    void                                onCursorMovedOnMonitor();
+    void        onConnect(bool noRule);
+    void        onDisconnect(bool destroy = false);
+    void        addDamage(const pixman_region32_t* rg);
+    void        addDamage(const CRegion* rg);
+    void        addDamage(const CBox* box);
+    bool        shouldSkipScheduleFrameOnMouseEvent();
+    void        setMirror(const std::string&);
+    bool        isMirror();
+    bool        matchesStaticSelector(const std::string& selector) const;
+    float       getDefaultScale();
+    void        changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal = false, bool noMouseMove = false, bool noFocus = false);
+    void        changeWorkspace(const WORKSPACEID& id, bool internal = false, bool noMouseMove = false, bool noFocus = false);
+    void        setSpecialWorkspace(const PHLWORKSPACE& pWorkspace);
+    void        setSpecialWorkspace(const WORKSPACEID& id);
+    void        moveTo(const Vector2D& pos);
+    Vector2D    middle();
+    void        updateMatrix();
+    WORKSPACEID activeWorkspaceID();
+    WORKSPACEID activeSpecialWorkspaceID();
+    CBox        logicalBox();
+    void        scheduleDone();
+    bool        attemptDirectScanout();
+    void        setCTM(const Mat3x3& ctm);

-    void                                debugLastPresentation(const std::string& message);
-    void                                onMonitorFrame();
+    void        debugLastPresentation(const std::string& message);
+    void        onMonitorFrame();

-    bool                                m_bEnabled             = false;
-    bool                                m_bRenderingInitPassed = false;
-    WP<CWindow>                         m_previousFSWindow;
-    NColorManagement::SImageDescription imageDescription;
+    bool        m_bEnabled             = false;
+    bool        m_bRenderingInitPassed = false;

    // For the list lookup

@@ -221,16 +197,11 @@ class CMonitor {
        return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName;
    }

-    // workspace previous per monitor functionality
-    SWorkspaceIDName getPrevWorkspaceIDName(const WORKSPACEID id);
-    void             addPrevWorkspaceID(const WORKSPACEID id);
-
  private:
-    void                    setupDefaultWS(const SMonitorRule&);
-    WORKSPACEID             findAvailableDefaultWS();
+    void        setupDefaultWS(const SMonitorRule&);
+    WORKSPACEID findAvailableDefaultWS();

-    bool                    doneScheduled = false;
-    std::stack<WORKSPACEID> prevWorkSpaces;
+    bool        doneScheduled = false;

    struct {
        CHyprSignalListener frame;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
vaxerski	12f9a0d0b9	[gha] Nix: update inputs	2024-11-19 21:47:18 +00:00
Vaxry	fab0f426b5	version: bump to 0.45.2	2024-11-19 21:45:40 +00:00
Vaxry	e735eae4ad	xdg-shell: don't report invalid min/max sizes on unset fixes #8522	2024-11-19 21:45:20 +00:00
Aqa-Ib	57cf6d81a9	internal: fix changeWindowZOrder reordering incorrectly (#8494 )	2024-11-19 21:45:20 +00:00
Vaxry	77b9d03c3f	version: bump to 0.45.1	2024-11-18 14:27:21 +00:00
johannes hanika	53e8513000	constraints: don't warp pointer position on release (#8491 ) this was annoying for nuklear properties/ui slider elements that grab the pointer via GLFW_CURSOR_DISABLE to allow more range and finer control. upon mouse release, the pointer is reset to the middle of the window without this patch, making long mouse movements necessary to go back to the original position for readjustments. fwiw the new behaviour is consistent with x11 and weston.	2024-11-18 14:26:44 +00:00
Vaxry	7976bfa2df	shell: don't use fgrep, prefer grep -F	2024-11-18 14:26:44 +00:00
Vaxry	a77ffa8cb8	windows/xdg: minor cleanup of min/max size calculations fixes #8495	2024-11-18 14:26:44 +00:00
Vaxry	a4a1ad1f9b	hyprpm: fix format crash ref #8487	2024-11-18 14:26:44 +00:00
Vaxry	737b51d032	renderer: don't render unmapped popups fixes #8485	2024-11-18 14:26:44 +00:00
staz	b3251f2961	workspacerules: Do not check 'on-created-empty' if using a workspace windowrule (#8486 )	2024-11-18 14:26:44 +00:00
Vaxry	c4a77b8da7	core: guard pmonitor in focuswindow may be null fixes #8483	2024-11-18 14:26:44 +00:00
sslater11	38b6f3babb	workspace: fix missing name via focusworkspaceoncurrentmonitor (#8484 )	2024-11-18 14:26:44 +00:00
Vaxry	ace7ece4f2	protocols: mark primarySelection as not privileged fixes #8479	2024-11-18 14:26:44 +00:00
Tom Englund	0557b2ed8c	xcursors: store themes in a std:set to order it (#8474 ) using a unordered_set means its store based on a hash_value meaning currently it can end up loading inherited themes before the actual theme itself depending on the hash of the theme name used, reason for using set at all over vector is to keep unique members and not foreverever looping broken inherit themeing.	2024-11-18 14:26:44 +00:00
Vaxry	9728a39b2e	makefile: add stub to discourage direct make	2024-11-18 14:26:44 +00:00
dawsers	7120dde3d1	renderer: scaled surfaces could have zero area (#8423 )	2024-11-18 14:26:44 +00:00
Vaxry	e7ab2d8533	defaultConfig: fixup smart gaps rules	2024-11-18 14:26:44 +00:00
@@ -1 +1 @@
 .48.0
 .45.2