props: bump ver to 0.39.0

modified:   src/render/Renderer.cpp

.github/ISSUE_TEMPLATE/bug.yml

@@ -13,7 +13,7 @@ body:
     id: ver
     attributes:
       label: Hyprland Version
-      description: "Paste here the output of `hyprctl version`. For hyprland after 0.34.0, paste `hyprctl systeminfo` instead."
+      description: "Paste the output of `hyprctl systeminfo` here."
       value: "<details>
         <summary>System/Version info</summary>
 
@@ -63,5 +63,5 @@ body:
       description: |
         Anything that can help. Please always ATTACH and not paste them.
         Logs can be found in /tmp/hypr
-        Crash reports are stored in ~/.hyprland or $XDG_CACHE_HOME/hyprland
+        Crash reports are stored in ~/.cache/hyprland or $XDG_CACHE_HOME/hyprland
 

.github/actions/setup_base/action.yml

@@ -12,6 +12,7 @@ runs:
     - name: Get required pacman pkgs
       shell: bash
       run: |
+        sed -i -e "1i [extra-testing]\nInclude = /etc/pacman.d/mirrorlist" "/etc/pacman.conf"
         sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
         pacman --noconfirm --noprogressbar -Syyu
         pacman --noconfirm --noprogressbar -Sy \
@@ -23,6 +24,7 @@ runs:
           glm \
           glslang \
           go \
+          hyprlang \
           jq \
           libc++ \
           libdisplay-info \
@@ -50,7 +52,20 @@ runs:
           wayland-protocols \
           xcb-util-errors \
           xcb-util-renderutil \
-          xcb-util-wm
+          xcb-util-wm \
+          xcb-util \
+          xcb-util-image \
+          libzip \
+          librsvg
+
+    - name: Get hyprcursor-git
+      shell: bash
+      run: |
+        git clone https://github.com/hyprwm/hyprcursor --recursive
+        cd hyprcursor
+        cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build
+        cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+        cmake --install build
 
     - name: Get Xorg pacman pkgs
       shell: bash

.github/workflows/ci.yaml

@@ -31,7 +31,7 @@ jobs:
           cp ./LICENSE hyprland/
           cp build/Hyprland hyprland/
           cp build/hyprctl/hyprctl hyprland/
-          cp subprojects/wlroots/build/libwlroots.so.13032 hyprland/
+          cp build/hyprpm/hyprpm hyprland/
           cp build/Hyprland hyprland/
           cp -r example/ hyprland/
           cp -r assets/ hyprland/

.github/workflows/nix-build.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           ref: ${{ github.ref }}
 
-      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: cachix/install-nix-action@v25
       - uses: DeterminateSystems/magic-nix-cache-action@main
       - uses: cachix/cachix-action@v12
         with:

.github/workflows/security-checks.yml

@@ -24,44 +24,3 @@ jobs:
         uses: github/codeql-action/upload-sarif@v2
         with:
           sarif_file: ${{github.workspace}}/flawfinder_results.sarif
-
-  codeql:
-    name: CodeQL
-    runs-on: ubuntu-latest
-    container:
-      image: archlinux
-
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'cpp' ]
-
-    steps:
-    - name: Checkout repository actions
-      uses: actions/checkout@v4
-      with:
-        sparse-checkout: .github/actions
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-
-    - name: Setup base
-      uses: ./.github/actions/setup_base
-      with:
-        INSTALL_XORG_PKGS: true
-
-    - name: Build Hyprland
-      run: |
-        make all
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"

.gitignore

@@ -31,3 +31,5 @@ gmon.out
 PKGBUILD
 
 src/version.h
+
+.direnv

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "wlroots"]
-	path = subprojects/wlroots
-	url = https://gitlab.freedesktop.org/wlroots/wlroots.git
 [submodule "subprojects/hyprland-protocols"]
 	path = subprojects/hyprland-protocols
 	url = https://github.com/hyprwm/hyprland-protocols
@@ -10,3 +7,6 @@
 [submodule "subprojects/tracy"]
 	path = subprojects/tracy
 	url = https://github.com/wolfpld/tracy
+[submodule "subprojects/wlroots-hyprland"]
+	path = subprojects/wlroots-hyprland
+	url = https://github.com/hyprwm/wlroots-hyprland

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.19)
+cmake_minimum_required(VERSION 3.27)
 include(CheckIncludeFile)
 
 # Get version
@@ -54,25 +54,22 @@ else()
 endif()
 
 ExternalProject_Add(
-    wlroots
-    PREFIX ${CMAKE_SOURCE_DIR}/subprojects/wlroots
-    SOURCE_DIR ${CMAKE_SOURCE_DIR}/subprojects/wlroots
-    PATCH_COMMAND sed -E -i -e "s/(soversion = .*$)/soversion = 13032/g" meson.build
-    CONFIGURE_COMMAND meson setup --reconfigure build --buildtype=${BUILDTYPE_LOWER} -Dwerror=false -Dxwayland=$<IF:$<BOOL:${NO_XWAYLAND}>,disabled,enabled> -Dexamples=false -Drenderers=gles2 $<IF:$<BOOL:${WITH_ASAN}>,-Db_sanitize=address,-Db_sanitize=none>
+    wlroots-hyprland
+    PREFIX ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland
+    SOURCE_DIR ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland
+    CONFIGURE_COMMAND meson setup --reconfigure build --buildtype=${BUILDTYPE_LOWER} -Dwerror=false -Dxwayland=$<IF:$<BOOL:${NO_XWAYLAND}>,disabled,enabled> -Dexamples=false -Drenderers=gles2 -Dbackends=drm,libinput $<IF:$<BOOL:${WITH_ASAN}>,-Db_sanitize=address,-Db_sanitize=none>
     BUILD_COMMAND ninja -C build
     BUILD_ALWAYS true
     BUILD_IN_SOURCE true
-    BUILD_BYPRODUCTS ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.13032
-    INSTALL_COMMAND echo "wlroots: install not needed"
+    BUILD_BYPRODUCTS ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland/build/libwlroots.a
+    INSTALL_COMMAND echo "wlroots-hyprland: install not needed"
 )
 
-find_program(WaylandScanner NAMES wayland-scanner)
+find_package(PkgConfig REQUIRED)
+
+pkg_get_variable(WaylandScanner wayland-scanner wayland_scanner)
 message(STATUS "Found WaylandScanner at ${WaylandScanner}")
-execute_process(
-    COMMAND pkg-config --variable=pkgdatadir wayland-protocols
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE WAYLAND_PROTOCOLS_DIR
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+pkg_get_variable(WAYLAND_PROTOCOLS_DIR wayland-protocols pkgdatadir)
 message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}")
 
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
@@ -86,22 +83,34 @@ endif()
 include_directories(
   .
   "src/"
-  "subprojects/wlroots/include/"
-  "subprojects/wlroots/build/include/"
+  "subprojects/wlroots-hyprland/include/"
+  "subprojects/wlroots-hyprland/build/include/"
   "subprojects/udis86/"
   "protocols/")
 set(CMAKE_CXX_STANDARD 23)
 add_compile_definitions(WLR_USE_UNSTABLE)
 add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing -Wno-pointer-arith)
-add_link_options(-rdynamic)
-set(CMAKE_ENABLE_EXPORTS TRUE)
+
+set(CMAKE_EXECUTABLE_ENABLE_EXPORTS TRUE)
 
 message(STATUS "Checking deps...")
 
 find_package(Threads REQUIRED)
-find_package(PkgConfig REQUIRED)
-find_package(OpenGL REQUIRED)
-pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo libdrm xkbcommon libinput pango pangocairo pixman-1) # we do not check for wlroots, as we provide it ourselves
+
+if(LEGACY_RENDERER)
+    set(GLES_VERSION "GLES2")
+else()
+    set(GLES_VERSION "GLES3")
+endif()
+find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
+
+pkg_check_modules(deps REQUIRED IMPORTED_TARGET
+    xkbcommon
+    wayland-server wayland-client wayland-cursor wayland-protocols
+    cairo pango pangocairo pixman-1
+    libdrm libinput hwdata libseat libdisplay-info libliftoff libudev gbm
+    hyprlang>=0.3.2 hyprcursor
+)
 
 file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 
@@ -112,7 +121,7 @@ if(USE_TRACY)
 endif()
 
 add_executable(Hyprland ${SRCFILES} ${TRACY_CPP_FILES})
-add_dependencies(Hyprland wlroots)
+add_dependencies(Hyprland wlroots-hyprland)
 
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
     message(STATUS "Setting debug flags")
@@ -165,8 +174,12 @@ if(NO_XWAYLAND)
     add_compile_definitions(NO_XWAYLAND)
 else()
     message(STATUS "XWAYLAND Enabled (NO_XWAYLAND not defined) checking deps...")
-    pkg_check_modules(xcbdep REQUIRED IMPORTED_TARGET xcb)
-    target_link_libraries(Hyprland PkgConfig::xcbdep)
+    pkg_check_modules(xdeps REQUIRED IMPORTED_TARGET xcb xwayland xcb-util xcb-render xcb-image xcb-xfixes xcb-icccm xcb-composite xcb-res xcb-ewmh)
+    pkg_check_modules(xcb_errors IMPORTED_TARGET xcb-errors)
+    target_link_libraries(Hyprland PkgConfig::xdeps)
+    if(xcb_errors_FOUND)
+        target_link_libraries(Hyprland PkgConfig::xcb_errors)
+    endif()
 endif()
 
 if(NO_SYSTEMD)
@@ -221,7 +234,7 @@ function(protocol protoPath protoName external)
 endfunction()
 
 target_link_libraries(Hyprland
-        ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.13032 # wlroots is provided by us
+        ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland/build/libwlroots.a
         OpenGL::EGL
         OpenGL::GL
         Threads::Threads

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022-2023, vaxerski
+Copyright (c) 2022-2024, vaxerski
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile

@@ -23,7 +23,7 @@ debug:
 clear:
 	rm -rf build
 	rm -f ./protocols/*-protocol.h ./protocols/*-protocol.c
-	rm -rf ./subprojects/wlroots/build
+	rm -rf ./subprojects/wlroots-hyprland/build
 
 all:
 	@if [[ "$EUID" = 0 ]]; then echo -en "Avoid running $(MAKE) all as sudo.\n"; fi
@@ -36,15 +36,24 @@ install:
 
 	mkdir -p ${PREFIX}/share/wayland-sessions
 	mkdir -p ${PREFIX}/bin
+	mkdir -p ${PREFIX}/share/hyprland
+	mkdir -p ${PREFIX}/share/bash-completion/completions
+	mkdir -p ${PREFIX}/share/fish/vendor_completions.d
+	mkdir -p ${PREFIX}/share/zsh/site-functions
 	cp -f ./build/Hyprland ${PREFIX}/bin
 	cp -f ./build/hyprctl/hyprctl ${PREFIX}/bin
 	cp -f ./build/hyprpm/hyprpm ${PREFIX}/bin
+	cp -f ./hyprctl/hyprctl.bash ${PREFIX}/share/bash-completion/completions/hyprctl
+	cp -f ./hyprctl/hyprctl.fish ${PREFIX}/share/fish/vendor_completions.d/hyprctl.fish
+	cp -f ./hyprctl/hyprctl.zsh ${PREFIX}/share/zsh/site-functions/_hyprctl
+	cp -f ./hyprpm/hyprpm.bash ${PREFIX}/share/bash-completion/completions/hyprpm
+	cp -f ./hyprpm/hyprpm.fish ${PREFIX}/share/fish/vendor_completions.d/hyprpm.fish
+	cp -f ./hyprpm/hyprpm.zsh ${PREFIX}/share/zsh/site-functions/_hyprpm
 	chmod 755 ${PREFIX}/bin/Hyprland
 	chmod 755 ${PREFIX}/bin/hyprctl
 	chmod 755 ${PREFIX}/bin/hyprpm
 	cd ${PREFIX}/bin && ln -sf Hyprland hyprland
 	if [ ! -f ${PREFIX}/share/wayland-sessions/hyprland.desktop ]; then cp ./example/hyprland.desktop ${PREFIX}/share/wayland-sessions; fi
-	mkdir -p ${PREFIX}/share/hyprland
 	cp ./assets/wall* ${PREFIX}/share/hyprland
 	mkdir -p ${PREFIX}/share/xdg-desktop-portal
 	cp ./assets/hyprland-portals.conf ${PREFIX}/share/xdg-desktop-portal
@@ -52,9 +61,6 @@ install:
 	mkdir -p ${PREFIX}/share/man/man1
 	install -m644 ./docs/*.1 ${PREFIX}/share/man/man1
 
-	mkdir -p ${PREFIX}/lib/
-	cp ./subprojects/wlroots/build/libwlroots.so.13032 ${PREFIX}/lib/
-
 	$(MAKE) installheaders
 
 uninstall:
@@ -63,10 +69,15 @@ uninstall:
 	rm -f ${PREFIX}/bin/hyprland
 	rm -f ${PREFIX}/bin/hyprctl
 	rm -f ${PREFIX}/bin/hyprpm
-	rm -f ${PREFIX}/lib/libwlroots.so.13032
 	rm -rf ${PREFIX}/share/hyprland
 	rm -f ${PREFIX}/share/man/man1/Hyprland.1
 	rm -f ${PREFIX}/share/man/man1/hyprctl.1
+	rm -f ${PREFIX}/share/bash-completion/completions/hyprctl
+	rm -f ${PREFIX}/share/fish/vendor_completions.d/hyprctl.fish
+	rm -f ${PREFIX}/share/zsh/site-functions/_hyprctl
+	rm -f ${PREFIX}/share/bash-completion/completions/hyprpm
+	rm -f ${PREFIX}/share/fish/vendor_completions.d/hyprpm.fish
+	rm -f ${PREFIX}/share/zsh/site-functions/_hyprpm
 
 pluginenv:
 	@echo -en "$(MAKE) pluginenv has been deprecated.\nPlease run $(MAKE) all && sudo $(MAKE) installheaders\n"
@@ -75,14 +86,15 @@ pluginenv:
 installheaders:
 	@if [ ! -f ./src/version.h ]; then echo -en "You need to run $(MAKE) all first.\n" && exit 1; fi
 
+	rm -fr ${PREFIX}/include/hyprland
 	mkdir -p ${PREFIX}/include/hyprland
 	mkdir -p ${PREFIX}/include/hyprland/protocols
-	mkdir -p ${PREFIX}/include/hyprland/wlroots
+	mkdir -p ${PREFIX}/include/hyprland/wlroots-hyprland
 	mkdir -p ${PREFIX}/share/pkgconfig
 	
 	find src -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
-	cd subprojects/wlroots/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots && cd ../../..
-	cd subprojects/wlroots/build/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots && cd ../../../..
+	cd subprojects/wlroots-hyprland/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots-hyprland && cd ../../..
+	cd subprojects/wlroots-hyprland/build/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots-hyprland && cd ../../../..
 	cp ./protocols/*-protocol.h ${PREFIX}/include/hyprland/protocols
 	cp ./build/hyprland.pc ${PREFIX}/share/pkgconfig
 	if [ -d /usr/share/pkgconfig ]; then cp ./build/hyprland.pc /usr/share/pkgconfig 2>/dev/null || true; fi
@@ -106,3 +118,28 @@ man:
 		--variable=section:1 \
 		--from rst \
 		--to man > ./docs/hyprctl.1
+
+asan:
+	@echo -en "!!WARNING!!\nOnly run this in the TTY.\n"
+	@pidof Hyprland > /dev/null && echo -ne "Refusing to run with Hyprland running.\n" || echo ""
+	@pidof Hyprland > /dev/null && exit 1 || echo ""
+
+	rm -rf ./wayland
+	git reset --hard
+
+	@echo -en "If you want to apply a patch, input its path (leave empty for none):\n"
+	@read patchvar
+	@if [-n "$patchvar"]; then patch -p1 < $patchvar || echo ""; else echo "No patch specified"; fi
+
+	git clone --recursive https://gitlab.freedesktop.org/wayland/wayland
+	cd wayland && patch -p1 < ../scripts/waylandStatic.diff && meson setup build --buildtype=debug -Db_sanitize=address -Ddocumentation=false && ninja -C build && cd ..
+	cp ./wayland/build/src/libwayland-server.a .
+	@echo "Wayland done"
+
+	patch -p1 < ./scripts/hyprlandStaticAsan.diff
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DWITH_ASAN:STRING=True -DUSE_TRACY:STRING=False -DUSE_TRACY_GPU:STRING=False -S . -B ./build -G Ninja
+	cmake --build ./build --config Debug --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+	@echo "Hyprland done"
+
+	ASAN_OPTIONS="detect_odr_violation=0,log_path=asan.log" HYPRLAND_NO_CRASHREPORTER=1 ./build/Hyprland -c ~/.config/hypr/hyprland.conf
+	

README.md

@@ -124,13 +124,13 @@ easy IPC, much more QoL stuff than other wlr-based compositors and more...
 [Wayfire]: https://github.com/WayfireWM/wayfire
 [TinyWl]: https://gitlab.freedesktop.org/wlroots/wlroots/-/blob/master/tinywl/tinywl.c
 [Sway]: https://github.com/swaywm/sway
-[DWL]: https://github.com/djpohly/dwl
+[DWL]: https://codeberg.org/dwl/dwl
 
 <!----------------------------------{ Images }--------------------------------->
 
 [Stars Preview]: https://starchart.cc/vaxerski/Hyprland.svg
 [Preview A]: https://i.ibb.co/C1yTb0r/falf.png
-[Preview B]: https://cdn.discordapp.com/attachments/1091569872535814185/1107675866101723277/screenshot-summer.png
+[Preview B]: https://linfindel.github.io/cdn/hyprland-preview-b.png
 [Preview C]: https://i.ibb.co/B3GJg28/20221126-20h53m26s-grim.png
 
 

docs/ISSUE_GUIDELINES.md

@@ -47,7 +47,7 @@ basically, directories in /tmp/hypr are your sessions.
 
 ## Obtaining the Hyprland Crash Report (v0.22.0beta and up)
 
-If you have `$XDG_CACHE_HOME` set, the crash report directory is `$XDG_CACHE_HOME/hyprland`. If not, it's `~/.hyprland`
+If you have `$XDG_CACHE_HOME` set, the crash report directory is `$XDG_CACHE_HOME/hyprland`. If not, it's `$HOME/.cache/hyprland`.
 
 Go to the crash report directory and you should find a file named `hyprlandCrashReport[XXXX].txt` where `[XXXX]` is the PID of the process that crashed.
 

example/hyprland.conf

@@ -117,7 +117,8 @@ misc {
 
 # Example per-device config
 # See https://wiki.hyprland.org/Configuring/Keywords/#per-device-input-configs for more
-device:epic-mouse-v1 {
+device {
+    name = epic-mouse-v1
     sensitivity = -0.5
 }
 
@@ -126,7 +127,7 @@ device:epic-mouse-v1 {
 # Example windowrule v2
 # windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
 # See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
-windowrulev2 = nomaximizerequest, class:.* # You'll probably like this.
+windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
 
 
 # See https://wiki.hyprland.org/Configuring/Keywords/ for more

flake.lock

@@ -1,5 +1,31 @@
 {
   "nodes": {
+    "hyprcursor": {
+      "inputs": {
+        "hyprlang": [
+          "hyprlang"
+        ],
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1712434681,
+        "narHash": "sha256-qwmR2p1oc48Bj7gUDvb1oGL19Rjs2PmEmk4ChV01A5o=",
+        "owner": "hyprwm",
+        "repo": "hyprcursor",
+        "rev": "818d8c4b69e0997483d60b75f701fe14b561a7a3",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprcursor",
+        "type": "github"
+      }
+    },
     "hyprland-protocols": {
       "inputs": {
         "nixpkgs": [
@@ -26,16 +52,18 @@
     "hyprlang": {
       "inputs": {
         "nixpkgs": [
-          "xdph",
           "nixpkgs"
+        ],
+        "systems": [
+          "systems"
         ]
       },
       "locked": {
-        "lastModified": 1704287638,
-        "narHash": "sha256-TuRXJGwtK440AXQNl5eiqmQqY4LZ/9+z/R7xC0ie3iA=",
+        "lastModified": 1711671891,
+        "narHash": "sha256-C/Wwsy/RLxHP1axFFl+AnwJRWfd8gxDKKoa8nt8Qk3c=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "6624f2bb66d4d27975766e81f77174adbe58ec97",
+        "rev": "c1402612146ba06606ebf64963a02bc1efe11e74",
         "type": "github"
       },
       "original": {
@@ -46,11 +74,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1706191920,
-        "narHash": "sha256-eLihrZAPZX0R6RyM5fYAWeKVNuQPYjAkCUBr+JNvtdE=",
+        "lastModified": 1712439257,
+        "narHash": "sha256-aSpiNepFOMk9932HOax0XwNxbA38GOUVOiXfUVPOrck=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "ae5c332cbb5827f6b1f02572496b141021de335f",
+        "rev": "ff0dbd94265ac470dda06a657d5fe49de93b4599",
         "type": "github"
       },
       "original": {
@@ -62,7 +90,9 @@
     },
     "root": {
       "inputs": {
+        "hyprcursor": "hyprcursor",
         "hyprland-protocols": "hyprland-protocols",
+        "hyprlang": "hyprlang",
         "nixpkgs": "nixpkgs",
         "systems": "systems",
         "wlroots": "wlroots",
@@ -87,20 +117,18 @@
     "wlroots": {
       "flake": false,
       "locked": {
-        "host": "gitlab.freedesktop.org",
-        "lastModified": 1706359063,
-        "narHash": "sha256-5HUTG0p+nCJv3cn73AmFHRZdfRV5AD5N43g8xAePSKM=",
-        "owner": "wlroots",
-        "repo": "wlroots",
-        "rev": "00b869c1a96f300a8f25da95d624524895e0ddf2",
-        "type": "gitlab"
+        "lastModified": 1712935342,
+        "narHash": "sha256-zzIbTFNFd/as42jyGx23fil2uBDYYv+8GA5JmRq5y9c=",
+        "owner": "hyprwm",
+        "repo": "wlroots-hyprland",
+        "rev": "62eeffbe233d199f520a5755c344e85f8eab7940",
+        "type": "github"
       },
       "original": {
-        "host": "gitlab.freedesktop.org",
-        "owner": "wlroots",
-        "repo": "wlroots",
-        "rev": "00b869c1a96f300a8f25da95d624524895e0ddf2",
-        "type": "gitlab"
+        "owner": "hyprwm",
+        "repo": "wlroots-hyprland",
+        "rev": "62eeffbe233d199f520a5755c344e85f8eab7940",
+        "type": "github"
       }
     },
     "xdph": {
@@ -108,7 +136,9 @@
         "hyprland-protocols": [
           "hyprland-protocols"
         ],
-        "hyprlang": "hyprlang",
+        "hyprlang": [
+          "hyprlang"
+        ],
         "nixpkgs": [
           "nixpkgs"
         ],
@@ -117,11 +147,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1706145785,
-        "narHash": "sha256-j9MP4fv2U/vdRKAXXc2gyMTmYwVnHP6kHx1/y6jprrU=",
+        "lastModified": 1709299639,
+        "narHash": "sha256-jYqJM5khksLIbqSxCLUUcqEgI+O2LdlSlcMEBs39CAU=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "5a592647587cd20b9692a347df6939b6d371b3bb",
+        "rev": "2d2fb547178ec025da643db57d40a971507b82fe",
         "type": "github"
       },
       "original": {

flake.nix

@@ -8,25 +8,38 @@
     systems.url = "github:nix-systems/default-linux";
 
     wlroots = {
-      type = "gitlab";
-      host = "gitlab.freedesktop.org";
-      owner = "wlroots";
-      repo = "wlroots";
-      rev = "00b869c1a96f300a8f25da95d624524895e0ddf2";
+      type = "github";
+      owner = "hyprwm";
+      repo = "wlroots-hyprland";
+      rev = "62eeffbe233d199f520a5755c344e85f8eab7940";
       flake = false;
     };
 
+    hyprcursor = {
+      url = "github:hyprwm/hyprcursor";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
+      inputs.hyprlang.follows = "hyprlang";
+    };
+
     hyprland-protocols = {
       url = "github:hyprwm/hyprland-protocols";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.systems.follows = "systems";
     };
 
+    hyprlang = {
+      url = "github:hyprwm/hyprlang";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
+    };
+
     xdph = {
       url = "github:hyprwm/xdg-desktop-portal-hyprland";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.systems.follows = "systems";
       inputs.hyprland-protocols.follows = "hyprland-protocols";
+      inputs.hyprlang.follows = "hyprlang";
     };
   };
 
@@ -64,9 +77,9 @@
         # hyprland-packages
         
         hyprland
-        hyprland-unwrapped
         hyprland-debug
         hyprland-legacy-renderer
+        hyprland-unwrapped
         # hyprland-extras
         
         xdg-desktop-portal-hyprland
@@ -84,9 +97,9 @@
           stdenv = pkgsFor.${system}.gcc13Stdenv;
         } {
           name = "hyprland-shell";
-          nativeBuildInputs = with pkgsFor.${system}; [cmake python3];
+          nativeBuildInputs = with pkgsFor.${system}; [cmake python3 expat libxml2];
           buildInputs = [self.packages.${system}.wlroots-hyprland];
-          hardeningDisable = [ "fortify" ];
+          hardeningDisable = ["fortify"];
           inputsFrom = [
             self.packages.${system}.wlroots-hyprland
             self.packages.${system}.hyprland

hyprctl/Strings.hpp

@@ -0,0 +1,158 @@
+#pragma once
+
+const std::string_view USAGE = R"#(usage: hyprctl [flags] <command> [args...|--help]
+
+commands:
+    activewindow        → Gets the active window name and its properties
+    activeworkspace     → Gets the active workspace and its properties
+    animations          → Gets the current config'd info about animations
+                          and beziers
+    binds               → Lists all registered binds
+    clients             → Lists all windows with their properties
+    configerrors        → Lists all current config parsing errors
+    cursorpos           → Gets the current cursor position in global layout
+                          coordinates
+    decorations <window_regex> → Lists all decorations and their info
+    devices             → Lists all connected keyboards and mice
+    dismissnotify [amount] → Dismisses all or up to AMOUNT notifications
+    dispatch <dispatcher> [args] → Issue a dispatch to call a keybind
+                          dispatcher with arguments
+    getoption <option>  → Gets the config option status (values)
+    globalshortcuts     → Lists all global shortcuts
+    hyprpaper ...       → Issue a hyprpaper request
+    instances           → Lists all running instances of Hyprland with
+                          their info
+    keyword <name> <value> → Issue a keyword to call a config keyword
+                          dynamically
+    kill                → Issue a kill to get into a kill mode, where you can
+                          kill an app by clicking on it. You can exit it
+                          with ESCAPE
+    layers              → Lists all the surface layers
+    layouts             → Lists all layouts available (including plugin'd ones)
+    monitors            → Lists active outputs with their properties,
+                          'monitors all' lists active and inactive outputs
+    notify ...          → Sends a notification using the built-in Hyprland
+                          notification system
+    output ...          → Allows you to add and remove fake outputs to your
+                          preferred backend
+    plugin ...          → Issue a plugin request
+    reload [config-only] → Issue a reload to force reload the config. Pass
+                          'config-only' to disable monitor reload
+    rollinglog          → Prints tail of the log
+    setcursor <theme> <size> → Sets the cursor theme and reloads the cursor
+                          manager
+    seterror <color> <message...> → Sets the hyprctl error string. Color has
+                          the same format as in colors in config. Will reset
+                          when Hyprland's config is reloaded
+    setprop ...         → Sets a window property
+    splash              → Get the current splash
+    switchxkblayout ... → Sets the xkb layout index for a keyboard
+    systeminfo          → Get system info
+    version             → Prints the hyprland version, meaning flags, commit
+                          and branch of build.
+    workspacerules      → Lists all workspace rules
+    workspaces          → Lists all workspaces with their properties
+
+flags:
+    -j                  → Output in JSON
+    -r                  → Refresh state after issuing command (e.g. for
+                          updating variables)
+    --batch             → Execute a batch of commands, separated by ';'
+    --instance (-i)     → use a specific instance. Can be either signature or
+                          index in hyprctl instances (0, 1, etc)
+
+--help:
+    Can be used to print command's arguments that did not fit into this page
+    (three dots))#";
+
+const std::string_view HYPRPAPER_HELP = R"#(usage: hyprctl [flags] hyprpaper <request>
+
+requests:
+    listactive      → Lists all active images
+    listloaded      → Lists all loaded images
+    preload <path>  → Preloads image
+    unload <path>   → Unloads image. Pass 'all' as path to unload all images
+    wallpaper       → Issue a wallpaper to call a config wallpaper dynamically
+
+flags:
+    See 'hyprctl --help')#";
+
+const std::string_view NOTIFY_HELP = R"#(usage: hyprctl [flags] notify <icon> <time_ms> <color> <message...>
+
+icon:
+    Integer of value:
+        0       → Warning
+        1       → Info
+        2       → Hint
+        3       → Error
+        4       → Confused
+        5       → Ok
+        6 or -1 → No icon
+
+time_ms:
+    Time to display notification in milliseconds
+
+color:
+    Notification color. Format is the same as for colors in hyprland.conf. Use
+    0 for default color for icon
+
+message:
+    Notification message
+
+flags:
+    See 'hyprctl --help')#";
+
+const std::string_view OUTPUT_HELP = R"#(usage: hyprctl [flags] output <create <backend> | remove <name>>
+
+create <backend>:
+    Creates new virtual output. Possible values for backend: wayland, x11,
+    headless or auto.
+
+remove <name>:
+    Removes virtual output. Pass the output's name, as found in
+    'hyprctl monitors'
+    
+flags:
+    See 'hyprctl --help')#";
+
+const std::string_view PLUGIN_HELP = R"#(usage: hyprctl [flags] plugin <request>
+
+requests:
+    load <path>     → Loads a plugin. Path must be absolute
+    unload <path>   → Unloads a plugin. Path must be absolute
+    list            → Lists all loaded plugins
+
+flags:
+    See 'hyprctl --help')#";
+
+const std::string_view SETPROP_HELP = R"#(usage: hyprctl [flags] setprop <regex> <property> <value> [lock]
+
+regex:
+    Regular expression by which a window will be searched
+
+property:
+    See https://wiki.hyprland.org/Configuring/Using-hyprctl/#setprop for list
+    of properties
+
+value:
+    Property value
+
+lock:
+    Optional argument. If lock is not added, will be unlocked. Locking means a
+    dynamic windowrule cannot override this setting.
+
+flags:
+    See 'hyprctl --help')#";
+
+const std::string_view SWITCHXKBLAYOUT_HELP = R"#(usage: [flags] switchxkblayout <device> <cmd>
+
+device:
+    You can find the device using 'hyprctl devices' command
+
+cmd:
+    'next' for next, 'prev' for previous, or ID for a specific one. IDs are
+    assigned based on their order in config file (keyboard_layout),
+    starting from 0
+
+flags:
+    See 'hyprctl --help')#";

hyprctl/hyprctl.bash

@@ -0,0 +1,127 @@
+_hyprctl_cmd_2 () {
+    hyprctl monitors | grep Monitor | awk '{ print $2 }'
+}
+
+_hyprctl_cmd_1 () {
+    hyprpm list | grep "Plugin" | awk '{print $4}'
+}
+
+_hyprctl_cmd_0 () {
+    hyprctl clients | grep class | awk '{print $2}'
+}
+
+_hyprctl_cmd_3 () {
+    hyprctl devices | sed -n '/Keyboard at/{n; s/^\s\+//; p}'
+}
+
+_hyprctl () {
+    if [[ $(type -t _get_comp_words_by_ref) != function ]]; then
+        echo _get_comp_words_by_ref: function not defined.  Make sure the bash-completions system package is installed
+        return 1
+    fi
+
+    local words cword
+    _get_comp_words_by_ref -n "$COMP_WORDBREAKS" words cword
+
+    local -a literals=("cyclenext" "globalshortcuts" "cursorpos" "bordersize" "renameworkspace" "animationstyle" "focuswindow" "0" "auto" "swapnext" "forceallowsinput" "moveactive" "activebordercolor" "alphafullscreen" "wayland" "layers" "minsize" "monitors" "1" "kill" "settiled" "3" "focusmonitor" "swapwindow" "moveoutofgroup" "notify" "movecursor" "setcursor" "seterror" "movecurrentworkspacetomonitor" "4" "nomaxsize" "forcenoanims" "setprop" "-i" "togglefloating" "workspacerules" "movetoworkspace" "disable" "setignoregrouplock" "workspaces" "movegroupwindow" "closewindow" "0" "--instance" "binds" "movewindow" "splitratio" "alpha" "denywindowfromgroup" "workspace" "configerrors" "togglegroup" "getoption" "forceopaque" "keepaspectratio" "killactive" "pass" "decorations" "devices" "focuscurrentorlast" "submap" "global" "alphafullscreenoverride" "forcerendererreload" "movewindowpixel" "headless" "version" "dpms" "resizeactive" "moveintogroup" "5" "alphaoverride" "setfloating" "rollinglog" "::=" "rounding" "layouts" "moveworkspacetomonitor" "exec" "alphainactiveoverride" "alterzorder" "fakefullscreen" "nofocus" "keyword" "forcenoborder" "forcenodim" "pin" "output" "forcenoblur" "togglespecialworkspace" "fullscreen" "toggleopaque" "focusworkspaceoncurrentmonitor" "next" "changegroupactive" "-j" "instances" "execr" "exit" "clients" "all" "--batch" "dismissnotify" "inactivebordercolor" "switchxkblayout" "movetoworkspacesilent" "movewindoworgroup" "-r" "movefocus" "focusurgentorlast" "remove" "activeworkspace" "dispatch" "create" "centerwindow" "2" "hyprpaper" "-1" "reload" "alphainactive" "systeminfo" "plugin" "dimaround" "activewindow" "swapactiveworkspaces" "splash" "maxsize" "lockactivegroup" "windowdancecompat" "forceopaqueoverriden" "lockgroups" "movecursortocorner" "x11" "prev" "1" "resizewindowpixel" "forcenoshadow")
+
+    declare -A literal_transitions
+    literal_transitions[0]="([103]=1 [74]=2 [33]=3 [1]=2 [2]=2 [77]=2 [105]=4 [36]=2 [108]=5 [40]=2 [45]=2 [112]=2 [84]=6 [113]=8 [51]=2 [53]=2 [88]=9 [117]=2 [119]=2 [121]=2 [15]=2 [58]=10 [59]=2 [17]=11 [122]=12 [19]=2 [124]=2 [126]=2 [25]=13 [67]=2 [96]=5 [97]=2 [27]=2 [28]=14 [100]=2 [102]=5)"
+    literal_transitions[3]="([72]=18 [13]=2 [32]=18 [54]=18 [55]=18 [89]=18 [104]=2 [120]=2 [76]=1 [16]=2 [123]=18 [3]=1 [5]=2 [63]=18 [127]=2 [129]=18 [80]=18 [130]=18 [83]=18 [31]=18 [48]=2 [12]=2 [85]=18 [10]=18 [86]=18 [137]=18)"
+    literal_transitions[7]="([103]=1 [74]=2 [33]=3 [1]=2 [2]=2 [77]=2 [105]=4 [36]=2 [40]=2 [45]=2 [112]=2 [84]=6 [113]=8 [51]=2 [53]=2 [88]=9 [117]=2 [119]=2 [121]=2 [15]=2 [58]=10 [59]=2 [17]=11 [122]=12 [19]=2 [124]=2 [126]=2 [25]=13 [67]=2 [97]=2 [27]=2 [28]=14 [100]=2)"
+    literal_transitions[8]="([128]=2 [131]=2 [0]=2 [73]=2 [35]=2 [106]=2 [37]=2 [107]=2 [4]=2 [78]=2 [39]=2 [79]=2 [110]=2 [6]=2 [41]=2 [42]=2 [81]=2 [82]=2 [46]=2 [47]=2 [9]=2 [109]=2 [50]=2 [52]=2 [11]=2 [115]=2 [87]=2 [49]=2 [56]=2 [90]=2 [57]=2 [91]=2 [92]=2 [60]=2 [61]=2 [125]=2 [93]=2 [62]=2 [20]=2 [95]=2 [22]=2 [23]=2 [64]=2 [65]=2 [24]=2 [132]=2 [26]=2 [68]=2 [98]=2 [69]=2 [29]=2 [136]=2 [70]=2 [99]=2)"
+    literal_transitions[9]="([114]=15 [111]=16)"
+    literal_transitions[11]="([101]=2)"
+    literal_transitions[13]="([21]=1 [116]=1 [30]=1 [135]=1 [118]=1 [43]=1 [71]=1)"
+    literal_transitions[14]="([38]=2)"
+    literal_transitions[15]="([8]=2 [66]=2 [14]=2 [133]=2)"
+    literal_transitions[17]="([75]=19)"
+    literal_transitions[18]="([18]=2 [7]=2)"
+    literal_transitions[19]="([34]=5 [44]=5)"
+    literal_transitions[20]="([134]=2 [94]=2)"
+
+    declare -A match_anything_transitions
+    match_anything_transitions=([1]=2 [0]=7 [6]=2 [20]=2 [10]=2 [2]=17 [7]=7 [12]=2 [14]=17 [16]=2 [4]=20 [11]=17)
+    declare -A subword_transitions
+
+    local state=0
+    local word_index=1
+    while [[ $word_index -lt $cword ]]; do
+        local word=${words[$word_index]}
+
+        if [[ -v "literal_transitions[$state]" ]]; then
+            declare -A state_transitions
+            eval "state_transitions=${literal_transitions[$state]}"
+
+            local word_matched=0
+            for literal_id in $(seq 0 $((${#literals[@]} - 1))); do
+                if [[ ${literals[$literal_id]} = "$word" ]]; then
+                    if [[ -v "state_transitions[$literal_id]" ]]; then
+                        state=${state_transitions[$literal_id]}
+                        word_index=$((word_index + 1))
+                        word_matched=1
+                        break
+                    fi
+                fi
+            done
+            if [[ $word_matched -ne 0 ]]; then
+                continue
+            fi
+        fi
+
+        if [[ -v "match_anything_transitions[$state]" ]]; then
+            state=${match_anything_transitions[$state]}
+            word_index=$((word_index + 1))
+            continue
+        fi
+
+        return 1
+    done
+
+
+    local prefix="${words[$cword]}"
+
+    local shortest_suffix="$word"
+    for ((i=0; i < ${#COMP_WORDBREAKS}; i++)); do
+        local char="${COMP_WORDBREAKS:$i:1}"
+        local candidate="${word##*$char}"
+        if [[ ${#candidate} -lt ${#shortest_suffix} ]]; then
+            shortest_suffix=$candidate
+        fi
+    done
+    local superfluous_prefix=""
+    if [[ "$shortest_suffix" != "$word" ]]; then
+        local superfluous_prefix=${word%$shortest_suffix}
+    fi
+
+    if [[ -v "literal_transitions[$state]" ]]; then
+        local state_transitions_initializer=${literal_transitions[$state]}
+        declare -A state_transitions
+        eval "state_transitions=$state_transitions_initializer"
+
+        for literal_id in "${!state_transitions[@]}"; do
+            local literal="${literals[$literal_id]}"
+            if [[ $literal = "${prefix}"* ]]; then
+                local completion=${literal#"$superfluous_prefix"}
+                COMPREPLY+=("$completion ")
+            fi
+        done
+    fi
+    declare -A commands
+    commands=([16]=2 [4]=3 [12]=1 [10]=0)
+    if [[ -v "commands[$state]" ]]; then
+        local command_id=${commands[$state]}
+        local completions=()
+        mapfile -t completions < <(_hyprctl_cmd_${command_id} "$prefix" | cut -f1)
+        for item in "${completions[@]}"; do
+            if [[ $item = "${prefix}"* ]]; then
+                COMPREPLY+=("$item")
+            fi
+        done
+    fi
+
+
+    return 0
+}
+
+complete -o nospace -F _hyprctl hyprctl

hyprctl/hyprctl.fish

@@ -0,0 +1,216 @@
+function _hyprctl_3
+    set 1 $argv[1]
+    hyprctl monitors | grep Monitor | awk '{ print $2 }'
+end
+
+function _hyprctl_2
+    set 1 $argv[1]
+    hyprpm list | grep "Plugin" | awk '{print $4}'
+end
+
+function _hyprctl_1
+    set 1 $argv[1]
+    hyprctl clients | grep class | awk '{print $2}'
+end
+
+function _hyprctl_4
+    set 1 $argv[1]
+    hyprctl devices | sed -n '/Keyboard at/{n; s/^\s\+//; p}'
+end
+
+function _hyprctl
+    set COMP_LINE (commandline --cut-at-cursor)
+
+    set COMP_WORDS
+    echo $COMP_LINE | read --tokenize --array COMP_WORDS
+    if string match --quiet --regex '.*\s$' $COMP_LINE
+        set COMP_CWORD (math (count $COMP_WORDS) + 1)
+    else
+        set COMP_CWORD (count $COMP_WORDS)
+    end
+
+    set --local literals "cyclenext" "globalshortcuts" "cursorpos" "bordersize" "renameworkspace" "animationstyle" "focuswindow" "0" "auto" "swapnext" "forceallowsinput" "moveactive" "activebordercolor" "alphafullscreen" "wayland" "layers" "minsize" "monitors" "1" "kill" "settiled" "3" "focusmonitor" "swapwindow" "moveoutofgroup" "notify" "movecursor" "setcursor" "seterror" "movecurrentworkspacetomonitor" "4" "nomaxsize" "forcenoanims" "setprop" "-i" "togglefloating" "workspacerules" "movetoworkspace" "disable" "setignoregrouplock" "workspaces" "movegroupwindow" "closewindow" "0" "--instance" "binds" "movewindow" "splitratio" "alpha" "denywindowfromgroup" "workspace" "configerrors" "togglegroup" "getoption" "forceopaque" "keepaspectratio" "killactive" "pass" "decorations" "devices" "focuscurrentorlast" "submap" "global" "alphafullscreenoverride" "forcerendererreload" "movewindowpixel" "headless" "version" "dpms" "resizeactive" "moveintogroup" "5" "alphaoverride" "setfloating" "rollinglog" "::=" "rounding" "layouts" "moveworkspacetomonitor" "exec" "alphainactiveoverride" "alterzorder" "fakefullscreen" "nofocus" "keyword" "forcenoborder" "forcenodim" "pin" "output" "forcenoblur" "togglespecialworkspace" "fullscreen" "toggleopaque" "focusworkspaceoncurrentmonitor" "next" "changegroupactive" "-j" "instances" "execr" "exit" "clients" "all" "--batch" "dismissnotify" "inactivebordercolor" "switchxkblayout" "movetoworkspacesilent" "movewindoworgroup" "-r" "movefocus" "focusurgentorlast" "remove" "activeworkspace" "dispatch" "create" "centerwindow" "2" "hyprpaper" "-1" "reload" "alphainactive" "systeminfo" "plugin" "dimaround" "activewindow" "swapactiveworkspaces" "splash" "maxsize" "lockactivegroup" "windowdancecompat" "forceopaqueoverriden" "lockgroups" "movecursortocorner" "x11" "prev" "1" "resizewindowpixel" "forcenoshadow"
+
+    set --local descriptions
+    set descriptions[1] "Focus the next window on a workspace"
+    set descriptions[3] "Get the current cursor pos in global layout coordinates"
+    set descriptions[5] "Rename a workspace"
+    set descriptions[7] "Focus the first window matching"
+    set descriptions[10] "Swap the focused window with the next window"
+    set descriptions[12] "Move the active window"
+    set descriptions[16] "List the layers"
+    set descriptions[18] "List active outputs with their properties"
+    set descriptions[20] "Get into a kill mode, where you can kill an app by clicking on it"
+    set descriptions[21] "Set the current window's floating state to false"
+    set descriptions[22] "ERROR"
+    set descriptions[23] "Focus a monitor"
+    set descriptions[24] "Swap the active window with another window"
+    set descriptions[25] "Move the active window out of a group"
+    set descriptions[26] "Send a notification using the built-in Hyprland notification system"
+    set descriptions[27] "Move the cursor to a specified position"
+    set descriptions[28] "Set the cursor theme and reloads the cursor manager"
+    set descriptions[29] "Set the hyprctl error string"
+    set descriptions[30] "Move the active workspace to a monitor"
+    set descriptions[31] "CONFUSED"
+    set descriptions[34] "Set a property of a window"
+    set descriptions[35] "Specify the Hyprland instance"
+    set descriptions[36] "Toggle the current window's floating state"
+    set descriptions[37] "Get the list of defined workspace rules"
+    set descriptions[38] "Move the focused window to a workspace"
+    set descriptions[40] "Temporarily enable or disable binds:ignore_group_lock"
+    set descriptions[41] "List all workspaces with their properties"
+    set descriptions[42] "Swap the active window with the next or previous in a group"
+    set descriptions[43] "Close a specified window"
+    set descriptions[44] "WARNING"
+    set descriptions[45] "Specify the Hyprland instance"
+    set descriptions[46] "List all registered binds"
+    set descriptions[47] "Move the active window in a direction or to a monitor"
+    set descriptions[48] "Change the split ratio"
+    set descriptions[50] "Prohibit the active window from becoming or being inserted into group"
+    set descriptions[51] "Change the workspace"
+    set descriptions[52] "List all current config parsing errors"
+    set descriptions[53] "Toggle the current active window into a group"
+    set descriptions[54] "Get the config option status (values)"
+    set descriptions[57] "Close the active window"
+    set descriptions[58] "Pass the key to a specified window"
+    set descriptions[59] "List all decorations and their info"
+    set descriptions[60] "List all connected keyboards and mice"
+    set descriptions[61] "Switch focus from current to previously focused window"
+    set descriptions[62] "Change the current mapping group"
+    set descriptions[63] "Execute a Global Shortcut using the GlobalShortcuts portal"
+    set descriptions[65] "Force the renderer to reload all resources and outputs"
+    set descriptions[66] "Move a selected window"
+    set descriptions[68] "Print the Hyprland version: flags, commit and branch of build"
+    set descriptions[69] "Set all monitors' DPMS status"
+    set descriptions[70] "Resize the active window"
+    set descriptions[71] "Move the active window into a group"
+    set descriptions[72] "OK"
+    set descriptions[74] "Set the current window's floating state to true"
+    set descriptions[75] "Print tail of the log"
+    set descriptions[78] "List all layouts available (including plugin ones)"
+    set descriptions[79] "Move a workspace to a monitor"
+    set descriptions[80] "Execute a shell command"
+    set descriptions[82] "Modify the window stack order of the active or specified window"
+    set descriptions[83] "Toggle the focused window's internal fullscreen state"
+    set descriptions[85] "Issue a keyword to call a config keyword dynamically"
+    set descriptions[88] "Pin a window"
+    set descriptions[89] "Allows adding/removing fake outputs to a specific backend"
+    set descriptions[91] "Toggle a special workspace on/off"
+    set descriptions[92] "Toggle the focused window's fullscreen state"
+    set descriptions[93] "Toggle the current window to always be opaque"
+    set descriptions[94] "Focus the requested workspace"
+    set descriptions[96] "Switch to the next window in a group"
+    set descriptions[97] "Output in JSON format"
+    set descriptions[98] "List all running Hyprland instances and their info"
+    set descriptions[99] "Execute a raw shell command"
+    set descriptions[100] "Exit the compositor with no questions asked"
+    set descriptions[101] "List all windows with their properties"
+    set descriptions[103] "Execute a batch of commands separated by ;"
+    set descriptions[104] "Dismiss all or up to amount of notifications"
+    set descriptions[106] "Set the xkb layout index for a keyboard"
+    set descriptions[107] "Move window doesnt switch to the workspace"
+    set descriptions[108] "Behave as moveintogroup"
+    set descriptions[109] "Refresh state after issuing the command"
+    set descriptions[110] "Move the focus in a direction"
+    set descriptions[111] "Focus the urgent window or the last window"
+    set descriptions[113] "Get the active workspace name and its properties"
+    set descriptions[114] "Issue a dispatch to call a keybind dispatcher with an arg"
+    set descriptions[116] "Center the active window"
+    set descriptions[117] "HINT"
+    set descriptions[118] "Interact with hyprpaper if present"
+    set descriptions[119] "No Icon"
+    set descriptions[120] "Force reload the config"
+    set descriptions[122] "Print system info"
+    set descriptions[123] "Interact with a plugin"
+    set descriptions[125] "Get the active window name and its properties"
+    set descriptions[126] "Swap the active workspaces between two monitors"
+    set descriptions[127] "Print the current random splash"
+    set descriptions[129] "Lock the focused group"
+    set descriptions[132] "Lock the groups"
+    set descriptions[133] "Move the cursor to the corner of the active window"
+    set descriptions[136] "INFO"
+    set descriptions[137] "Resize a selected window"
+
+    set --local literal_transitions
+    set literal_transitions[1] "set inputs 104 75 34 2 3 78 106 37 109 41 46 113 85 114 52 54 89 118 120 122 16 59 60 18 123 20 125 127 26 68 97 98 28 29 101 103; set tos 2 3 4 3 3 3 5 3 6 3 3 3 7 9 3 3 10 3 3 3 3 11 3 12 13 3 3 3 14 3 6 3 3 15 3 6"
+    set literal_transitions[4] "set inputs 73 14 33 55 56 90 105 121 77 17 124 4 6 64 128 130 81 131 84 32 49 13 86 11 87 138; set tos 19 3 19 19 19 19 3 3 2 3 19 2 3 19 3 19 19 19 19 19 3 3 19 19 19 19"
+    set literal_transitions[8] "set inputs 104 75 34 2 3 78 106 37 41 46 113 85 114 52 54 89 118 120 122 16 59 60 18 123 20 125 127 26 68 98 28 29 101; set tos 2 3 4 3 3 3 5 3 3 3 3 7 9 3 3 10 3 3 3 3 11 3 12 13 3 3 3 14 3 3 3 15 3"
+    set literal_transitions[9] "set inputs 129 132 1 74 36 107 38 108 5 79 40 80 111 7 42 43 82 83 47 48 10 110 51 53 12 116 88 50 57 91 58 92 93 61 62 126 94 63 21 96 23 24 65 66 25 133 27 69 99 70 30 137 71 100; set tos 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3"
+    set literal_transitions[10] "set inputs 115 112; set tos 16 17"
+    set literal_transitions[12] "set inputs 102; set tos 3"
+    set literal_transitions[14] "set inputs 22 117 31 136 119 44 72; set tos 2 2 2 2 2 2 2"
+    set literal_transitions[15] "set inputs 39; set tos 3"
+    set literal_transitions[16] "set inputs 9 67 15 134; set tos 3 3 3 3"
+    set literal_transitions[18] "set inputs 76; set tos 20"
+    set literal_transitions[19] "set inputs 19 8; set tos 3 3"
+    set literal_transitions[20] "set inputs 35 45; set tos 6 6"
+    set literal_transitions[21] "set inputs 135 95; set tos 3 3"
+
+    set --local match_anything_transitions_from 2 1 7 21 11 3 8 13 15 17 5 12
+    set --local match_anything_transitions_to 3 8 3 3 3 18 8 3 18 3 21 18
+
+    set --local state 1
+    set --local word_index 2
+    while test $word_index -lt $COMP_CWORD
+        set --local -- word $COMP_WORDS[$word_index]
+
+        if set --query literal_transitions[$state] && test -n $literal_transitions[$state]
+            set --local --erase inputs
+            set --local --erase tos
+            eval $literal_transitions[$state]
+
+            if contains -- $word $literals
+                set --local literal_matched 0
+                for literal_id in (seq 1 (count $literals))
+                    if test $literals[$literal_id] = $word
+                        set --local index (contains --index -- $literal_id $inputs)
+                        set state $tos[$index]
+                        set word_index (math $word_index + 1)
+                        set literal_matched 1
+                        break
+                    end
+                end
+                if test $literal_matched -ne 0
+                    continue
+                end
+            end
+        end
+
+        if set --query match_anything_transitions_from[$state] && test -n $match_anything_transitions_from[$state]
+            set --local index (contains --index -- $state $match_anything_transitions_from)
+            set state $match_anything_transitions_to[$index]
+            set word_index (math $word_index + 1)
+            continue
+        end
+
+        return 1
+    end
+
+    if set --query literal_transitions[$state] && test -n $literal_transitions[$state]
+        set --local --erase inputs
+        set --local --erase tos
+        eval $literal_transitions[$state]
+        for literal_id in $inputs
+            if test -n $descriptions[$literal_id]
+                printf '%s\t%s\n' $literals[$literal_id] $descriptions[$literal_id]
+            else
+                printf '%s\n' $literals[$literal_id]
+            end
+        end
+    end
+
+    set command_states 17 5 13 11
+    set command_ids 3 4 2 1
+    if contains $state $command_states
+        set --local index (contains --index $state $command_states)
+        set --local function_id $command_ids[$index]
+        set --local function_name _hyprctl_$function_id
+        set --local --erase inputs
+        set --local --erase tos
+        $function_name "$COMP_WORDS[$COMP_CWORD]"
+    end
+
+    return 0
+end
+
+complete --command hyprctl --no-files --arguments "(_hyprctl)"

hyprctl/hyprctl.usage

@@ -0,0 +1,148 @@
+# This is a file feeded to complgen to generate bash/fish/zsh completions
+# Repo: https://github.com/adaszko/complgen
+# Generate completion scripts: "complgen aot --bash-script hyprctl.bash --fish-script hyprctl.fish --zsh-script hyprctl.zsh ./hyprctl.usage"
+
+hyprctl [<OPTIONS>]... <ARGUMENTS>           
+
+<OPTIONS>  ::=  (-i | --instance)                                     "Specify the Hyprland instance"
+            |   (-j)                                                  "Output in JSON format"
+            |   (-r)                                                  "Refresh state after issuing the command"
+            |   (--batch)                                             "Execute a batch of commands separated by ;"
+            ;
+
+<WINDOWS> ::= {{{ hyprctl clients | grep class | awk '{print $2}' }}};
+
+<AVAILABLE_PLUGINS> ::= {{{ hyprpm list | grep "Plugin" | awk '{print $4}' }}};
+
+<MONITORS> ::= {{{ hyprctl monitors | grep Monitor | awk '{ print $2 }' }}};
+
+<KEYBOARDS> ::= {{{ hyprctl devices | sed -n '/Keyboard at/{n; s/^\s\+//; p}' }}};
+
+<NOTIFICATION_TYPES> ::=  (0)   "WARNING"
+                      |   (1)   "INFO"
+                      |   (2)   "HINT"
+                      |   (3)   "ERROR"
+                      |   (4)   "CONFUSED"
+                      |   (5)   "OK"
+                      |   (-1)  "No Icon"
+                      ;
+
+<PROPS> ::=  (animationstyle)
+         |   (rounding <NUM>)
+         |   (bordersize <NUM>)
+         |   (forcenoblur (0 | 1))
+         |   (forceopaque (0 | 1))
+         |   (forceopaqueoverriden (0 | 1))
+         |   (forceallowsinput (0 | 1))
+         |   (forcenoanims (0 | 1))
+         |   (forcenoborder (0 | 1))
+         |   (forcenodim (0 | 1))
+         |   (forcenoshadow (0 | 1))
+         |   (nofocus (0 | 1))
+         |   (windowdancecompat (0 | 1))
+         |   (nomaxsize (0 | 1))
+         |   (minsize)
+         |   (maxsize)
+         |   (dimaround (0 | 1))
+         |   (keepaspectratio (0 | 1))
+         |   (alphaoverride (0 | 1))
+         |   (alpha)
+         |   (alphainactiveoverride (0 | 1))
+         |   (alphainactive)
+         |   (alphafullscreenoverride (0 | 1))
+         |   (alphafullscreen)
+         |   (activebordercolor)
+         |   (inactivebordercolor)
+         ;
+
+
+<ARGUMENTS> ::= (activewindow)                                        "Get the active window name and its properties"
+            |   (activeworkspace)                                     "Get the active workspace name and its properties"
+            |   (binds)                                               "List all registered binds"
+            |   (clients)                                             "List all windows with their properties"
+            |   (configerrors)                                        "List all current config parsing errors"
+            |   (cursorpos)                                           "Get the current cursor pos in global layout coordinates"
+            |   (decorations <WINDOWS>)                               "List all decorations and their info"
+            |   (devices)                                             "List all connected keyboards and mice"
+            |   (dismissnotify <NUM>)                                 "Dismiss all or up to amount of notifications"
+            |   (dispatch <DISPATCHERS>)                              "Issue a dispatch to call a keybind dispatcher with an arg"
+            |   (getoption)                                           "Get the config option status (values)"
+            |   (globalshortcuts)                                     ""
+            |   (hyprpaper)                                           "Interact with hyprpaper if present"
+            |   (instances)                                           "List all running Hyprland instances and their info"
+            |   (keyword <KEYWORDS>)                                  "Issue a keyword to call a config keyword dynamically"
+            |   (kill)                                                "Get into a kill mode, where you can kill an app by clicking on it"
+            |   (layers)                                              "List the layers"
+            |   (layouts)                                             "List all layouts available (including plugin ones)"
+            |   (monitors [all])                                      "List active outputs with their properties"
+            |   (notify <NOTIFICATION_TYPES> <NUM>)                   "Send a notification using the built-in Hyprland notification system"
+            |   (output (create (wayland | x11 | headless | auto) | remove <MONITORS>)) "Allows adding/removing fake outputs to a specific backend"
+            |   (plugin <AVAILABLE_PLUGINS>)                          "Interact with a plugin"
+            |   (reload)                                              "Force reload the config"
+            |   (rollinglog)                                          "Print tail of the log"
+            |   (setcursor)                                           "Set the cursor theme and reloads the cursor manager"
+            |   (seterror [disable])                                  "Set the hyprctl error string"
+            |   (setprop <PROPS>)                                     "Set a property of a window"
+            |   (splash)                                              "Print the current random splash"
+            |   (switchxkblayout <KEYBOARDS> (next | prev | <NUM>))   "Set the xkb layout index for a keyboard"
+            |   (systeminfo)                                          "Print system info"
+            |   (version)                                             "Print the Hyprland version: flags, commit and branch of build"
+            |   (workspacerules)                                      "Get the list of defined workspace rules"
+            |   (workspaces)                                          "List all workspaces with their properties"
+            ;
+
+<DISPATCHERS> ::=  (exec)         	                                  "Execute a shell command"
+                |  (execr)           	                              "Execute a raw shell command"
+                |  (pass)            	                              "Pass the key to a specified window"
+                |  (killactive)          	                          "Close the active window"
+                |  (closewindow)         	                          "Close a specified window"
+                |  (workspace)           	                          "Change the workspace"
+                |  (movetoworkspace)         	                      "Move the focused window to a workspace"
+                |  (movetoworkspacesilent)           	              "Move window doesnt switch to the workspace"
+                |  (togglefloating)          	                      "Toggle the current window's floating state"
+                |  (setfloating)         	                          "Set the current window's floating state to true"
+                |  (settiled)            	                          "Set the current window's floating state to false"
+                |  (fullscreen)          	                          "Toggle the focused window's fullscreen state"
+                |  (fakefullscreen)          	                      "Toggle the focused window's internal fullscreen state"
+                |  (dpms)            	                              "Set all monitors' DPMS status"
+                |  (pin)         	                                  "Pin a window"
+                |  (movefocus)           	                          "Move the focus in a direction"
+                |  (movewindow)          	                          "Move the active window in a direction or to a monitor"
+                |  (swapwindow)          	                          "Swap the active window with another window"
+                |  (centerwindow)            	                      "Center the active window"
+                |  (resizeactive)            	                      "Resize the active window"
+                |  (moveactive)          	                          "Move the active window"
+                |  (resizewindowpixel)           	                  "Resize a selected window"
+                |  (movewindowpixel)         	                      "Move a selected window"
+                |  (cyclenext)           	                          "Focus the next window on a workspace"
+                |  (swapnext)            	                          "Swap the focused window with the next window"
+                |  (focuswindow)         	                          "Focus the first window matching"
+                |  (focusmonitor)            	                      "Focus a monitor"
+                |  (splitratio)          	                          "Change the split ratio"
+                |  (toggleopaque)            	                      "Toggle the current window to always be opaque"
+                |  (movecursortocorner)          	                  "Move the cursor to the corner of the active window"
+                |  (movecursor)          	                          "Move the cursor to a specified position"
+                |  (renameworkspace)         	                      "Rename a workspace"
+                |  (exit)            	                              "Exit the compositor with no questions asked"
+                |  (forcerendererreload)         	                  "Force the renderer to reload all resources and outputs"
+                |  (movecurrentworkspacetomonitor)           	      "Move the active workspace to a monitor"
+                |  (focusworkspaceoncurrentmonitor)          	      "Focus the requested workspace"
+                |  (moveworkspacetomonitor)          	              "Move a workspace to a monitor"
+                |  (swapactiveworkspaces)            	              "Swap the active workspaces between two monitors"
+                |  (alterzorder)         	                          "Modify the window stack order of the active or specified window"
+                |  (togglespecialworkspace)          	              "Toggle a special workspace on/off"
+                |  (focusurgentorlast)           	                  "Focus the urgent window or the last window"
+                |  (togglegroup)         	                          "Toggle the current active window into a group"
+                |  (changegroupactive)           	                  "Switch to the next window in a group"
+                |  (focuscurrentorlast)          	                  "Switch focus from current to previously focused window"
+                |  (lockgroups)          	                          "Lock the groups"
+                |  (lockactivegroup)         	                      "Lock the focused group"
+                |  (moveintogroup)           	                      "Move the active window into a group"
+                |  (moveoutofgroup)          	                      "Move the active window out of a group"
+                |  (movewindoworgroup)           	                  "Behave as moveintogroup"
+                |  (movegroupwindow)         	                      "Swap the active window with the next or previous in a group"
+                |  (denywindowfromgroup)         	                  "Prohibit the active window from becoming or being inserted into group"
+                |  (setignoregrouplock)          	                  "Temporarily enable or disable binds:ignore_group_lock"
+                |  (global)          	                              "Execute a Global Shortcut using the GlobalShortcuts portal"
+                |  (submap)          	                              "Change the current mapping group"
+                ;

hyprctl/hyprctl.zsh

@@ -0,0 +1,251 @@
+#compdef hyprctl
+
+_hyprctl_cmd_2 () {
+    hyprctl monitors | grep Monitor | awk '{ print $2 }'
+}
+
+_hyprctl_cmd_1 () {
+    hyprpm list | grep "Plugin" | awk '{print $4}'
+}
+
+_hyprctl_cmd_0 () {
+    hyprctl clients | grep class | awk '{print $2}'
+}
+
+_hyprctl_cmd_3 () {
+    hyprctl devices | sed -n '/Keyboard at/{n; s/^\s\+//; p}'
+}
+
+_hyprctl () {
+    local -a literals=("cyclenext" "globalshortcuts" "cursorpos" "bordersize" "renameworkspace" "animationstyle" "focuswindow" "0" "auto" "swapnext" "forceallowsinput" "moveactive" "activebordercolor" "alphafullscreen" "wayland" "layers" "minsize" "monitors" "1" "kill" "settiled" "3" "focusmonitor" "swapwindow" "moveoutofgroup" "notify" "movecursor" "setcursor" "seterror" "movecurrentworkspacetomonitor" "4" "nomaxsize" "forcenoanims" "setprop" "-i" "togglefloating" "workspacerules" "movetoworkspace" "disable" "setignoregrouplock" "workspaces" "movegroupwindow" "closewindow" "0" "--instance" "binds" "movewindow" "splitratio" "alpha" "denywindowfromgroup" "workspace" "configerrors" "togglegroup" "getoption" "forceopaque" "keepaspectratio" "killactive" "pass" "decorations" "devices" "focuscurrentorlast" "submap" "global" "alphafullscreenoverride" "forcerendererreload" "movewindowpixel" "headless" "version" "dpms" "resizeactive" "moveintogroup" "5" "alphaoverride" "setfloating" "rollinglog" "::=" "rounding" "layouts" "moveworkspacetomonitor" "exec" "alphainactiveoverride" "alterzorder" "fakefullscreen" "nofocus" "keyword" "forcenoborder" "forcenodim" "pin" "output" "forcenoblur" "togglespecialworkspace" "fullscreen" "toggleopaque" "focusworkspaceoncurrentmonitor" "next" "changegroupactive" "-j" "instances" "execr" "exit" "clients" "all" "--batch" "dismissnotify" "inactivebordercolor" "switchxkblayout" "movetoworkspacesilent" "movewindoworgroup" "-r" "movefocus" "focusurgentorlast" "remove" "activeworkspace" "dispatch" "create" "centerwindow" "2" "hyprpaper" "-1" "reload" "alphainactive" "systeminfo" "plugin" "dimaround" "activewindow" "swapactiveworkspaces" "splash" "maxsize" "lockactivegroup" "windowdancecompat" "forceopaqueoverriden" "lockgroups" "movecursortocorner" "x11" "prev" "1" "resizewindowpixel" "forcenoshadow")
+
+    local -A descriptions
+    descriptions[1]="Focus the next window on a workspace"
+    descriptions[3]="Get the current cursor pos in global layout coordinates"
+    descriptions[5]="Rename a workspace"
+    descriptions[7]="Focus the first window matching"
+    descriptions[10]="Swap the focused window with the next window"
+    descriptions[12]="Move the active window"
+    descriptions[16]="List the layers"
+    descriptions[18]="List active outputs with their properties"
+    descriptions[20]="Get into a kill mode, where you can kill an app by clicking on it"
+    descriptions[21]="Set the current window's floating state to false"
+    descriptions[22]="ERROR"
+    descriptions[23]="Focus a monitor"
+    descriptions[24]="Swap the active window with another window"
+    descriptions[25]="Move the active window out of a group"
+    descriptions[26]="Send a notification using the built-in Hyprland notification system"
+    descriptions[27]="Move the cursor to a specified position"
+    descriptions[28]="Set the cursor theme and reloads the cursor manager"
+    descriptions[29]="Set the hyprctl error string"
+    descriptions[30]="Move the active workspace to a monitor"
+    descriptions[31]="CONFUSED"
+    descriptions[34]="Set a property of a window"
+    descriptions[35]="Specify the Hyprland instance"
+    descriptions[36]="Toggle the current window's floating state"
+    descriptions[37]="Get the list of defined workspace rules"
+    descriptions[38]="Move the focused window to a workspace"
+    descriptions[40]="Temporarily enable or disable binds:ignore_group_lock"
+    descriptions[41]="List all workspaces with their properties"
+    descriptions[42]="Swap the active window with the next or previous in a group"
+    descriptions[43]="Close a specified window"
+    descriptions[44]="WARNING"
+    descriptions[45]="Specify the Hyprland instance"
+    descriptions[46]="List all registered binds"
+    descriptions[47]="Move the active window in a direction or to a monitor"
+    descriptions[48]="Change the split ratio"
+    descriptions[50]="Prohibit the active window from becoming or being inserted into group"
+    descriptions[51]="Change the workspace"
+    descriptions[52]="List all current config parsing errors"
+    descriptions[53]="Toggle the current active window into a group"
+    descriptions[54]="Get the config option status (values)"
+    descriptions[57]="Close the active window"
+    descriptions[58]="Pass the key to a specified window"
+    descriptions[59]="List all decorations and their info"
+    descriptions[60]="List all connected keyboards and mice"
+    descriptions[61]="Switch focus from current to previously focused window"
+    descriptions[62]="Change the current mapping group"
+    descriptions[63]="Execute a Global Shortcut using the GlobalShortcuts portal"
+    descriptions[65]="Force the renderer to reload all resources and outputs"
+    descriptions[66]="Move a selected window"
+    descriptions[68]="Print the Hyprland version: flags, commit and branch of build"
+    descriptions[69]="Set all monitors' DPMS status"
+    descriptions[70]="Resize the active window"
+    descriptions[71]="Move the active window into a group"
+    descriptions[72]="OK"
+    descriptions[74]="Set the current window's floating state to true"
+    descriptions[75]="Print tail of the log"
+    descriptions[78]="List all layouts available (including plugin ones)"
+    descriptions[79]="Move a workspace to a monitor"
+    descriptions[80]="Execute a shell command"
+    descriptions[82]="Modify the window stack order of the active or specified window"
+    descriptions[83]="Toggle the focused window's internal fullscreen state"
+    descriptions[85]="Issue a keyword to call a config keyword dynamically"
+    descriptions[88]="Pin a window"
+    descriptions[89]="Allows adding/removing fake outputs to a specific backend"
+    descriptions[91]="Toggle a special workspace on/off"
+    descriptions[92]="Toggle the focused window's fullscreen state"
+    descriptions[93]="Toggle the current window to always be opaque"
+    descriptions[94]="Focus the requested workspace"
+    descriptions[96]="Switch to the next window in a group"
+    descriptions[97]="Output in JSON format"
+    descriptions[98]="List all running Hyprland instances and their info"
+    descriptions[99]="Execute a raw shell command"
+    descriptions[100]="Exit the compositor with no questions asked"
+    descriptions[101]="List all windows with their properties"
+    descriptions[103]="Execute a batch of commands separated by ;"
+    descriptions[104]="Dismiss all or up to amount of notifications"
+    descriptions[106]="Set the xkb layout index for a keyboard"
+    descriptions[107]="Move window doesnt switch to the workspace"
+    descriptions[108]="Behave as moveintogroup"
+    descriptions[109]="Refresh state after issuing the command"
+    descriptions[110]="Move the focus in a direction"
+    descriptions[111]="Focus the urgent window or the last window"
+    descriptions[113]="Get the active workspace name and its properties"
+    descriptions[114]="Issue a dispatch to call a keybind dispatcher with an arg"
+    descriptions[116]="Center the active window"
+    descriptions[117]="HINT"
+    descriptions[118]="Interact with hyprpaper if present"
+    descriptions[119]="No Icon"
+    descriptions[120]="Force reload the config"
+    descriptions[122]="Print system info"
+    descriptions[123]="Interact with a plugin"
+    descriptions[125]="Get the active window name and its properties"
+    descriptions[126]="Swap the active workspaces between two monitors"
+    descriptions[127]="Print the current random splash"
+    descriptions[129]="Lock the focused group"
+    descriptions[132]="Lock the groups"
+    descriptions[133]="Move the cursor to the corner of the active window"
+    descriptions[136]="INFO"
+    descriptions[137]="Resize a selected window"
+
+    local -A literal_transitions
+    literal_transitions[1]="([104]=2 [75]=3 [34]=4 [2]=3 [3]=3 [78]=3 [106]=5 [37]=3 [109]=6 [41]=3 [46]=3 [113]=3 [85]=7 [114]=9 [52]=3 [54]=3 [89]=10 [118]=3 [120]=3 [122]=3 [16]=3 [59]=11 [60]=3 [18]=12 [123]=13 [20]=3 [125]=3 [127]=3 [26]=14 [68]=3 [97]=6 [98]=3 [28]=3 [29]=15 [101]=3 [103]=6)"
+    literal_transitions[4]="([73]=19 [14]=3 [33]=19 [55]=19 [56]=19 [90]=19 [105]=3 [121]=3 [77]=2 [17]=3 [124]=19 [4]=2 [6]=3 [64]=19 [128]=3 [130]=19 [81]=19 [131]=19 [84]=19 [32]=19 [49]=3 [13]=3 [86]=19 [11]=19 [87]=19 [138]=19)"
+    literal_transitions[8]="([104]=2 [75]=3 [34]=4 [2]=3 [3]=3 [78]=3 [106]=5 [37]=3 [41]=3 [46]=3 [113]=3 [85]=7 [114]=9 [52]=3 [54]=3 [89]=10 [118]=3 [120]=3 [122]=3 [16]=3 [59]=11 [60]=3 [18]=12 [123]=13 [20]=3 [125]=3 [127]=3 [26]=14 [68]=3 [98]=3 [28]=3 [29]=15 [101]=3)"
+    literal_transitions[9]="([129]=3 [132]=3 [1]=3 [74]=3 [36]=3 [107]=3 [38]=3 [108]=3 [5]=3 [79]=3 [40]=3 [80]=3 [111]=3 [7]=3 [42]=3 [43]=3 [82]=3 [83]=3 [47]=3 [48]=3 [10]=3 [110]=3 [51]=3 [53]=3 [12]=3 [116]=3 [88]=3 [50]=3 [57]=3 [91]=3 [58]=3 [92]=3 [93]=3 [61]=3 [62]=3 [126]=3 [94]=3 [63]=3 [21]=3 [96]=3 [23]=3 [24]=3 [65]=3 [66]=3 [25]=3 [133]=3 [27]=3 [69]=3 [99]=3 [70]=3 [30]=3 [137]=3 [71]=3 [100]=3)"
+    literal_transitions[10]="([115]=16 [112]=17)"
+    literal_transitions[12]="([102]=3)"
+    literal_transitions[14]="([22]=2 [117]=2 [31]=2 [136]=2 [119]=2 [44]=2 [72]=2)"
+    literal_transitions[15]="([39]=3)"
+    literal_transitions[16]="([9]=3 [67]=3 [15]=3 [134]=3)"
+    literal_transitions[18]="([76]=20)"
+    literal_transitions[19]="([19]=3 [8]=3)"
+    literal_transitions[20]="([35]=6 [45]=6)"
+    literal_transitions[21]="([135]=3 [95]=3)"
+
+    local -A match_anything_transitions
+    match_anything_transitions=([2]=3 [1]=8 [7]=3 [21]=3 [11]=3 [3]=18 [8]=8 [13]=3 [15]=18 [17]=3 [5]=21 [12]=18)
+
+    declare -A subword_transitions
+
+    local state=1
+    local word_index=2
+    while [[ $word_index -lt $CURRENT ]]; do
+        if [[ -v "literal_transitions[$state]" ]]; then
+            local -A state_transitions
+            eval "state_transitions=${literal_transitions[$state]}"
+
+            local word=${words[$word_index]}
+            local word_matched=0
+            for ((literal_id = 1; literal_id <= $#literals; literal_id++)); do
+                if [[ ${literals[$literal_id]} = "$word" ]]; then
+                    if [[ -v "state_transitions[$literal_id]" ]]; then
+                        state=${state_transitions[$literal_id]}
+                        word_index=$((word_index + 1))
+                        word_matched=1
+                        break
+                    fi
+                fi
+            done
+            if [[ $word_matched -ne 0 ]]; then
+                continue
+            fi
+        fi
+
+        if [[ -v "match_anything_transitions[$state]" ]]; then
+            state=${match_anything_transitions[$state]}
+            word_index=$((word_index + 1))
+            continue
+        fi
+
+        return 1
+    done
+
+    completions_no_description_trailing_space=()
+    completions_no_description_no_trailing_space=()
+    completions_trailing_space=()
+    suffixes_trailing_space=()
+    descriptions_trailing_space=()
+    completions_no_trailing_space=()
+    suffixes_no_trailing_space=()
+    descriptions_no_trailing_space=()
+
+    if [[ -v "literal_transitions[$state]" ]]; then
+        local -A state_transitions
+        eval "state_transitions=${literal_transitions[$state]}"
+
+        for literal_id in ${(k)state_transitions}; do
+            if [[ -v "descriptions[$literal_id]" ]]; then
+                completions_trailing_space+=("${literals[$literal_id]}")
+                suffixes_trailing_space+=("${literals[$literal_id]}")
+                descriptions_trailing_space+=("${descriptions[$literal_id]}")
+            else
+                completions_no_description_trailing_space+=("${literals[$literal_id]}")
+            fi
+        done
+    fi
+    local -A commands=([17]=2 [5]=3 [13]=1 [11]=0)
+
+    if [[ -v "commands[$state]" ]]; then
+        local command_id=${commands[$state]}
+        local output=$(_hyprctl_cmd_${command_id} "${words[$CURRENT]}")
+        local -a command_completions=("${(@f)output}")
+        for line in ${command_completions[@]}; do
+            local parts=(${(@s:	:)line})
+            if [[ -v "parts[2]" ]]; then
+                completions_trailing_space+=("${parts[1]}")
+                suffixes_trailing_space+=("${parts[1]}")
+                descriptions_trailing_space+=("${parts[2]}")
+            else
+                completions_no_description_trailing_space+=("${parts[1]}")
+            fi
+        done
+    fi
+
+    local maxlen=0
+    for suffix in ${suffixes_trailing_space[@]}; do
+        if [[ ${#suffix} -gt $maxlen ]]; then
+            maxlen=${#suffix}
+        fi
+    done
+    for suffix in ${suffixes_no_trailing_space[@]}; do
+        if [[ ${#suffix} -gt $maxlen ]]; then
+            maxlen=${#suffix}
+        fi
+    done
+
+    for ((i = 1; i <= $#suffixes_trailing_space; i++)); do
+        if [[ -z ${descriptions_trailing_space[$i]} ]]; then
+            descriptions_trailing_space[$i]="${(r($maxlen)( ))${suffixes_trailing_space[$i]}}"
+        else
+            descriptions_trailing_space[$i]="${(r($maxlen)( ))${suffixes_trailing_space[$i]}} -- ${descriptions_trailing_space[$i]}"
+        fi
+    done
+
+    for ((i = 1; i <= $#suffixes_no_trailing_space; i++)); do
+        if [[ -z ${descriptions_no_trailing_space[$i]} ]]; then
+            descriptions_no_trailing_space[$i]="${(r($maxlen)( ))${suffixes_no_trailing_space[$i]}}"
+        else
+            descriptions_no_trailing_space[$i]="${(r($maxlen)( ))${suffixes_no_trailing_space[$i]}} -- ${descriptions_no_trailing_space[$i]}"
+        fi
+    done
+
+    compadd -Q -a completions_no_description_trailing_space
+    compadd -Q -S ' ' -a completions_no_description_no_trailing_space
+    compadd -l -Q -a -d descriptions_trailing_space completions_trailing_space
+    compadd -l -Q -S '' -a -d descriptions_no_trailing_space completions_no_trailing_space
+    return 0
+}
+
+compdef _hyprctl hyprctl

hyprctl/main.cpp

@@ -22,45 +22,9 @@
 #include <deque>
 #include <filesystem>
 #include <stdarg.h>
+#include <regex>
 
-const std::string USAGE = R"#(usage: hyprctl [(opt)flags] [command] [(opt)args]
-
-commands:
-    activewindow
-    activeworkspace
-    binds
-    clients
-    cursorpos
-    decorations
-    devices
-    dispatch
-    getoption
-    globalshortcuts
-    hyprpaper
-    instances
-    keyword
-    kill
-    layers
-    layouts
-    monitors
-    notify
-    plugin
-    reload
-    setcursor
-    seterror
-    setprop
-    splash
-    switchxkblayout
-    systeminfo
-    version
-    workspacerules
-    workspaces
-
-flags:
-    -j -> output in JSON
-    --batch -> execute a batch of commands, separated by ';'
-    --instance (-i) -> use a specific instance. Can be either signature or index in hyprctl instances (0, 1, etc)
-)#";
+#include "Strings.hpp"
 
 #define PAD
 
@@ -78,7 +42,7 @@ std::vector<SInstanceData> instances() {
     std::vector<SInstanceData> result;
 
     for (const auto& el : std::filesystem::directory_iterator("/tmp/hypr")) {
-        if (el.is_directory())
+        if (el.is_directory() || !el.path().string().ends_with(".lock"))
             continue;
 
         // read lock
@@ -86,7 +50,9 @@ std::vector<SInstanceData> instances() {
         data->id            = el.path().string();
         data->id            = data->id.substr(data->id.find_last_of('/') + 1, data->id.find(".lock") - data->id.find_last_of('/') - 1);
 
+        try {
             data->time = std::stoull(data->id.substr(data->id.find_first_of('_') + 1));
+        } catch (std::exception& e) { continue; }
 
         // read file
         std::ifstream ifs(el.path().string());
@@ -94,7 +60,9 @@ std::vector<SInstanceData> instances() {
         int           i = 0;
         for (std::string line; std::getline(ifs, line); ++i) {
             if (i == 0) {
+                try {
                     data->pid = std::stoull(line);
+                } catch (std::exception& e) { continue; }
             } else if (i == 1) {
                 data->wlSocket = line;
             } else
@@ -225,9 +193,14 @@ void requestHyprpaper(std::string arg) {
     std::cout << std::string(buffer);
 }
 
-void batchRequest(std::string arg) {
-    std::string rq = "[[BATCH]]" + arg.substr(arg.find_first_of(" ") + 1);
+void batchRequest(std::string arg, bool json) {
+    std::string commands = arg.substr(arg.find_first_of(" ") + 1);
 
+    if (json) {
+        commands = "j/" + std::regex_replace(commands, std::regex(";\\s*"), ";j/");
+    }
+
+    std::string rq = "[[BATCH]]" + commands;
     request(rq);
 }
 
@@ -280,7 +253,7 @@ int main(int argc, char** argv) {
     bool parseArgs = true;
 
     if (argc < 2) {
-        printf("%s\n", USAGE.c_str());
+        std::cout << USAGE << std::endl;
         return 1;
     }
 
@@ -301,19 +274,43 @@ int main(int argc, char** argv) {
             if (ARGS[i] == "-j" && !fullArgs.contains("j")) {
                 fullArgs += "j";
                 json = true;
+            } else if (ARGS[i] == "-r" && !fullArgs.contains("r")) {
+                fullArgs += "r";
+            } else if (ARGS[i] == "-a" && !fullArgs.contains("a")) {
+                fullArgs += "a";
             } else if (ARGS[i] == "--batch") {
                 fullRequest = "--batch ";
             } else if (ARGS[i] == "--instance" || ARGS[i] == "-i") {
                 ++i;
 
                 if (i >= ARGS.size()) {
-                    printf("%s\n", USAGE.c_str());
+                    std::cout << USAGE << std::endl;
                     return 1;
                 }
 
                 overrideInstance = ARGS[i];
+            } else if (ARGS[i] == "--help") {
+                const std::string& cmd = ARGS[0];
+
+                if (cmd == "hyprpaper") {
+                    std::cout << HYPRPAPER_HELP << std::endl;
+                } else if (cmd == "notify") {
+                    std::cout << NOTIFY_HELP << std::endl;
+                } else if (cmd == "output") {
+                    std::cout << OUTPUT_HELP << std::endl;
+                } else if (cmd == "plugin") {
+                    std::cout << PLUGIN_HELP << std::endl;
+                } else if (cmd == "setprop") {
+                    std::cout << SETPROP_HELP << std::endl;
+                } else if (cmd == "switchxkblayout") {
+                    std::cout << SWITCHXKBLAYOUT_HELP << std::endl;
                 } else {
-                printf("%s\n", USAGE.c_str());
+                    std::cout << USAGE << std::endl;
+                }
+
+                return 1;
+            } else {
+                std::cout << USAGE << std::endl;
                 return 1;
             }
 
@@ -324,7 +321,7 @@ int main(int argc, char** argv) {
     }
 
     if (fullRequest.empty()) {
-        printf("%s\n", USAGE.c_str());
+        std::cout << USAGE << std::endl;
         return 1;
     }
 
@@ -360,7 +357,7 @@ int main(int argc, char** argv) {
         const auto ISIG = getenv("HYPRLAND_INSTANCE_SIGNATURE");
 
         if (!ISIG) {
-            std::cout << "HYPRLAND_INSTANCE_SIGNATURE not set! (is hyprland running?)";
+            std::cout << "HYPRLAND_INSTANCE_SIGNATURE not set! (is hyprland running?)\n";
             return 1;
         }
 
@@ -370,45 +367,9 @@ int main(int argc, char** argv) {
     int exitStatus = 0;
 
     if (fullRequest.contains("/--batch"))
-        batchRequest(fullRequest);
-    else if (fullRequest.contains("/monitors"))
-        request(fullRequest);
-    else if (fullRequest.contains("/clients"))
-        request(fullRequest);
-    else if (fullRequest.contains("/workspaces"))
-        request(fullRequest);
-    else if (fullRequest.contains("/activeworkspace"))
-        request(fullRequest);
-    else if (fullRequest.contains("/workspacerules"))
-        request(fullRequest);
-    else if (fullRequest.contains("/activewindow"))
-        request(fullRequest);
-    else if (fullRequest.contains("/layers"))
-        request(fullRequest);
-    else if (fullRequest.contains("/version"))
-        request(fullRequest);
-    else if (fullRequest.contains("/kill"))
-        request(fullRequest);
-    else if (fullRequest.contains("/systeminfo"))
-        request(fullRequest);
-    else if (fullRequest.contains("/splash"))
-        request(fullRequest);
-    else if (fullRequest.contains("/devices"))
-        request(fullRequest);
-    else if (fullRequest.contains("/reload"))
-        request(fullRequest);
-    else if (fullRequest.contains("/getoption"))
-        request(fullRequest);
-    else if (fullRequest.contains("/binds"))
-        request(fullRequest);
-    else if (fullRequest.contains("/cursorpos"))
-        request(fullRequest);
-    else if (fullRequest.contains("/animations"))
-        request(fullRequest);
-    else if (fullRequest.contains("/globalshortcuts"))
-        request(fullRequest);
-    else if (fullRequest.contains("/rollinglog"))
-        request(fullRequest);
+        batchRequest(fullRequest, json);
+    else if (fullRequest.contains("/hyprpaper"))
+        requestHyprpaper(fullRequest);
     else if (fullRequest.contains("/switchxkblayout"))
         request(fullRequest, 2);
     else if (fullRequest.contains("/seterror"))
@@ -417,6 +378,8 @@ int main(int argc, char** argv) {
         request(fullRequest, 3);
     else if (fullRequest.contains("/plugin"))
         request(fullRequest, 1);
+    else if (fullRequest.contains("/dismissnotify"))
+        request(fullRequest, 0);
     else if (fullRequest.contains("/notify"))
         request(fullRequest, 2);
     else if (fullRequest.contains("/output"))
@@ -429,17 +392,12 @@ int main(int argc, char** argv) {
         request(fullRequest, 2);
     else if (fullRequest.contains("/decorations"))
         request(fullRequest, 1);
-    else if (fullRequest.contains("/hyprpaper"))
-        requestHyprpaper(fullRequest);
-    else if (fullRequest.contains("/layouts"))
-        request(fullRequest);
     else if (fullRequest.contains("/--help"))
-        printf("%s", USAGE.c_str());
+        std::cout << USAGE << std::endl;
     else {
-        printf("%s\n", USAGE.c_str());
-        return 1;
+        request(fullRequest);
     }
 
-    printf("\n");
+    std::cout << std::endl;
     return exitStatus;
 }

hyprctl/meson.build

@@ -1,3 +1,7 @@
 executable('hyprctl', 'main.cpp',
   install: true
 )
+
+install_data('hyprctl.bash', install_dir: join_paths(get_option('datadir'), 'bash-completions'), install_tag: 'runtime', rename: 'hyprctl')
+install_data('hyprctl.fish', install_dir: join_paths(get_option('datadir'), 'fish/vendor_completions.d'), install_tag: 'runtime')
+install_data('hyprctl.zsh', install_dir: join_paths(get_option('datadir'), 'zsh/site-functions'), install_tag: 'runtime', rename: '_hyprctl')

hyprland.pc.in

@@ -5,4 +5,4 @@ Name: Hyprland
 URL: https://github.com/hyprwm/Hyprland
 Description: Hyprland header files
 Version: @HYPRLAND_VERSION@
-Cflags: -I"${includedir}/hyprland/protocols" -I"${includedir}/hyprland/wlroots" -I"${includedir}"
+Cflags: -I"${includedir}/hyprland/protocols" -I"${includedir}/hyprland/wlroots-hyprland" -I"${includedir}"

hyprpm/hyprpm.bash

@@ -0,0 +1,106 @@
+_hyprpm_cmd_0 () {
+    hyprpm list | grep Plugin | awk '{print $4}'
+}
+
+_hyprpm () {
+    if [[ $(type -t _get_comp_words_by_ref) != function ]]; then
+        echo _get_comp_words_by_ref: function not defined.  Make sure the bash-completions system package is installed
+        return 1
+    fi
+
+    local words cword
+    _get_comp_words_by_ref -n "$COMP_WORDBREAKS" words cword
+
+    local -a literals=("-n" "::=" "list" "disable" "--help" "update" "add" "--verbose" "-v" "--force" "remove" "enable" "--notify" "-h" "reload" "-f")
+
+    declare -A literal_transitions
+    literal_transitions[0]="([9]=6 [2]=2 [7]=6 [8]=6 [4]=6 [10]=2 [11]=3 [5]=2 [13]=6 [3]=3 [14]=2 [15]=6 [6]=2)"
+    literal_transitions[1]="([10]=2 [11]=3 [3]=3 [2]=2 [14]=2 [5]=2 [6]=2)"
+    literal_transitions[4]="([1]=5)"
+    literal_transitions[5]="([0]=6 [12]=6)"
+
+    declare -A match_anything_transitions
+    match_anything_transitions=([3]=2 [2]=4 [0]=1 [1]=1)
+    declare -A subword_transitions
+
+    local state=0
+    local word_index=1
+    while [[ $word_index -lt $cword ]]; do
+        local word=${words[$word_index]}
+
+        if [[ -v "literal_transitions[$state]" ]]; then
+            declare -A state_transitions
+            eval "state_transitions=${literal_transitions[$state]}"
+
+            local word_matched=0
+            for literal_id in $(seq 0 $((${#literals[@]} - 1))); do
+                if [[ ${literals[$literal_id]} = "$word" ]]; then
+                    if [[ -v "state_transitions[$literal_id]" ]]; then
+                        state=${state_transitions[$literal_id]}
+                        word_index=$((word_index + 1))
+                        word_matched=1
+                        break
+                    fi
+                fi
+            done
+            if [[ $word_matched -ne 0 ]]; then
+                continue
+            fi
+        fi
+
+        if [[ -v "match_anything_transitions[$state]" ]]; then
+            state=${match_anything_transitions[$state]}
+            word_index=$((word_index + 1))
+            continue
+        fi
+
+        return 1
+    done
+
+
+    local prefix="${words[$cword]}"
+
+    local shortest_suffix="$word"
+    for ((i=0; i < ${#COMP_WORDBREAKS}; i++)); do
+        local char="${COMP_WORDBREAKS:$i:1}"
+        local candidate="${word##*$char}"
+        if [[ ${#candidate} -lt ${#shortest_suffix} ]]; then
+            shortest_suffix=$candidate
+        fi
+    done
+    local superfluous_prefix=""
+    if [[ "$shortest_suffix" != "$word" ]]; then
+        local superfluous_prefix=${word%$shortest_suffix}
+    fi
+
+    if [[ -v "literal_transitions[$state]" ]]; then
+        local state_transitions_initializer=${literal_transitions[$state]}
+        declare -A state_transitions
+        eval "state_transitions=$state_transitions_initializer"
+
+        for literal_id in "${!state_transitions[@]}"; do
+            local literal="${literals[$literal_id]}"
+            if [[ $literal = "${prefix}"* ]]; then
+                local completion=${literal#"$superfluous_prefix"}
+                COMPREPLY+=("$completion ")
+            fi
+        done
+    fi
+    declare -A commands
+    commands=([3]=0)
+    if [[ -v "commands[$state]" ]]; then
+        local command_id=${commands[$state]}
+        local completions=()
+        mapfile -t completions < <(_hyprpm_cmd_${command_id} "$prefix" | cut -f1)
+        for item in "${completions[@]}"; do
+            if [[ $item = "${prefix}"* ]]; then
+                COMPREPLY+=("$item")
+            fi
+        done
+    fi
+
+
+    return 0
+}
+
+complete -o nospace -F _hyprpm hyprpm

hyprpm/hyprpm.fish

@@ -0,0 +1,109 @@
+function _hyprpm_1
+    set 1 $argv[1]
+    hyprpm list | grep Plugin | awk '{print $4}'
+end
+
+function _hyprpm
+    set COMP_LINE (commandline --cut-at-cursor)
+
+    set COMP_WORDS
+    echo $COMP_LINE | read --tokenize --array COMP_WORDS
+    if string match --quiet --regex '.*\s$' $COMP_LINE
+        set COMP_CWORD (math (count $COMP_WORDS) + 1)
+    else
+        set COMP_CWORD (count $COMP_WORDS)
+    end
+
+    set --local literals "-n" "::=" "list" "disable" "--help" "update" "add" "--verbose" "-v" "--force" "remove" "enable" "--notify" "-h" "reload" "-f"
+
+    set --local descriptions
+    set descriptions[1] "Send a hyprland notification for important events (e.g. load fail)"
+    set descriptions[3] "List all installed plugins"
+    set descriptions[4] "Unload a plugin"
+    set descriptions[5] "Show help menu"
+    set descriptions[6] "Check and update all plugins if needed"
+    set descriptions[7] "Install a new plugin repository from git"
+    set descriptions[8] "Enable too much loggin"
+    set descriptions[9] "Enable too much loggin"
+    set descriptions[10] "Force an operation ignoring checks (e.g. update -f)"
+    set descriptions[11] "Remove a plugin repository"
+    set descriptions[12] "Load a plugin"
+    set descriptions[13] "Send a hyprland notification for important events (e.g. load fail)"
+    set descriptions[14] "Show help menu"
+    set descriptions[15] "Reload all plugins"
+    set descriptions[16] "Force an operation ignoring checks (e.g. update -f)"
+
+    set --local literal_transitions
+    set literal_transitions[1] "set inputs 10 3 8 9 5 11 12 6 14 4 15 16 7; set tos 7 3 7 7 7 3 4 3 7 4 3 7 3"
+    set literal_transitions[2] "set inputs 11 12 4 3 15 6 7; set tos 3 4 4 3 3 3 3"
+    set literal_transitions[5] "set inputs 2; set tos 6"
+    set literal_transitions[6] "set inputs 1 13; set tos 7 7"
+
+    set --local match_anything_transitions_from 4 3 1 2
+    set --local match_anything_transitions_to 3 5 2 2
+
+    set --local state 1
+    set --local word_index 2
+    while test $word_index -lt $COMP_CWORD
+        set --local -- word $COMP_WORDS[$word_index]
+
+        if set --query literal_transitions[$state] && test -n $literal_transitions[$state]
+            set --local --erase inputs
+            set --local --erase tos
+            eval $literal_transitions[$state]
+
+            if contains -- $word $literals
+                set --local literal_matched 0
+                for literal_id in (seq 1 (count $literals))
+                    if test $literals[$literal_id] = $word
+                        set --local index (contains --index -- $literal_id $inputs)
+                        set state $tos[$index]
+                        set word_index (math $word_index + 1)
+                        set literal_matched 1
+                        break
+                    end
+                end
+                if test $literal_matched -ne 0
+                    continue
+                end
+            end
+        end
+
+        if set --query match_anything_transitions_from[$state] && test -n $match_anything_transitions_from[$state]
+            set --local index (contains --index -- $state $match_anything_transitions_from)
+            set state $match_anything_transitions_to[$index]
+            set word_index (math $word_index + 1)
+            continue
+        end
+
+        return 1
+    end
+
+    if set --query literal_transitions[$state] && test -n $literal_transitions[$state]
+        set --local --erase inputs
+        set --local --erase tos
+        eval $literal_transitions[$state]
+        for literal_id in $inputs
+            if test -n $descriptions[$literal_id]
+                printf '%s\t%s\n' $literals[$literal_id] $descriptions[$literal_id]
+            else
+                printf '%s\n' $literals[$literal_id]
+            end
+        end
+    end
+
+    set command_states 4
+    set command_ids 1
+    if contains $state $command_states
+        set --local index (contains --index $state $command_states)
+        set --local function_id $command_ids[$index]
+        set --local function_name _hyprpm_$function_id
+        set --local --erase inputs
+        set --local --erase tos
+        $function_name "$COMP_WORDS[$COMP_CWORD]"
+    end
+
+    return 0
+end
+
+complete --command hyprpm --no-files --arguments "(_hyprpm)"

hyprpm/hyprpm.usage

@@ -0,0 +1,19 @@
+hyprpm [<FLAGS>]... <ARGUMENT>
+
+
+<FLAGS> ::= (--notify | -n)             "Send a hyprland notification for important events (e.g. load fail)"
+        |   (--help | -h)               "Show help menu"
+        |   (--verbose | -v)            "Enable too much loggin"
+        |   (--force | -f)              "Force an operation ignoring checks (e.g. update -f)"
+        ;
+
+<ARGUMENT> ::= (add)                    "Install a new plugin repository from git"
+        |   (remove)                    "Remove a plugin repository"
+        |   (update)                    "Check and update all plugins if needed"
+        |   (list)                      "List all installed plugins"
+        |   (enable <PLUGINS>)          "Load a plugin"
+        |   (disable <PLUGINS>)         "Unload a plugin"
+        |   (reload)                    "Reload all plugins"
+        ;
+
+<PLUGINS> ::= {{{ hyprpm list | grep Plugin | awk '{print $4}' }}};

hyprpm/hyprpm.zsh

@@ -0,0 +1,151 @@
+#compdef hyprpm
+
+_hyprpm_cmd_0 () {
+    hyprpm list | grep Plugin | awk '{print $4}'
+}
+
+_hyprpm () {
+    local -a literals=("-n" "::=" "list" "disable" "--help" "update" "add" "--verbose" "-v" "--force" "remove" "enable" "--notify" "-h" "reload" "-f")
+
+    local -A descriptions
+    descriptions[1]="Send a hyprland notification for important events (e.g. load fail)"
+    descriptions[3]="List all installed plugins"
+    descriptions[4]="Unload a plugin"
+    descriptions[5]="Show help menu"
+    descriptions[6]="Check and update all plugins if needed"
+    descriptions[7]="Install a new plugin repository from git"
+    descriptions[8]="Enable too much loggin"
+    descriptions[9]="Enable too much loggin"
+    descriptions[10]="Force an operation ignoring checks (e.g. update -f)"
+    descriptions[11]="Remove a plugin repository"
+    descriptions[12]="Load a plugin"
+    descriptions[13]="Send a hyprland notification for important events (e.g. load fail)"
+    descriptions[14]="Show help menu"
+    descriptions[15]="Reload all plugins"
+    descriptions[16]="Force an operation ignoring checks (e.g. update -f)"
+
+    local -A literal_transitions
+    literal_transitions[1]="([10]=7 [3]=3 [8]=7 [9]=7 [5]=7 [11]=3 [12]=4 [6]=3 [14]=7 [4]=4 [15]=3 [16]=7 [7]=3)"
+    literal_transitions[2]="([11]=3 [12]=4 [4]=4 [3]=3 [15]=3 [6]=3 [7]=3)"
+    literal_transitions[5]="([2]=6)"
+    literal_transitions[6]="([1]=7 [13]=7)"
+
+    local -A match_anything_transitions
+    match_anything_transitions=([4]=3 [3]=5 [1]=2 [2]=2)
+
+    declare -A subword_transitions
+
+    local state=1
+    local word_index=2
+    while [[ $word_index -lt $CURRENT ]]; do
+        if [[ -v "literal_transitions[$state]" ]]; then
+            local -A state_transitions
+            eval "state_transitions=${literal_transitions[$state]}"
+
+            local word=${words[$word_index]}
+            local word_matched=0
+            for ((literal_id = 1; literal_id <= $#literals; literal_id++)); do
+                if [[ ${literals[$literal_id]} = "$word" ]]; then
+                    if [[ -v "state_transitions[$literal_id]" ]]; then
+                        state=${state_transitions[$literal_id]}
+                        word_index=$((word_index + 1))
+                        word_matched=1
+                        break
+                    fi
+                fi
+            done
+            if [[ $word_matched -ne 0 ]]; then
+                continue
+            fi
+        fi
+
+        if [[ -v "match_anything_transitions[$state]" ]]; then
+            state=${match_anything_transitions[$state]}
+            word_index=$((word_index + 1))
+            continue
+        fi
+
+        return 1
+    done
+
+    completions_no_description_trailing_space=()
+    completions_no_description_no_trailing_space=()
+    completions_trailing_space=()
+    suffixes_trailing_space=()
+    descriptions_trailing_space=()
+    completions_no_trailing_space=()
+    suffixes_no_trailing_space=()
+    descriptions_no_trailing_space=()
+
+    if [[ -v "literal_transitions[$state]" ]]; then
+        local -A state_transitions
+        eval "state_transitions=${literal_transitions[$state]}"
+
+        for literal_id in ${(k)state_transitions}; do
+            if [[ -v "descriptions[$literal_id]" ]]; then
+                completions_trailing_space+=("${literals[$literal_id]}")
+                suffixes_trailing_space+=("${literals[$literal_id]}")
+                descriptions_trailing_space+=("${descriptions[$literal_id]}")
+            else
+                completions_no_description_trailing_space+=("${literals[$literal_id]}")
+            fi
+        done
+    fi
+    local -A commands=([4]=0)
+
+    if [[ -v "commands[$state]" ]]; then
+        local command_id=${commands[$state]}
+        local output=$(_hyprpm_cmd_${command_id} "${words[$CURRENT]}")
+        local -a command_completions=("${(@f)output}")
+        for line in ${command_completions[@]}; do
+            local parts=(${(@s:	:)line})
+            if [[ -v "parts[2]" ]]; then
+                completions_trailing_space+=("${parts[1]}")
+                suffixes_trailing_space+=("${parts[1]}")
+                descriptions_trailing_space+=("${parts[2]}")
+            else
+                completions_no_description_trailing_space+=("${parts[1]}")
+            fi
+        done
+    fi
+
+    local maxlen=0
+    for suffix in ${suffixes_trailing_space[@]}; do
+        if [[ ${#suffix} -gt $maxlen ]]; then
+            maxlen=${#suffix}
+        fi
+    done
+    for suffix in ${suffixes_no_trailing_space[@]}; do
+        if [[ ${#suffix} -gt $maxlen ]]; then
+            maxlen=${#suffix}
+        fi
+    done
+
+    for ((i = 1; i <= $#suffixes_trailing_space; i++)); do
+        if [[ -z ${descriptions_trailing_space[$i]} ]]; then
+            descriptions_trailing_space[$i]="${(r($maxlen)( ))${suffixes_trailing_space[$i]}}"
+        else
+            descriptions_trailing_space[$i]="${(r($maxlen)( ))${suffixes_trailing_space[$i]}} -- ${descriptions_trailing_space[$i]}"
+        fi
+    done
+
+    for ((i = 1; i <= $#suffixes_no_trailing_space; i++)); do
+        if [[ -z ${descriptions_no_trailing_space[$i]} ]]; then
+            descriptions_no_trailing_space[$i]="${(r($maxlen)( ))${suffixes_no_trailing_space[$i]}}"
+        else
+            descriptions_no_trailing_space[$i]="${(r($maxlen)( ))${suffixes_no_trailing_space[$i]}} -- ${descriptions_no_trailing_space[$i]}"
+        fi
+    done
+
+    compadd -Q -a completions_no_description_trailing_space
+    compadd -Q -S ' ' -a completions_no_description_no_trailing_space
+    compadd -l -Q -a -d descriptions_trailing_space completions_trailing_space
+    compadd -l -Q -S '' -a -d descriptions_no_trailing_space completions_no_trailing_space
+    return 0
+}
+
+if [[ $ZSH_EVAL_CONTEXT =~ :file$ ]]; then
+    compdef _hyprpm hyprpm
+else
+    _hyprpm
+fi

hyprpm/src/core/DataState.cpp

@@ -45,11 +45,13 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
         {"repository", toml::table{
             {"name", repo.name},
             {"hash", repo.hash},
-            {"url", repo.url}
+            {"url", repo.url},
+            {"rev", repo.rev}
         }}
     };
     for (auto& p : repo.plugins) {
         // copy .so to the good place
+        if (std::filesystem::exists(p.filename))
             std::filesystem::copy_file(p.filename, PATH + "/" + p.name + ".so");
 
         DATA.emplace(p.name, toml::table{
@@ -177,12 +179,14 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
 
         const auto        NAME = STATE["repository"]["name"].value_or("");
         const auto        URL  = STATE["repository"]["url"].value_or("");
+        const auto        REV  = STATE["repository"]["rev"].value_or("");
         const auto        HASH = STATE["repository"]["hash"].value_or("");
 
         SPluginRepository repo;
         repo.hash = HASH;
         repo.name = NAME;
         repo.url  = URL;
+        repo.rev  = REV;
 
         for (const auto& [key, val] : STATE) {
             if (key == "repository")

hyprpm/src/core/Manifest.cpp

@@ -75,6 +75,7 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
         for (auto& plugin : m_vPlugins) {
             plugin.description = manifest[plugin.name]["description"].value_or("?");
             plugin.output      = manifest[plugin.name]["output"].value_or("?");
+            plugin.since       = manifest[plugin.name]["since_hyprland"].value_or(0);
             auto authors       = manifest[plugin.name]["authors"].as_array();
             if (authors) {
                 for (auto&& a : *authors) {

hyprpm/src/core/Manifest.hpp

@@ -19,6 +19,7 @@ class CManifest {
         std::vector<std::string> authors;
         std::vector<std::string> buildSteps;
         std::string              output;
+        int                      since  = 0;
         bool                     failed = false;
     };
 

hyprpm/src/core/Plugin.hpp

@@ -12,6 +12,7 @@ struct SPlugin {
 
 struct SPluginRepository {
     std::string          url;
+    std::string          rev;
     std::string          name;
     std::vector<SPlugin> plugins;
     std::string          hash;

hyprpm/src/core/PluginManager.cpp

@@ -70,15 +70,29 @@ SHyprlandVersion CPluginManager::getHyprlandVersion() {
     std::string hlbranch = HLVERCALL.substr(HLVERCALL.find("from branch") + 12);
     hlbranch             = hlbranch.substr(0, hlbranch.find(" at commit "));
 
-    if (m_bVerbose)
-        std::cout << Colors::BLUE << "[v] " << Colors::RESET << "parsed commit " << hlcommit << " at branch " << hlbranch << "\n";
+    std::string hldate = HLVERCALL.substr(HLVERCALL.find("Date: ") + 6);
+    hldate             = hldate.substr(0, hldate.find("\n"));
 
-    ver = SHyprlandVersion{hlbranch, hlcommit};
+    std::string hlcommits;
+
+    if (HLVERCALL.contains("commits:")) {
+        hlcommits = HLVERCALL.substr(HLVERCALL.find("commits:") + 9);
+        hlcommits = hlcommits.substr(0, hlcommits.find(" "));
+    }
+
+    int commits = 0;
+    try {
+        commits = std::stoi(hlcommits);
+    } catch (...) { ; }
+
+    if (m_bVerbose)
+        std::cout << Colors::BLUE << "[v] " << Colors::RESET << "parsed commit " << hlcommit << " at branch " << hlbranch << " on " << hldate << ", commits " << commits << "\n";
+
+    ver = SHyprlandVersion{hlbranch, hlcommit, hldate, commits};
     return ver;
 }
 
-bool CPluginManager::addNewPluginRepo(const std::string& url) {
-
+bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string& rev) {
     const auto HLVER = getHyprlandVersion();
 
     if (DataState::pluginRepoExists(url)) {
@@ -134,6 +148,14 @@ bool CPluginManager::addNewPluginRepo(const std::string& url) {
         return false;
     }
 
+    if (!rev.empty()) {
+        std::string ret = execAndGet("git -C /tmp/hyprpm/new reset --hard --recurse-submodules " + rev);
+        if (ret.compare(0, 6, "fatal:") == 0) {
+            std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not check out revision " << rev << ". shell returned:\n" << ret << "\n";
+            return false;
+        }
+    }
+
     progress.m_iSteps = 1;
     progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " cloned");
     progress.m_szCurrentMessage = "Reading the manifest";
@@ -207,6 +229,12 @@ bool CPluginManager::addNewPluginRepo(const std::string& url) {
     for (auto& p : pManifest->m_vPlugins) {
         std::string out;
 
+        if (p.since > HLVER.commits && HLVER.commits >= 1 /* for --depth 1 clones, we can't check this. */) {
+            progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Not building " + p.name + ": your Hyprland version is too old.\n");
+            p.failed = true;
+            continue;
+        }
+
         progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + p.name);
 
         for (auto& bs : p.buildSteps) {
@@ -214,14 +242,16 @@ bool CPluginManager::addNewPluginRepo(const std::string& url) {
             out += " -> " + cmd + "\n" + execAndGet(cmd) + "\n";
         }
 
-        if (!std::filesystem::exists("/tmp/hyprpm/new/" + p.output)) {
-            progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Plugin " + p.name + " failed to build.\n");
-
         if (m_bVerbose)
             std::cout << Colors::BLUE << "[v] " << Colors::RESET << "shell returned: " << out << "\n";
 
-            p.failed = true;
+        if (!std::filesystem::exists("/tmp/hyprpm/new/" + p.output)) {
+            progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Plugin " + p.name + " failed to build.\n" +
+                                       "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n  If you are on -git, update "
+                                       "first.\n  Try re-running with -v to see "
+                                       "more verbose output.\n");
 
+            p.failed = true;
             continue;
         }
 
@@ -240,6 +270,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url) {
         repohash.pop_back();
     repo.name = pManifest->m_sRepository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_sRepository.name;
     repo.url  = url;
+    repo.rev  = rev;
     repo.hash = repohash;
     for (auto& p : pManifest->m_vPlugins) {
         repo.plugins.push_back(SPlugin{p.name, "/tmp/hyprpm/new/" + p.output, false, p.failed});
@@ -289,7 +320,7 @@ eHeadersErrors CPluginManager::headersValid() {
         return HEADERS_MISSING;
 
     // find headers commit
-    std::string cmd     = std::format("PKG_CONFIG_PATH=\"{}/share/pkgconfig\" pkg-config --cflags --keep-system-cflags hyprland", DataState::getHeadersPath());
+    std::string cmd     = std::format("PKG_CONFIG_PATH=\"{}/share/pkgconfig\" pkgconf --cflags --keep-system-cflags hyprland", DataState::getHeadersPath());
     auto        headers = execAndGet(cmd.c_str());
 
     if (!headers.contains("-I/"))
@@ -307,7 +338,7 @@ eHeadersErrors CPluginManager::headersValid() {
         else
             headers = "";
 
-        if (PATH.ends_with("protocols") || PATH.ends_with("wlroots"))
+        if (PATH.ends_with("protocols") || PATH.ends_with("wlroots-hyprland"))
             continue;
 
         verHeader = removeBeginEndSpacesTabs(PATH.substr(2)) + "/hyprland/src/version.h";
@@ -325,7 +356,12 @@ eHeadersErrors CPluginManager::headersValid() {
     std::string verHeaderContent((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
     ifs.close();
 
-    std::string hash = verHeaderContent.substr(verHeaderContent.find("#define GIT_COMMIT_HASH") + 23);
+    const auto HASHPOS = verHeaderContent.find("#define GIT_COMMIT_HASH");
+
+    if (HASHPOS == std::string::npos || HASHPOS + 23 >= verHeaderContent.length())
+        return HEADERS_CORRUPTED;
+
+    std::string hash = verHeaderContent.substr(HASHPOS + 23);
     hash             = hash.substr(0, hash.find_first_of('\n'));
     hash             = hash.substr(hash.find_first_of('"') + 1);
     hash             = hash.substr(0, hash.find_first_of('"'));
@@ -365,7 +401,7 @@ bool CPluginManager::updateHeaders(bool force) {
 
     progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " Cloning https://github.com/hyprwm/hyprland, this might take a moment.");
 
-    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland");
+    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland --shallow-since='" + HLVER.date + "'");
 
     if (!std::filesystem::exists("/tmp/hyprpm/hyprland")) {
         std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the hyprland repository. shell returned:\n" << ret << "\n";
@@ -377,8 +413,8 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.m_szCurrentMessage = "Checking out sources";
     progress.print();
 
-    ret =
-        execAndGet("cd /tmp/hyprpm/hyprland && git checkout " + HLVER.branch + " 2>&1 && git submodule update --init 2>&1 && git reset --hard --recurse-submodules " + HLVER.hash);
+    ret = execAndGet("cd /tmp/hyprpm/hyprland && git checkout " + HLVER.branch +
+                     " 2>&1 && git rm subprojects/tracy && git submodule update --init 2>&1 && git reset --hard --recurse-submodules " + HLVER.hash);
 
     if (m_bVerbose)
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "git returned: " + ret);
@@ -400,7 +436,7 @@ bool CPluginManager::updateHeaders(bool force) {
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "cmake returned: " + ret);
 
     // le hack. Wlroots has to generate its build/include
-    ret = execAndGet("cd /tmp/hyprpm/hyprland/subprojects/wlroots && meson setup -Drenderers=gles2 -Dexamples=false build");
+    ret = execAndGet("cd /tmp/hyprpm/hyprland/subprojects/wlroots-hyprland && meson setup -Drenderers=gles2 -Dexamples=false build");
     if (m_bVerbose)
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "meson returned: " + ret);
 
@@ -409,10 +445,6 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.m_szCurrentMessage = "Installing sources";
     progress.print();
 
-    // progress.printMessageAbove(
-    //     std::string{Colors::YELLOW} + "!" + Colors::RESET +
-    //     " in order to install the sources, you will need to input your password.\n  If nothing pops up, make sure you have polkit and an authentication daemon running.");
-
     std::string cmd = std::format("sed -i -e \"s#PREFIX = /usr/local#PREFIX = {}#\" /tmp/hyprpm/hyprland/Makefile && cd /tmp/hyprpm/hyprland && make installheaders",
                                   DataState::getHeadersPath());
     if (m_bVerbose)
@@ -494,6 +526,16 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             return false;
         }
 
+        if (!repo.rev.empty()) {
+            progress.printMessageAbove(std::string{Colors::RESET} + " → Plugin has revision set, resetting: " + repo.rev);
+
+            std::string ret = execAndGet("git -C /tmp/hyprpm/update reset --hard --recurse-submodules " + repo.rev);
+            if (ret.compare(0, 6, "fatal:") == 0) {
+                std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " could not check out revision " + repo.rev + ": shell returned:\n" + ret;
+                return false;
+            }
+        }
+
         if (!update) {
             // check if git has updates
             std::string hash = execAndGet("cd /tmp/hyprpm/update && git rev-parse HEAD");
@@ -538,8 +580,8 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             continue;
         }
 
-        if (!pManifest->m_sRepository.commitPins.empty()) {
-            // check commit pins
+        if (repo.rev.empty() && !pManifest->m_sRepository.commitPins.empty()) {
+            // check commit pins unless a revision is specified
 
             progress.printMessageAbove(std::string{Colors::RESET} + " → Manifest has " + std::to_string(pManifest->m_sRepository.commitPins.size()) + " pins, checking");
 
@@ -553,10 +595,15 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             }
         }
 
-        bool failed = false;
         for (auto& p : pManifest->m_vPlugins) {
             std::string out;
 
+            if (p.since > HLVER.commits && HLVER.commits >= 1 /* for --depth 1 clones, we can't check this. */) {
+                progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Not building " + p.name + ": your Hyprland version is too old.\n");
+                p.failed = true;
+                continue;
+            }
+
             progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + p.name);
 
             for (auto& bs : p.buildSteps) {
@@ -564,20 +611,22 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
                 out += " -> " + cmd + "\n" + execAndGet(cmd) + "\n";
             }
 
-            if (!std::filesystem::exists("/tmp/hyprpm/update/" + p.output)) {
-                std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Plugin " << p.name << " failed to build.\n";
-                failed = true;
             if (m_bVerbose)
                 std::cout << Colors::BLUE << "[v] " << Colors::RESET << "shell returned: " << out << "\n";
-                break;
+
+            if (!std::filesystem::exists("/tmp/hyprpm/update/" + p.output)) {
+                std::cerr << "\n"
+                          << Colors::RED << "✖" << Colors::RESET << " Plugin " << p.name << " failed to build.\n"
+                          << "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n  If you are on -git, update first.\n  Try "
+                             "re-running with -v to see more verbose "
+                             "output.\n";
+                p.failed = true;
+                continue;
             }
 
             progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " built " + p.name + " into " + p.output);
         }
 
-        if (failed)
-            continue;
-
         // add repo toml to DataState
         SPluginRepository newrepo = repo;
         newrepo.plugins.clear();

hyprpm/src/core/PluginManager.hpp

@@ -32,11 +32,13 @@ enum ePluginLoadStateReturn {
 struct SHyprlandVersion {
     std::string branch;
     std::string hash;
+    std::string date;
+    int         commits = 0;
 };
 
 class CPluginManager {
   public:
-    bool                   addNewPluginRepo(const std::string& url);
+    bool                   addNewPluginRepo(const std::string& url, const std::string& rev);
     bool                   removePluginRepo(const std::string& urlOrName);
 
     eHeadersErrors         headersValid();

hyprpm/src/main.cpp

@@ -11,7 +11,8 @@
 
 const std::string HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
-┣ add [url]              → Install a new plugin repository from git
+┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision
+┃                          is optional, when set, commit locks are ignored.
 ┣ remove [url/name]      → Remove an installed plugin repository
 ┣ enable [name]          → Enable a plugin
 ┣ disable [name]         → Disable a plugin
@@ -55,7 +56,7 @@ int               main(int argc, char** argv, char** envp) {
                 force = true;
                 std::cout << Colors::RED << "!" << Colors::RESET << " Using --force, I hope you know what you are doing.\n";
             } else {
-                std::cerr << "Unrecognized option " << ARGS[i];
+                std::cerr << "Unrecognized option " << ARGS[i] << "\n";
                 return 1;
             }
         } else {
@@ -77,7 +78,12 @@ int               main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        return g_pPluginManager->addNewPluginRepo(command[1]) ? 0 : 1;
+        std::string rev = "";
+        if (command.size() >= 3) {
+            rev = command[2];
+        }
+
+        return g_pPluginManager->addNewPluginRepo(command[1], rev) ? 0 : 1;
     } else if (command[0] == "remove") {
         if (ARGS.size() < 2) {
             std::cerr << Colors::RED << "✖" << Colors::RESET << " Not enough args for remove.\n";

hyprpm/src/meson.build

@@ -8,3 +8,7 @@ executable('hyprpm', src,
   ],
   install : true
 )
+
+install_data('../hyprpm.bash', install_dir: join_paths(get_option('datadir'), 'bash-completions'), install_tag: 'runtime', rename: 'hyprpm')
+install_data('../hyprpm.fish', install_dir: join_paths(get_option('datadir'), 'fish/vendor_completions.d'), install_tag: 'runtime')
+install_data('../hyprpm.zsh', install_dir: join_paths(get_option('datadir'), 'zsh/site-functions'), install_tag: 'runtime', rename: '_hyprpm')

meson.build

@@ -33,7 +33,7 @@ if cpp_compiler.check_header('execinfo.h')
   add_project_arguments('-DHAS_EXECINFO', language: 'cpp')
 endif
 
-wlroots = subproject('wlroots', default_options: ['examples=false', 'renderers=gles2'])
+wlroots = subproject('wlroots-hyprland', default_options: ['examples=false', 'renderers=gles2'])
 have_xwlr = wlroots.get_variable('features').get('xwayland')
 xcb_dep = dependency('xcb', required: get_option('xwayland'))
 

nix/default.nix

@@ -2,16 +2,20 @@
   lib,
   stdenv,
   pkg-config,
+  pkgconf,
   makeWrapper,
   meson,
   ninja,
   binutils,
   cairo,
   git,
+  hyprcursor,
   hyprland-protocols,
+  hyprlang,
   jq,
   libGL,
   libdrm,
+  libexecinfo,
   libinput,
   libxcb,
   libxkbcommon,
@@ -24,7 +28,7 @@
   wayland,
   wayland-protocols,
   wayland-scanner,
-  wlroots,
+  wlroots-hyprland,
   xcbutilwm,
   xwayland,
   debug ? false,
@@ -42,7 +46,9 @@
 }:
 assert lib.assertMsg (!nvidiaPatches) "The option `nvidiaPatches` has been removed.";
 assert lib.assertMsg (!enableNvidiaPatches) "The option `enableNvidiaPatches` has been removed.";
-assert lib.assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been removed. Please refer https://wiki.hyprland.org/Configuring/XWayland";
+assert lib.assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been removed. Please refer https://wiki.hyprland.org/Configuring/XWayland"; let
+  wlr = wlroots-hyprland.override {inherit enableXWayland;};
+in
   stdenv.mkDerivation {
     pname = "hyprland${lib.optionalString debug "-debug"}";
     inherit version;
@@ -55,55 +61,6 @@ assert lib.assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been remov
       src = lib.cleanSource ../.;
     };
 
-    nativeBuildInputs = [
-      jq
-      meson
-      ninja
-      pkg-config
-      makeWrapper
-      wayland-scanner
-    ];
-
-    outputs = [
-      "out"
-      "man"
-      "dev"
-    ];
-
-    buildInputs =
-      [
-        cairo
-        git
-        hyprland-protocols
-        libdrm
-        libGL
-        libinput
-        libxkbcommon
-        mesa
-        pango
-        pciutils
-        tomlplusplus
-        udis86
-        wayland
-        wayland-protocols
-        wlroots
-      ]
-      ++ lib.optionals enableXWayland [libxcb xcbutilwm xwayland]
-      ++ lib.optionals withSystemd [systemd];
-
-    mesonBuildType =
-      if debug
-      then "debug"
-      else "release";
-
-    mesonAutoFeatures = "disabled";
-
-    mesonFlags = builtins.concatLists [
-      (lib.optional enableXWayland "-Dxwayland=enabled")
-      (lib.optional legacyRenderer "-Dlegacy_renderer=enabled")
-      (lib.optional withSystemd "-Dsystemd=enabled")
-    ];
-
     patches = [
       # make meson use the provided wlroots instead of the git submodule
       ./patches/meson-build.patch
@@ -128,14 +85,69 @@ assert lib.assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been remov
       }'
     '';
 
+    nativeBuildInputs = [
+      jq
+      makeWrapper
+      meson
+      ninja
+      pkg-config
+      wayland-scanner
+    ];
+
+    outputs = [
+      "out"
+      "man"
+      "dev"
+    ];
+
+    buildInputs =
+      wlr.buildInputs
+      ++ [
+        cairo
+        git
+        hyprcursor.dev
+        hyprland-protocols
+        hyprlang
+        libdrm
+        libGL
+        libinput
+        libxkbcommon
+        mesa
+        pango
+        pciutils
+        tomlplusplus
+        udis86
+        wayland
+        wayland-protocols
+        wlr
+      ]
+      ++ lib.optionals stdenv.hostPlatform.isMusl [libexecinfo]
+      ++ lib.optionals enableXWayland [libxcb xcbutilwm xwayland]
+      ++ lib.optionals withSystemd [systemd];
+
+    mesonBuildType =
+      if debug
+      then "debug"
+      else "release";
+
+    mesonAutoFeatures = "disabled";
+
+    mesonFlags = [
+      (lib.mesonEnable "xwayland" enableXWayland)
+      (lib.mesonEnable "legacy_renderer" legacyRenderer)
+      (lib.mesonEnable "systemd" withSystemd)
+    ];
+
     postInstall = ''
-      ln -s ${wlroots}/include/wlr $dev/include/hyprland/wlroots
+      ln -s ${wlr}/include/wlr $dev/include/hyprland/wlroots
+
       ${lib.optionalString wrapRuntimeDeps ''
         wrapProgram $out/bin/Hyprland \
           --suffix PATH : ${lib.makeBinPath [
           stdenv.cc
           binutils
           pciutils
+          pkgconf
         ]}
       ''}
     '';
@@ -143,10 +155,10 @@ assert lib.assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been remov
     passthru.providedSessions = ["hyprland"];
 
     meta = with lib; {
-      homepage = "https://github.com/vaxerski/Hyprland";
+      homepage = "https://github.com/hyprwm/Hyprland";
       description = "A dynamic tiling Wayland compositor that doesn't sacrifice on its looks";
       license = licenses.bsd3;
-      platforms = platforms.linux;
+      platforms = wlr.meta.platforms;
       mainProgram = "Hyprland";
     };
   }

nix/overlays.nix

@@ -21,7 +21,9 @@ in {
   # Packages for variations of Hyprland, dependencies included.
   hyprland-packages = lib.composeManyExtensions [
     # Dependencies
+    inputs.hyprcursor.overlays.default
     inputs.hyprland-protocols.overlays.default
+    inputs.hyprlang.overlays.default
     self.overlays.wlroots-hyprland
     self.overlays.udis86
     # Hyprland packages themselves
@@ -31,9 +33,9 @@ in {
       hyprland = final.callPackage ./default.nix {
         stdenv = final.gcc13Stdenv;
         version = "${props.version}+date=${date}_${self.shortRev or "dirty"}";
-        wlroots = prev.wlroots-hyprland;
         commit = self.rev or "";
-        inherit (final) udis86 hyprland-protocols;
+        udis86 = final.udis86-hyprland; # explicit override until decided on breaking change of the name
+        inherit (final) wlroots-hyprland; # explicit override until decided on breaking change of the name
         inherit date;
       };
       hyprland-unwrapped = final.hyprland.override {wrapRuntimeDeps = false;};
@@ -61,7 +63,7 @@ in {
   ];
 
   udis86 = final: prev: {
-    udis86 = final.callPackage ./udis86.nix {};
+    udis86-hyprland = final.callPackage ./udis86.nix {};
   };
 
   # Patched version of wlroots for Hyprland.

nix/patches/meson-build.patch

@@ -6,7 +6,7 @@ index 1d2c7f9f..c5ef4e67 100644
    add_project_arguments('-DHAS_EXECINFO', language: 'cpp')
  endif
  
--wlroots = subproject('wlroots', default_options: ['examples=false', 'renderers=gles2'])
+-wlroots = subproject('wlroots-hyprland', default_options: ['examples=false', 'renderers=gles2'])
 -have_xwlr = wlroots.get_variable('features').get('xwayland')
 -xcb_dep = dependency('xcb', required: get_option('xwayland'))
 -
@@ -34,17 +34,19 @@ index 1d2c7f9f..c5ef4e67 100644
  headers = globber.stdout().strip().split('\n')
  foreach file : headers
 diff --git a/src/meson.build b/src/meson.build
-index 0af864b9..38723b8c 100644
+index 45701f5f..3505cefe 100644
 --- a/src/meson.build
 +++ b/src/meson.build
-@@ -9,16 +9,16 @@ executable('Hyprland', src,
+@@ -9,7 +9,7 @@ executable('Hyprland', src,
      server_protos,
      dependency('wayland-server'),
      dependency('wayland-client'),
 -    wlroots.get_variable('wlroots'),
 +    dependency('wlroots'),
      dependency('cairo'),
-     dependency('libdrm'),
+     dependency('hyprcursor'),
+     dependency('hyprlang', version: '>= 0.3.2'),
+@@ -16,12 +16,12 @@ executable('Hyprland', src,
      dependency('egl'),
      dependency('xkbcommon'),
      dependency('libinput'),

props.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.35.0"
+    "version": "0.39.0"
 }

scripts/generateVersion.sh

@@ -2,11 +2,12 @@
 cp -fr ./src/version.h.in ./src/version.h
 
 HASH=$(git rev-parse HEAD)
-BRANCH=$(git rev-parse --abbrev-ref HEAD)
+BRANCH=$(git branch --show-current)
 MESSAGE=$(git show ${GIT_COMMIT_HASH} | head -n 5 | tail -n 1 | sed -e 's/#//g' -e 's/\"//g')
 DATE=$(git show ${GIT_COMMIT_HASH} --no-patch --format=%cd --date=local)
 DIRTY=$(git diff-index --quiet HEAD -- || echo dirty)
 TAG=$(git describe --tags)
+COMMITS=$(git rev-list --count HEAD)
 
 sed -i -e "s#@HASH@#${HASH}#" ./src/version.h
 sed -i -e "s#@BRANCH@#${BRANCH}#" ./src/version.h
@@ -14,3 +15,4 @@ sed -i -e "s#@MESSAGE@#${MESSAGE}#" ./src/version.h
 sed -i -e "s#@DATE@#${DATE}#" ./src/version.h
 sed -i -e "s#@DIRTY@#${DIRTY}#" ./src/version.h
 sed -i -e "s#@TAG@#${TAG}#" ./src/version.h
+sed -i -e "s#@COMMITS@#${COMMITS}#" ./src/version.h

scripts/hyprlandStaticAsan.diff

@@ -0,0 +1,20 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1190876d..0e7573f9 100755
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -110,6 +110,7 @@ pkg_check_modules(deps REQUIRED IMPORTED_TARGET
+     cairo pango pangocairo pixman-1
+     libdrm libinput hwdata libseat libdisplay-info libliftoff libudev gbm
+     hyprlang>=0.3.2 hyprcursor
++    libffi
+ )
+ 
+ file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
+@@ -130,6 +131,7 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+         message(STATUS "Enabling ASan")
+ 
+         target_link_libraries(Hyprland asan)
++        target_link_libraries(Hyprland ${CMAKE_SOURCE_DIR}/libwayland-server.a)
+         target_compile_options(Hyprland PUBLIC -fsanitize=address)
+     endif()
+ 

scripts/waylandStatic.diff

@@ -0,0 +1,23 @@
+diff --git a/src/meson.build b/src/meson.build
+index 5d04334..6645eec 100644
+--- a/src/meson.build
++++ b/src/meson.build
+@@ -170,7 +170,7 @@ if get_option('libraries')
+ 		error('We probably need to bump the SONAME of libwayland-server and -client')
+ 	endif
+ 
+-	wayland_server = library(
++	wayland_server = static_library(
+ 		'wayland-server',
+ 		sources: [
+ 			wayland_server_protocol_core_h,
+@@ -180,9 +180,6 @@ if get_option('libraries')
+ 			'wayland-shm.c',
+ 			'event-loop.c'
+ 		],
+-		# To avoid an unnecessary SONAME bump, wayland 1.x.y produces
+-		# libwayland-server.so.0.x.y.
+-		version: '.'.join(['0', wayland_version[1], wayland_version[2]]),
+ 		dependencies: [
+ 			epoll_dep,
+ 			ffi_dep,

src/Compositor.hpp

@@ -21,8 +21,8 @@
 #include "debug/HyprDebugOverlay.hpp"
 #include "debug/HyprNotificationOverlay.hpp"
 #include "helpers/Monitor.hpp"
-#include "helpers/Workspace.hpp"
-#include "Window.hpp"
+#include "desktop/Workspace.hpp"
+#include "desktop/Window.hpp"
 #include "render/Renderer.hpp"
 #include "render/OpenGL.hpp"
 #include "hyprerror/HyprError.hpp"
@@ -57,7 +57,6 @@ class CCompositor {
     wlr_layer_shell_v1*                        m_sWLRLayerShell;
     wlr_xdg_shell*                             m_sWLRXDGShell;
     wlr_cursor*                                m_sWLRCursor;
-    wlr_xcursor_manager*                       m_sWLRXCursorMgr;
     wlr_virtual_keyboard_manager_v1*           m_sWLRVKeyboardMgr;
     wlr_output_manager_v1*                     m_sWLROutputMgr;
     wlr_presentation*                          m_sWLRPresentation;
@@ -93,9 +92,7 @@ class CCompositor {
     std::vector<std::shared_ptr<CMonitor>>    m_vMonitors;
     std::vector<std::shared_ptr<CMonitor>>    m_vRealMonitors; // for all monitors, even those turned off
     std::vector<std::unique_ptr<CWindow>>     m_vWindows;
-    std::vector<std::unique_ptr<SXDGPopup>>   m_vXDGPopups;
-    std::vector<std::unique_ptr<CWorkspace>>  m_vWorkspaces;
-    std::vector<std::unique_ptr<SSubsurface>> m_vSubsurfaces;
+    std::vector<PHLWORKSPACE>                 m_vWorkspaces;
     std::vector<CWindow*>                     m_vWindowsFadingOut;
     std::vector<SLayerSurface*>               m_vSurfacesFadingOut;
 
@@ -121,6 +118,7 @@ class CCompositor {
     bool                                      m_bUnsafeState    = false;   // unsafe state is when there is no monitors.
     bool                                      m_bNextIsUnsafe   = false;   // because wlroots
     CMonitor*                                 m_pUnsafeOutput   = nullptr; // fallback output for the unsafe state
+    bool                                      m_bExitTriggered  = false;   // For exit dispatcher
     bool                                      m_bIsShuttingDown = false;
 
     // ------------------------------------------------- //
@@ -135,23 +133,26 @@ class CCompositor {
     void           focusSurface(wlr_surface*, CWindow* pWindowOwner = nullptr);
     bool           windowExists(CWindow*);
     bool           windowValidMapped(CWindow*);
+    bool           monitorExists(CMonitor*);
     CWindow*       vectorToWindowUnified(const Vector2D&, uint8_t properties, CWindow* pIgnoreWindow = nullptr);
     wlr_surface*   vectorToLayerSurface(const Vector2D&, std::vector<std::unique_ptr<SLayerSurface>>*, Vector2D*, SLayerSurface**);
-    SIMEPopup*     vectorToIMEPopup(const Vector2D& pos, std::list<SIMEPopup>& popups);
+    wlr_surface*   vectorToLayerPopupSurface(const Vector2D&, CMonitor* monitor, Vector2D*, SLayerSurface**);
     wlr_surface*   vectorWindowToSurface(const Vector2D&, CWindow*, Vector2D& sl);
     Vector2D       vectorToSurfaceLocal(const Vector2D&, CWindow*, wlr_surface*);
     CMonitor*      getMonitorFromOutput(wlr_output*);
-    CWindow*       getWindowForPopup(wlr_xdg_popup*);
+    CMonitor*      getRealMonitorFromOutput(wlr_output*);
     CWindow*       getWindowFromSurface(wlr_surface*);
     CWindow*       getWindowFromHandle(uint32_t);
     CWindow*       getWindowFromZWLRHandle(wl_resource*);
-    bool           isWorkspaceVisible(const int&);
-    CWorkspace*    getWorkspaceByID(const int&);
-    CWorkspace*    getWorkspaceByName(const std::string&);
-    CWorkspace*    getWorkspaceByString(const std::string&);
+    bool           isWorkspaceVisible(PHLWORKSPACE);
+    PHLWORKSPACE   getWorkspaceByID(const int&);
+    PHLWORKSPACE   getWorkspaceByName(const std::string&);
+    PHLWORKSPACE   getWorkspaceByString(const std::string&);
     void           sanityCheckWorkspaces();
     void           updateWorkspaceWindowDecos(const int&);
-    int            getWindowsOnWorkspace(const int&);
+    void           updateWorkspaceSpecialRenderData(const int&);
+    int            getWindowsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {});
+    int            getGroupsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {});
     CWindow*       getUrgentWindow();
     bool           hasUrgentWindowOnWorkspace(const int&);
     CWindow*       getFirstWindowOnWorkspace(const int&);
@@ -167,18 +168,18 @@ class CCompositor {
     int            getNextAvailableNamedWorkspace();
     bool           isPointOnAnyMonitor(const Vector2D&);
     bool           isPointOnReservedArea(const Vector2D& point, const CMonitor* monitor = nullptr);
-    CWindow*       getConstraintWindow(SMouse*);
     CMonitor*      getMonitorInDirection(const char&);
+    CMonitor*      getMonitorInDirection(CMonitor*, const char&);
     void           updateAllWindowsAnimatedDecorationValues();
     void           updateWorkspaceWindows(const int64_t& id);
     void           updateWindowAnimatedDecorationValues(CWindow*);
     int            getNextAvailableMonitorID(std::string const& name);
-    void           moveWorkspaceToMonitor(CWorkspace*, CMonitor*, bool noWarpCursor = false);
+    void           moveWorkspaceToMonitor(PHLWORKSPACE, CMonitor*, bool noWarpCursor = false);
     void           swapActiveWorkspaces(CMonitor*, CMonitor*);
     CMonitor*      getMonitorFromString(const std::string&);
     bool           workspaceIDOutOfBounds(const int64_t&);
-    void           setWindowFullscreen(CWindow*, bool, eFullscreenMode);
-    void           updateFullscreenFadeOnWorkspace(CWorkspace*);
+    void           setWindowFullscreen(CWindow*, bool, eFullscreenMode mode = FULLSCREEN_INVALID);
+    void           updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
     CWindow*       getX11Parent(CWindow*);
     void           scheduleFrameForMonitor(CMonitor*);
     void           addToFadingOutSafe(SLayerSurface*);
@@ -190,13 +191,13 @@ class CCompositor {
     void           closeWindow(CWindow*);
     Vector2D       parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
     void           forceReportSizesToWindowsOnWorkspace(const int&);
-    CWorkspace*    createNewWorkspace(const int&, const int&, const std::string& name = ""); // will be deleted next frame if left empty and unfocused!
+    PHLWORKSPACE   createNewWorkspace(const int&, const int&, const std::string& name = ""); // will be deleted next frame if left empty and unfocused!
     void           renameWorkspace(const int&, const std::string& name = "");
     void           setActiveMonitor(CMonitor*);
     bool           isWorkspaceSpecial(const int&);
     int            getNewSpecialID();
     void           performUserChecks();
-    void           moveWindowToWorkspaceSafe(CWindow* pWindow, CWorkspace* pWorkspace);
+    void           moveWindowToWorkspaceSafe(CWindow* pWindow, PHLWORKSPACE pWorkspace);
     CWindow*       getForceFocus();
     void           notifyIdleActivity();
     void           setIdleActivityInhibit(bool inhibit);
@@ -234,4 +235,7 @@ inline std::map<std::string, xcb_atom_t> HYPRATOMS = {HYPRATOM("_NET_WM_WINDOW_T
                                                       HYPRATOM("_NET_WM_WINDOW_TYPE_POPUP_MENU"),
                                                       HYPRATOM("_NET_WM_WINDOW_TYPE_TOOLTIP"),
                                                       HYPRATOM("_NET_WM_WINDOW_TYPE_NOTIFICATION"),
-                                                      HYPRATOM("_KDE_NET_WM_WINDOW_TYPE_OVERRIDE")};
+                                                      HYPRATOM("_KDE_NET_WM_WINDOW_TYPE_OVERRIDE"),
+                                                      HYPRATOM("_NET_SUPPORTING_WM_CHECK"),
+                                                      HYPRATOM("_NET_WM_NAME"),
+                                                      HYPRATOM("UTF8_STRING")};

src/SharedDefs.hpp

@@ -70,3 +70,5 @@ struct SHyprCtlCommand {
     bool                                                          exact = true;
     std::function<std::string(eHyprCtlOutputFormat, std::string)> fn;
 };
+
+typedef std::function<void(void*, SCallbackInfo&, std::any)> HOOK_CALLBACK_FN;

src/config/ConfigDataValues.hpp

@@ -1,10 +1,12 @@
 #pragma once
 #include "../defines.hpp"
+#include "../helpers/VarList.hpp"
 #include <vector>
 
 enum eConfigValueDataTypes {
     CVD_TYPE_INVALID   = -1,
-    CVD_TYPE_GRADIENT = 0
+    CVD_TYPE_GRADIENT  = 0,
+    CVD_TYPE_CSS_VALUE = 1
 };
 
 class ICustomConfigValueData {
@@ -12,6 +14,8 @@ class ICustomConfigValueData {
     virtual ~ICustomConfigValueData() = 0;
 
     virtual eConfigValueDataTypes getDataType() = 0;
+
+    virtual std::string           toString() = 0;
 };
 
 class CGradientValueData : public ICustomConfigValueData {
@@ -49,4 +53,70 @@ class CGradientValueData : public ICustomConfigValueData {
 
         return true;
     }
+
+    virtual std::string toString() {
+        std::string result;
+        for (auto& c : m_vColors) {
+            result += std::format("{:x} ", c.getAsHex());
+        }
+
+        result += std::format("{}deg", (int)(m_fAngle * 180.0 / M_PI));
+        return result;
+    }
+};
+
+class CCssGapData : public ICustomConfigValueData {
+  public:
+    CCssGapData() : top(0), right(0), bottom(0), left(0){};
+    CCssGapData(int64_t global) : top(global), right(global), bottom(global), left(global){};
+    CCssGapData(int64_t vertical, int64_t horizontal) : top(vertical), right(horizontal), bottom(vertical), left(horizontal){};
+    CCssGapData(int64_t top, int64_t horizontal, int64_t bottom) : top(top), right(horizontal), bottom(bottom), left(horizontal){};
+    CCssGapData(int64_t top, int64_t right, int64_t bottom, int64_t left) : top(top), right(right), bottom(bottom), left(left){};
+
+    /* Css like directions */
+    int64_t top;
+    int64_t right;
+    int64_t bottom;
+    int64_t left;
+
+    void    parseGapData(CVarList varlist) {
+        switch (varlist.size()) {
+            case 1: {
+                *this = CCssGapData(std::stoi(varlist[0]));
+                break;
+            }
+            case 2: {
+                *this = CCssGapData(std::stoi(varlist[0]), std::stoi(varlist[1]));
+                break;
+            }
+            case 3: {
+                *this = CCssGapData(std::stoi(varlist[0]), std::stoi(varlist[1]), std::stoi(varlist[2]));
+                break;
+            }
+            case 4: {
+                *this = CCssGapData(std::stoi(varlist[0]), std::stoi(varlist[1]), std::stoi(varlist[2]), std::stoi(varlist[3]));
+                break;
+            }
+            default: {
+                Debug::log(WARN, "Too many arguments provided for gaps.");
+                *this = CCssGapData(std::stoi(varlist[0]), std::stoi(varlist[1]), std::stoi(varlist[2]), std::stoi(varlist[3]));
+                break;
+            }
+        }
+    }
+
+    void reset(int64_t global) {
+        top    = global;
+        right  = global;
+        bottom = global;
+        left   = global;
+    }
+
+    virtual eConfigValueDataTypes getDataType() {
+        return CVD_TYPE_CSS_VALUE;
+    }
+
+    virtual std::string toString() {
+        return std::format("{} {} {} {}", top, right, bottom, left);
+    }
 };

src/config/ConfigManager.hpp

@@ -13,28 +13,22 @@
 #include <optional>
 #include <functional>
 #include <xf86drmMode.h>
-#include "../Window.hpp"
 #include "../helpers/WLClasses.hpp"
 #include "../helpers/Monitor.hpp"
 #include "../helpers/VarList.hpp"
+#include "../desktop/Window.hpp"
 
 #include "defaultConfig.hpp"
 #include "ConfigDataValues.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 SConfigValue {
-    int64_t                                 intValue   = -INT64_MAX;
-    float                                   floatValue = -__FLT_MAX__;
-    std::string                             strValue   = "";
-    Vector2D                                vecValue   = Vector2D(-__FLT_MAX__, -__FLT_MAX__);
-    std::shared_ptr<ICustomConfigValueData> data;
-
-    bool                                    set = false; // used for device configs
-};
+class CWindow;
 
 struct SWorkspaceRule {
     std::string                        monitor         = "";
@@ -43,14 +37,15 @@ struct SWorkspaceRule {
     int                                workspaceId     = -1;
     bool                               isDefault       = false;
     bool                               isPersistent    = false;
-    std::optional<int64_t>             gapsIn;
-    std::optional<int64_t>             gapsOut;
+    std::optional<CCssGapData>         gapsIn;
+    std::optional<CCssGapData>         gapsOut;
     std::optional<int64_t>             borderSize;
     std::optional<int>                 border;
     std::optional<int>                 rounding;
     std::optional<int>                 decorate;
     std::optional<int>                 shadow;
     std::optional<std::string>         onCreatedEmptyRunCmd;
+    std::optional<std::string>         defaultName;
     std::map<std::string, std::string> layoutopts;
 };
 
@@ -76,7 +71,12 @@ struct SAnimationPropertyConfig {
 struct SPluginKeyword {
     HANDLE                       handle = 0;
     std::string                  name   = "";
-    std::function<void(const std::string&, const std::string&)> fn;
+    Hyprlang::PCONFIGHANDLERFUNC fn     = nullptr;
+};
+
+struct SPluginVariable {
+    HANDLE      handle = 0;
+    std::string name   = "";
 };
 
 struct SExecRequestedRule {
@@ -91,44 +91,37 @@ class CConfigManager {
     void                                                            tick();
     void                                                            init();
 
-    int                                                             getInt(const std::string&);
-    float                                                           getFloat(const std::string&);
-    Vector2D                                                        getVec(const std::string&);
-    std::string                                                     getString(const std::string&);
-    void                                                            setFloat(const std::string&, float);
-    void                                                            setInt(const std::string&, int);
-    void                                                            setVec(const std::string&, Vector2D);
-    void                                                            setString(const std::string&, const std::string&);
-
     int                                                             getDeviceInt(const std::string&, const std::string&, const std::string& fallback = "");
     float                                                           getDeviceFloat(const std::string&, const std::string&, const std::string& fallback = "");
     Vector2D                                                        getDeviceVec(const std::string&, const std::string&, const std::string& fallback = "");
     std::string                                                     getDeviceString(const std::string&, const std::string&, const std::string& fallback = "");
     bool                                                            deviceConfigExists(const std::string&);
+    Hyprlang::CConfigValue*                                         getConfigValueSafeDevice(const std::string& dev, const std::string& val, const std::string& fallback);
     bool                                                            shouldBlurLS(const std::string&);
 
-    SConfigValue*                                                   getConfigValuePtr(const std::string&);
-    SConfigValue*                                                   getConfigValuePtrSafe(const std::string&);
+    void* const*                                                    getConfigValuePtr(const std::string&);
+    Hyprlang::CConfigValue*                                         getHyprlangConfigValuePtr(const std::string& name, const std::string& specialCat = "");
+    void                                                            onPluginLoadUnload(const std::string& name, bool load);
     static std::string                                              getConfigDir();
     static std::string                                              getMainConfigPath();
 
-    SMonitorRule                                                    getMonitorRuleFor(const std::string&, const std::string& displayName = "");
-    SWorkspaceRule                                                  getWorkspaceRuleFor(CWorkspace*);
+    SMonitorRule                                                    getMonitorRuleFor(const CMonitor&);
+    SWorkspaceRule                                                  getWorkspaceRuleFor(PHLWORKSPACE workspace);
     std::string                                                     getDefaultWorkspaceFor(const std::string&);
 
     CMonitor*                                                       getBoundMonitorForWS(const std::string&);
     std::string                                                     getBoundMonitorStringForWS(const std::string&);
     const std::deque<SWorkspaceRule>&                               getAllWorkspaceRules();
 
-    std::vector<SWindowRule>                                        getMatchingRules(CWindow*);
+    std::vector<SWindowRule>                                        getMatchingRules(CWindow*, bool dynamic = true, bool shadowExec = false);
     std::vector<SLayerRule>                                         getMatchingRules(SLayerSurface*);
 
     std::unordered_map<std::string, SMonitorAdditionalReservedArea> m_mAdditionalReservedAreas;
 
     std::unordered_map<std::string, SAnimationPropertyConfig>       getAnimationConfig();
 
-    void                                                            addPluginConfigVar(HANDLE handle, const std::string& name, const SConfigValue& value);
-    void addPluginKeyword(HANDLE handle, const std::string& name, std::function<void(const std::string& cmd, const std::string& val)> fun);
+    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.
@@ -141,7 +134,7 @@ class CConfigManager {
     void                      ensureMonitorStatus();
     void                      ensureVRR(CMonitor* pMonitor = nullptr);
 
-    std::string               parseKeyword(const std::string&, const std::string&, bool dynamic = false);
+    std::string               parseKeyword(const std::string&, const std::string&);
 
     void                      addParseError(const std::string&);
 
@@ -150,29 +143,44 @@ class CConfigManager {
     void                      addExecRule(const SExecRequestedRule&);
 
     void                      handlePluginLoads();
+    std::string               getErrors();
+
+    // keywords
+    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> 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;
 
   private:
+    std::unique_ptr<Hyprlang::CConfig>                        m_pConfig;
+
     std::deque<std::string>                                   configPaths;       // stores all the config paths
     std::unordered_map<std::string, time_t>                   configModifyTimes; // stores modify times
-    std::vector<std::pair<std::string, std::string>>                                           configDynamicVars; // stores dynamic vars declared by the user
-    std::unordered_map<std::string, SConfigValue>                                              configValues;
-    std::unordered_map<std::string, std::unordered_map<std::string, SConfigValue>>             deviceConfigs; // stores device configs
 
     std::unordered_map<std::string, SAnimationPropertyConfig> animationConfig; // stores all the animations with their set values
 
-    std::string                                                                                currentCategory = ""; // For storing the category of the current item
-
-    std::string                                                                                parseError = ""; // For storing a parse error to display later
-
     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<std::string>                                  m_vDeclaredPlugins;
-    std::unordered_map<HANDLE, std::unique_ptr<std::unordered_map<std::string, SConfigValue>>> pluginConfigs; // stores plugin configs
     std::vector<SPluginKeyword>                               pluginKeywords;
+    std::vector<SPluginVariable>                              pluginVariables;
 
     bool                                                      isFirstLaunch = true; // For exec-once
 
@@ -186,42 +194,17 @@ class CConfigManager {
     bool                                                      m_bManualCrashInitiated = false;
     std::deque<std::string>                                   firstExecRequests;
 
-    std::vector<std::pair<std::string, std::string>>                                           environmentVariables;
-
     std::vector<std::pair<std::string, std::string>>          m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
+    std::string                                               m_szConfigErrors = "";
 
     // internal methods
-    void         setDefaultVars();
-    void         setDefaultAnimationVars();
-    void         setDeviceDefaultVars(const std::string&);
-    void         populateEnvironment();
-
     void                       setAnimForChildren(SAnimationPropertyConfig* const);
     void                       updateBlurredLS(const std::string&, const bool);
-
-    void         applyUserDefinedVars(std::string&, const size_t);
-    void         loadConfigLoadVars();
-    SConfigValue getConfigValueSafe(const std::string&);
-    SConfigValue getConfigValueSafeDevice(const std::string&, const std::string&, const std::string& fallback = "");
-    void         parseLine(std::string&);
-    void         configSetValueSafe(const std::string&, const std::string&);
-    void         handleDeviceConfig(const std::string&, const std::string&);
-    void         handleRawExec(const std::string&, const std::string&);
-    void         handleMonitor(const std::string&, const std::string&);
-    void         handleBind(const std::string&, const std::string&);
-    void         handleUnbind(const std::string&, const std::string&);
-    void         handleWindowRule(const std::string&, const std::string&);
-    void         handleLayerRule(const std::string&, const std::string&);
-    void         handleWindowRuleV2(const std::string&, const std::string&);
-    void         handleWorkspaceRules(const std::string&, const std::string&);
-    void         handleBezier(const std::string&, const std::string&);
-    void         handleAnimation(const std::string&, const std::string&);
-    void         handleSource(const std::string&, const std::string&);
-    void         handleSubmap(const std::string&, const std::string&);
-    void         handleBlurLS(const std::string&, const std::string&);
-    void         handleBindWS(const std::string&, const std::string&);
-    void         handleEnv(const std::string&, const std::string&);
-    void         handlePlugin(const std::string&, const std::string&);
+    void                       setDefaultAnimationVars();
+    std::optional<std::string> resetHLConfig();
+    std::optional<std::string> verifyConfigExists();
+    void                       postConfigReload(const Hyprlang::CParseResult& result);
+    void                       reload();
 };
 
 inline std::unique_ptr<CConfigManager> g_pConfigManager;

src/config/ConfigValue.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <string>
+#include <typeindex>
+#include <hyprlang.hpp>
+#include "../debug/Log.hpp"
+#include "../macros.hpp"
+#include "ConfigManager.hpp"
+
+template <typename T>
+class CConfigValue {
+  public:
+    CConfigValue(const std::string& val) {
+        const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val.c_str());
+
+        p_ = PVHYPRLANG->getDataStaticPtr();
+
+#ifdef HYPRLAND_DEBUG
+        // verify type
+        const auto ANY  = PVHYPRLANG->getValue();
+        const auto TYPE = std::type_index(ANY.type());
+
+        // exceptions
+        const bool STRINGEX = (typeid(T) == typeid(std::string) && TYPE == typeid(Hyprlang::STRING));
+        const bool CUSTOMEX = (typeid(T) == typeid(Hyprlang::CUSTOMTYPE) && (TYPE == typeid(Hyprlang::CUSTOMTYPE*) || TYPE == typeid(void*) /* dunno why it does this? */));
+
+        RASSERT(typeid(T) == TYPE || STRINGEX || CUSTOMEX, "Mismatched type in CConfigValue<T>, got {} but has {}", typeid(T).name(), TYPE.name());
+#endif
+    }
+
+    T* ptr() const {
+        return *(T* const*)p_;
+    }
+
+    T operator*() const {
+        return *ptr();
+    }
+
+  private:
+    void* const* p_ = nullptr;
+};
+
+template <>
+inline std::string* CConfigValue<std::string>::ptr() const {
+    RASSERT(false, "Impossible to implement ptr() of CConfigValue<std::string>");
+    return nullptr;
+}
+
+template <>
+inline std::string CConfigValue<std::string>::operator*() const {
+    return std::string{*(Hyprlang::STRING*)p_};
+}
+
+template <>
+inline Hyprlang::STRING* CConfigValue<Hyprlang::STRING>::ptr() const {
+    return (Hyprlang::STRING*)p_;
+}
+
+template <>
+inline Hyprlang::STRING CConfigValue<Hyprlang::STRING>::operator*() const {
+    return *(Hyprlang::STRING*)p_;
+}
+
+template <>
+inline Hyprlang::CUSTOMTYPE* CConfigValue<Hyprlang::CUSTOMTYPE>::ptr() const {
+    return *(Hyprlang::CUSTOMTYPE* const*)p_;
+}
+
+template <>
+inline Hyprlang::CUSTOMTYPE CConfigValue<Hyprlang::CUSTOMTYPE>::operator*() const {
+    RASSERT(false, "Impossible to implement operator* of CConfigValue<Hyprlang::CUSTOMTYPE>, use ptr()");
+    return *ptr();
+}

src/config/defaultConfig.hpp

@@ -3,11 +3,11 @@
 #include <string>
 
 inline const std::string AUTOCONFIG = R"#(
-########################################################################################
-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.
-########################################################################################
+# #######################################################################################
+# 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.
+# #######################################################################################
 
 #
 # Please note not all available settings / options are set here.
@@ -51,7 +51,7 @@ input {
         natural_scroll = no
     }
 
-    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
+    sensitivity = 0 # -1.0 to 1.0, 0 means no modification.
 }
 
 general {
@@ -123,8 +123,9 @@ misc {
 }
 
 # Example per-device config
-# See https://wiki.hyprland.org/Configuring/Keywords/#executing for more
-device:epic-mouse-v1 {
+# See https://wiki.hyprland.org/Configuring/Keywords/#per-device-input-configs for more
+device {
+    name = epic-mouse-v1
     sensitivity = -0.5
 }
 
@@ -133,7 +134,7 @@ device:epic-mouse-v1 {
 # Example windowrule v2
 # windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
 # See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
-windowrulev2 = nomaximizerequest, class:.* # You'll probably like this.
+windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
 
 
 # See https://wiki.hyprland.org/Configuring/Keywords/ for more

src/debug/CrashReporter.cpp

@@ -3,6 +3,7 @@
 #include <sys/utsname.h>
 #include <fstream>
 #include <signal.h>
+#include <link.h>
 
 #include "../plugins/PluginSystem.hpp"
 
@@ -105,16 +106,38 @@ void CrashReporter::createAndSaveCrash(int sig) {
     const auto FPATH = std::filesystem::canonical("/proc/self/exe");
 #endif
 
+    std::string addrs = "";
     for (size_t i = 0; i < CALLSTACK.size(); ++i) {
-        finalCrashReport += std::format("\t#{} | {}\n", i, CALLSTACK[i].desc);
-
-#ifdef __clang__
-        const auto CMD = std::format("llvm-addr2line -e {} -f 0x{:x}", FPATH.c_str(), (uint64_t)CALLSTACK[i].adr);
+#ifdef __GLIBC__
+        // convert in memory address to VMA address
+        Dl_info          info;
+        struct link_map* linkMap;
+        dladdr1((void*)CALLSTACK[i].adr, &info, (void**)&linkMap, RTLD_DL_LINKMAP);
+        size_t vmaAddr = (size_t)CALLSTACK[i].adr - linkMap->l_addr;
 #else
-        const auto CMD = std::format("addr2line -e {} -f 0x{:x}", FPATH.c_str(), (uint64_t)CALLSTACK[i].adr);
+        // musl doesn't define dladdr1
+        size_t vmaAddr = (size_t)CALLSTACK[i].adr;
 #endif
-        const auto ADDR2LINE = replaceInString(execAndGet(CMD.c_str()), "\n", "\n\t\t");
-        finalCrashReport += "\t\t" + ADDR2LINE.substr(0, ADDR2LINE.length() - 2);
+
+        addrs += std::format("0x{:x} ", vmaAddr);
+    }
+#ifdef __clang__
+    const auto CMD = std::format("llvm-addr2line -e {} -Cf {}", FPATH.c_str(), addrs);
+#else
+    const auto CMD = std::format("addr2line -e {} -Cf {}", FPATH.c_str(), addrs);
+#endif
+
+    const auto        ADDR2LINE = execAndGet(CMD.c_str());
+
+    std::stringstream ssin(ADDR2LINE);
+
+    for (size_t i = 0; i < CALLSTACK.size(); ++i) {
+        finalCrashReport += std::format("\t#{} | {}", i, CALLSTACK[i].desc);
+        std::string functionInfo;
+        std::string fileLineInfo;
+        std::getline(ssin, functionInfo);
+        std::getline(ssin, fileLineInfo);
+        finalCrashReport += std::format("\n\t\t{}\n\t\t{}\n", functionInfo, fileLineInfo);
     }
 
     finalCrashReport += "\n\nLog tail:\n";
@@ -128,22 +151,19 @@ void CrashReporter::createAndSaveCrash(int sig) {
         return;
 
     std::ofstream ofs;
-    std::string   path;
-    if (!CACHE_HOME || std::string(CACHE_HOME).empty()) {
-        if (!std::filesystem::exists(std::string(HOME) + "/.hyprland"))
-            std::filesystem::create_directory(std::string(HOME) + "/.hyprland");
+    std::string   reportDir;
+
+    if (!CACHE_HOME || std::string(CACHE_HOME).empty())
+        reportDir = std::string(HOME) + "/.cache/hyprland";
+    else
+        reportDir = std::string(CACHE_HOME) + "/hyprland";
+
+    if (!std::filesystem::exists(reportDir))
+        std::filesystem::create_directory(reportDir);
+    const auto path = reportDir + "/hyprlandCrashReport" + std::to_string(PID) + ".txt";
 
-        path = std::string(HOME) + "/.hyprland/hyprlandCrashReport" + std::to_string(PID) + ".txt";
     ofs.open(path, std::ios::trunc);
 
-    } else {
-        if (!std::filesystem::exists(std::string(CACHE_HOME) + "/hyprland"))
-            std::filesystem::create_directory(std::string(CACHE_HOME) + "/hyprland");
-
-        path = std::string(CACHE_HOME) + "/hyprland/hyprlandCrashReport" + std::to_string(PID) + ".txt";
-        ofs.open(path, std::ios::trunc);
-    }
-
     ofs << finalCrashReport;
 
     ofs.close();

src/debug/HyprCtl.cpp

@@ -10,23 +10,51 @@
 #include <sys/utsname.h>
 #include <sys/un.h>
 #include <unistd.h>
-#include <errno.h>
 
 #include <sstream>
 #include <string>
+#include <typeindex>
+
+#include "../config/ConfigDataValues.hpp"
+#include "../config/ConfigValue.hpp"
+#include "../managers/CursorManager.hpp"
+#include "../hyprerror/HyprError.hpp"
 
 static void trimTrailingComma(std::string& str) {
     if (!str.empty() && str.back() == ',')
         str.pop_back();
 }
 
-static std::string getWorkspaceNameFromSpecialID(const int workspaceID) {
-    if (workspaceID == 0)
-        return "";
-    const auto* workspace = g_pCompositor->getWorkspaceByID(workspaceID);
-    if (!workspace)
-        return "";
-    return workspace->m_szName;
+static std::string formatToString(uint32_t drmFormat) {
+    switch (drmFormat) {
+        case DRM_FORMAT_XRGB2101010: return "XRGB2101010";
+        case DRM_FORMAT_XBGR2101010: return "XBGR2101010";
+        case DRM_FORMAT_XRGB8888: return "XRGB8888";
+        case DRM_FORMAT_XBGR8888: return "XBGR8888";
+        default: break;
+    }
+
+    return "Invalid";
+}
+
+static std::string availableModesForOutput(CMonitor* pMonitor, eHyprCtlOutputFormat format) {
+    std::string result;
+
+    if (!wl_list_empty(&pMonitor->output->modes)) {
+        wlr_output_mode* mode;
+
+        wl_list_for_each(mode, &pMonitor->output->modes, link) {
+
+            if (format == FORMAT_NORMAL)
+                result += std::format("{}x{}@{:.2f}Hz ", mode->width, mode->height, mode->refresh / 1000.0);
+            else
+                result += std::format("\"{}x{}@{:.2f}Hz\",", mode->width, mode->height, mode->refresh / 1000.0);
+        }
+
+        result.pop_back();
+    }
+
+    return result;
 }
 
 std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
@@ -74,15 +102,18 @@ std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
     "focused": {},
     "dpmsStatus": {},
     "vrr": {},
-    "activelyTearing": {}
+    "activelyTearing": {},
+    "disabled": {},
+    "currentFormat": "{}",
+    "availableModes": [{}]
 }},)#",
-                m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szDescription), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
+                m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
                 (m->output->serial ? m->output->serial : ""), (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
-                m->activeWorkspace, (m->activeWorkspace == -1 ? "" : escapeJSONStrings(g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName)), m->specialWorkspaceID,
-                escapeJSONStrings(getWorkspaceNameFromSpecialID(m->specialWorkspaceID)), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
+                m->activeWorkspaceID(), (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_szName)), m->activeSpecialWorkspaceID(),
+                escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
                 (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false"),
                 (m->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"),
-                m->tearingState.activelyTearing ? "true" : "false");
+                (m->tearingState.activelyTearing ? "true" : "false"), (m->m_bEnabled ? "false" : "true"), formatToString(m->drmFormat), availableModesForOutput(m.get(), format));
         }
 
         trimTrailingComma(result);
@@ -93,17 +124,17 @@ std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
             if (!m->output || m->ID == -1ull)
                 continue;
 
-            result +=
-                std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\tspecial "
+            result += std::format(
+                "Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\tspecial "
                 "workspace: {} ({})\n\treserved: {} "
                 "{} {} {}\n\tscale: {:.2f}\n\ttransform: "
-                            "{}\n\tfocused: {}\n\tdpmsStatus: {}\n\tvrr: {}\n\tactivelyTearing: {}\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->szDescription,
-                            (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""), (m->output->serial ? m->output->serial : ""), m->activeWorkspace,
-                            (m->activeWorkspace == -1 ? "" : g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName), m->specialWorkspaceID,
-                            getWorkspaceNameFromSpecialID(m->specialWorkspaceID), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x,
-                            (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus,
-                            (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED), m->tearingState.activelyTearing);
+                "{}\n\tfocused: {}\n\tdpmsStatus: {}\n\tvrr: {}\n\tactivelyTearing: {}\n\tdisabled: {}\n\tcurrentFormat: {}\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->make : ""), (m->output->model ? m->output->model : ""), (m->output->serial ? 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.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED),
+                m->tearingState.activelyTearing, !m->m_bEnabled, formatToString(m->drmFormat), availableModesForOutput(m.get(), format));
         }
     }
 
@@ -171,31 +202,24 @@ static std::string getWindowData(CWindow* w, eHyprCtlOutputFormat format) {
     "swallowing": "0x{:x}",
     "focusHistoryID": {}
 }},)#",
-            (uintptr_t)w, (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
-            (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
-            escapeJSONStrings(w->m_iWorkspaceID == -1                                ? "" :
-                                  g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
-                                                                                       std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))),
-            ((int)w->m_bIsFloating == 1 ? "true" : "false"), (int64_t)w->m_iMonitorID, escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)),
-            escapeJSONStrings(g_pXWaylandManager->getTitle(w)), escapeJSONStrings(w->m_szInitialClass), escapeJSONStrings(w->m_szInitialTitle), w->getPID(),
-            ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"), (w->m_bIsFullscreen ? "true" : "false"),
-            (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? (int)g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
+            (uintptr_t)w, (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"), (int64_t)w->m_iMonitorID,
+            escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)), escapeJSONStrings(g_pXWaylandManager->getTitle(w)), escapeJSONStrings(w->m_szInitialClass),
+            escapeJSONStrings(w->m_szInitialTitle), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"),
+            (w->m_bIsFullscreen ? "true" : "false"), (w->m_bIsFullscreen ? (w->m_pWorkspace ? (int)w->m_pWorkspace->m_efFullscreenMode : 0) : 0),
             w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format), (uintptr_t)w->m_pSwallowed, getFocusHistoryID(w));
     } else {
-        return std::format(
-            "Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
+        return std::format("Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
                            "{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
                            "{}\n\txwayland: {}\n\tpinned: "
                            "{}\n\tfullscreen: {}\n\tfullscreenmode: {}\n\tfakefullscreen: {}\n\tgrouped: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\n",
-            (uintptr_t)w, w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
-            (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
-            (w->m_iWorkspaceID == -1                                ? "" :
-                 g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
-                                                                      std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))),
-            (int)w->m_bIsFloating, (int64_t)w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w), g_pXWaylandManager->getTitle(w), w->m_szInitialClass, w->m_szInitialTitle,
-            w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
-            (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
-            (int)w->m_bFakeFullscreenState, getGroupedData(w, format), (uintptr_t)w->m_pSwallowed, getFocusHistoryID(w));
+                           (uintptr_t)w, 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 ? "" : std::to_string(w->workspaceID())), (int)w->m_bIsFloating, (int64_t)w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w),
+                           g_pXWaylandManager->getTitle(w), w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
+                           (w->m_bIsFullscreen ? (w->m_pWorkspace ? w->m_pWorkspace->m_efFullscreenMode : 0) : 0), (int)w->m_bFakeFullscreenState, getGroupedData(w, format),
+                           (uintptr_t)w->m_pSwallowed, getFocusHistoryID(w));
     }
 }
 
@@ -205,6 +229,9 @@ std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
         result += "[";
 
         for (auto& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
+                continue;
+
             result += getWindowData(w.get(), format);
         }
 
@@ -213,13 +240,16 @@ std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
         result += "]";
     } else {
         for (auto& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
+                continue;
+
             result += getWindowData(w.get(), format);
         }
     }
     return result;
 }
 
-static std::string getWorkspaceData(CWorkspace* w, eHyprCtlOutputFormat format) {
+static std::string getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format) {
     const auto PLASTW   = w->getLastFocusedWindow();
     const auto PMONITOR = g_pCompositor->getMonitorFromID(w->m_iMonitorID);
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -249,8 +279,12 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
         const std::string monitor    = r.monitor.empty() ? "" : std::format(",\n    \"monitor\": \"{}\"", escapeJSONStrings(r.monitor));
         const std::string default_   = (bool)(r.isDefault) ? std::format(",\n    \"default\": {}", boolToString(r.isDefault)) : "";
         const std::string persistent = (bool)(r.isPersistent) ? std::format(",\n    \"persistent\": {}", boolToString(r.isPersistent)) : "";
-        const std::string gapsIn     = (bool)(r.gapsIn) ? std::format(",\n    \"gapsIn\": {}", r.gapsIn.value()) : "";
-        const std::string gapsOut    = (bool)(r.gapsOut) ? std::format(",\n    \"gapsOut\": {}", r.gapsOut.value()) : "";
+        const std::string gapsIn     = (bool)(r.gapsIn) ?
+                std::format(",\n    \"gapsIn\": [{}, {}, {}, {}]", r.gapsIn.value().top, r.gapsIn.value().right, r.gapsIn.value().bottom, r.gapsIn.value().left) :
+                "";
+        const std::string gapsOut    = (bool)(r.gapsOut) ?
+               std::format(",\n    \"gapsOut\": [{}, {}, {}, {}]", r.gapsOut.value().top, r.gapsOut.value().right, r.gapsOut.value().bottom, r.gapsOut.value().left) :
+               "";
         const std::string borderSize = (bool)(r.borderSize) ? std::format(",\n    \"borderSize\": {}", r.borderSize.value()) : "";
         const std::string border     = (bool)(r.border) ? std::format(",\n    \"border\": {}", boolToString(r.border.value())) : "";
         const std::string rounding   = (bool)(r.rounding) ? std::format(",\n    \"rounding\": {}", boolToString(r.rounding.value())) : "";
@@ -267,8 +301,12 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
         const std::string monitor    = std::format("\tmonitor: {}\n", r.monitor.empty() ? "<unset>" : escapeJSONStrings(r.monitor));
         const std::string default_   = std::format("\tdefault: {}\n", (bool)(r.isDefault) ? boolToString(r.isDefault) : "<unset>");
         const std::string persistent = std::format("\tpersistent: {}\n", (bool)(r.isPersistent) ? boolToString(r.isPersistent) : "<unset>");
-        const std::string gapsIn     = std::format("\tgapsIn: {}\n", (bool)(r.gapsIn) ? std::to_string(r.gapsIn.value()) : "<unset>");
-        const std::string gapsOut    = std::format("\tgapsOut: {}\n", (bool)(r.gapsOut) ? std::to_string(r.gapsOut.value()) : "<unset>");
+        const std::string gapsIn     = (bool)(r.gapsIn) ? std::format("\tgapsIn: {} {} {} {}\n", std::to_string(r.gapsIn.value().top), std::to_string(r.gapsIn.value().right),
+                                                                      std::to_string(r.gapsIn.value().bottom), std::to_string(r.gapsIn.value().left)) :
+                                                          std::format("\tgapsIn: <unset>\n");
+        const std::string gapsOut    = (bool)(r.gapsOut) ? std::format("\tgapsOut: {} {} {} {}\n", std::to_string(r.gapsOut.value().top), std::to_string(r.gapsOut.value().right),
+                                                                       std::to_string(r.gapsOut.value().bottom), std::to_string(r.gapsOut.value().left)) :
+                                                           std::format("\tgapsOut: <unset>\n");
         const std::string borderSize = std::format("\tborderSize: {}\n", (bool)(r.borderSize) ? std::to_string(r.borderSize.value()) : "<unset>");
         const std::string border     = std::format("\tborder: {}\n", (bool)(r.border) ? boolToString(r.border.value()) : "<unset>");
         const std::string rounding   = std::format("\trounding: {}\n", (bool)(r.rounding) ? boolToString(r.rounding.value()) : "<unset>");
@@ -286,9 +324,9 @@ std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::string requ
         return "unsafe state";
 
     std::string result = "";
-    auto        w      = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+    auto        w      = g_pCompositor->m_pLastMonitor->activeWorkspace;
 
-    if (!w)
+    if (!valid(w))
         return "internal error";
 
     return getWorkspaceData(w, format);
@@ -300,7 +338,7 @@ std::string workspacesRequest(eHyprCtlOutputFormat format, std::string request)
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
         for (auto& w : g_pCompositor->m_vWorkspaces) {
-            result += getWorkspaceData(w.get(), format);
+            result += getWorkspaceData(w, format);
             result += ",";
         }
 
@@ -308,7 +346,7 @@ std::string workspacesRequest(eHyprCtlOutputFormat format, std::string request)
         result += "]";
     } else {
         for (auto& w : g_pCompositor->m_vWorkspaces) {
-            result += getWorkspaceData(w.get(), format);
+            result += getWorkspaceData(w, format);
         }
     }
 
@@ -445,6 +483,29 @@ std::string layoutsRequest(eHyprCtlOutputFormat format, std::string request) {
     return result;
 }
 
+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 (auto line : errLines) {
+            result += std::format(
+                R"#(
+	"{}",)#",
+
+                escapeJSONStrings(line));
+        }
+        trimTrailingComma(result);
+        result += "\n]\n";
+    } else {
+        for (auto line : errLines) {
+            result += std::format("{}\n", line);
+        }
+    }
+    return result;
+}
+
 std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
     std::string result = "";
 
@@ -581,7 +642,7 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
         }
 
         for (auto& d : g_pInputManager->m_lTablets) {
-            result += std::format("\tTablet at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.name);
+            result += std::format("\tTablet at {:x}:\n\t\t{}\n\t\t\tsize: {}x{}mm\n", (uintptr_t)&d, d.name, d.wlrTablet->width_mm, d.wlrTablet->height_mm);
         }
 
         for (auto& d : g_pInputManager->m_lTabletTools) {
@@ -710,8 +771,8 @@ std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
             if (kb.nonConsuming)
                 ret += "n";
 
-            ret += std::format("\n\tmodmask: {}\n\tsubmap: {}\n\tkey: {}\n\tkeycode: {}\n\tdispatcher: {}\n\targ: {}\n\n", kb.modmask, kb.submap, kb.key, kb.keycode, kb.handler,
-                               kb.arg);
+            ret += std::format("\n\tmodmask: {}\n\tsubmap: {}\n\tkey: {}\n\tkeycode: {}\n\tcatchall: {}\n\tdispatcher: {}\n\targ: {}\n\n", kb.modmask, kb.submap, kb.key,
+                               kb.keycode, kb.catchAll, kb.handler, kb.arg);
         }
     } else {
         // json
@@ -729,11 +790,13 @@ std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
     "submap": "{}",
     "key": "{}",
     "keycode": {},
+    "catch_all": {},
     "dispatcher": "{}",
     "arg": "{}"
 }},)#",
                 kb.locked ? "true" : "false", kb.mouse ? "true" : "false", kb.release ? "true" : "false", kb.repeat ? "true" : "false", kb.nonConsuming ? "true" : "false",
-                kb.modmask, escapeJSONStrings(kb.submap), escapeJSONStrings(kb.key), kb.keycode, escapeJSONStrings(kb.handler), escapeJSONStrings(kb.arg));
+                kb.modmask, escapeJSONStrings(kb.submap), escapeJSONStrings(kb.key), kb.keycode, kb.catchAll ? "true" : "false", escapeJSONStrings(kb.handler),
+                escapeJSONStrings(kb.arg));
         }
         trimTrailingComma(ret);
         ret += "]";
@@ -749,7 +812,7 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
 
     if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
         std::string result = "Hyprland, built from branch " + std::string(GIT_BRANCH) + " at commit " + GIT_COMMIT_HASH + " " + GIT_DIRTY + " (" + commitMsg +
-            ").\nDate: " + GIT_COMMIT_DATE + "\nTag: " + GIT_TAG + "\n\nflags: (if any)\n";
+            ").\nDate: " + GIT_COMMIT_DATE + "\nTag: " + GIT_TAG + ", commits: " + GIT_COMMITS + "\n\nflags: (if any)\n";
 
 #ifdef LEGACY_RENDERER
         result += "legacyrenderer\n";
@@ -771,8 +834,9 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
     "commit_message": "{}",
     "commit_date": "{}",
     "tag": "{}",
+    "commits": {},
     "flags": [)#",
-            GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg), GIT_COMMIT_DATE, GIT_TAG);
+            GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg), GIT_COMMIT_DATE, GIT_TAG, GIT_COMMITS);
 
 #ifdef LEGACY_RENDERER
         result += "\"legacyrenderer\",";
@@ -856,32 +920,35 @@ std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in) {
 
     const auto  VALUE = in.substr(in.find_first_of(' ') + 1);
 
-    std::string retval = g_pConfigManager->parseKeyword(COMMAND, VALUE, true);
+    std::string retval = g_pConfigManager->parseKeyword(COMMAND, VALUE);
 
-    if (COMMAND == "monitor")
+    // if we are executing a dynamic source we have to reload everything, so every if will have a check for source.
+    if (COMMAND == "monitor" || COMMAND == "source")
         g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
 
-    if (COMMAND.contains("input") || COMMAND.contains("device:")) {
+    if (COMMAND.contains("input") || COMMAND.contains("device") || COMMAND == "source") {
         g_pInputManager->setKeyboardLayout();     // update kb layout
         g_pInputManager->setPointerConfigs();     // update mouse cfgs
         g_pInputManager->setTouchDeviceConfigs(); // update touch device cfgs
         g_pInputManager->setTabletConfigs();      // update tablets
     }
 
-    if (COMMAND.contains("general:layout"))
-        g_pLayoutManager->switchToLayout(g_pConfigManager->getString("general:layout")); // update layout
+    static auto PLAYOUT = CConfigValue<std::string>("general:layout");
 
-    if (COMMAND.contains("decoration:screen_shader"))
+    if (COMMAND.contains("general:layout"))
+        g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
+
+    if (COMMAND.contains("decoration:screen_shader") || COMMAND == "source")
         g_pHyprOpenGL->m_bReloadScreenShader = true;
 
-    if (COMMAND.contains("blur")) {
+    if (COMMAND.contains("blur") || COMMAND == "source") {
         for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
             rd.blurFBDirty = true;
         }
     }
 
     // decorations will probably need a repaint
-    if (COMMAND.contains("decoration:") || COMMAND.contains("border") || COMMAND == "workspace" || COMMAND.contains("cursor_zoom_factor")) {
+    if (COMMAND.contains("decoration:") || COMMAND.contains("border") || COMMAND == "workspace" || COMMAND.contains("cursor_zoom_factor") || COMMAND == "source") {
         for (auto& m : g_pCompositor->m_vMonitors) {
             g_pHyprRenderer->damageMonitor(m.get());
             g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
@@ -962,7 +1029,7 @@ std::string dispatchBatch(eHyprCtlOutputFormat format, std::string request) {
 
     nextItem();
 
-    while (curitem != "") {
+    while (curitem != "" || request != "") {
         reply += g_pHyprCtl->getReply(curitem);
 
         nextItem();
@@ -989,16 +1056,7 @@ std::string dispatchSetCursor(eHyprCtlOutputFormat format, std::string request)
     if (size <= 0)
         return "size not positive";
 
-    wlr_xcursor_manager_destroy(g_pCompositor->m_sWLRXCursorMgr);
-
-    g_pCompositor->m_sWLRXCursorMgr = wlr_xcursor_manager_create(theme.c_str(), size);
-
-    setenv("XCURSOR_SIZE", SIZESTR.c_str(), true);
-    setenv("XCURSOR_THEME", theme.c_str(), true);
-
-    for (auto& m : g_pCompositor->m_vMonitors) {
-        wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, m->scale);
-    }
+    g_pCursorManager->changeTheme(theme, size);
 
     return "ok";
 }
@@ -1084,6 +1142,7 @@ std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
     if (vars.size() < 4)
         return "not enough args";
 
+    const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
     const auto PWINDOW     = g_pCompositor->getWindowByRegex(vars[1]);
 
     if (!PWINDOW)
@@ -1092,13 +1151,12 @@ std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
     const auto PROP = vars[2];
     const auto VAL  = vars[3];
 
+    auto       noFocus = PWINDOW->m_sAdditionalConfigData.noFocus;
+
     bool       lock = false;
 
-    if (vars.size() > 4) {
-        if (vars[4].starts_with("lock")) {
+    if (request.ends_with("lock"))
         lock = true;
-        }
-    }
 
     try {
         if (PROP == "animationstyle") {
@@ -1121,10 +1179,28 @@ std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
             PWINDOW->m_sAdditionalConfigData.forceNoShadow.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "forcenodim") {
             PWINDOW->m_sAdditionalConfigData.forceNoDim.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "nofocus") {
+            PWINDOW->m_sAdditionalConfigData.noFocus.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "windowdancecompat") {
             PWINDOW->m_sAdditionalConfigData.windowDanceCompat.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "nomaxsize") {
             PWINDOW->m_sAdditionalConfigData.noMaxSize.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "maxsize") {
+            PWINDOW->m_sAdditionalConfigData.maxSize.forceSetIgnoreLocked(configStringToVector2D(VAL + " " + vars[4]), lock);
+            if (lock) {
+                PWINDOW->m_vRealSize = Vector2D(std::min((double)PWINDOW->m_sAdditionalConfigData.maxSize.toUnderlying().x, PWINDOW->m_vRealSize.goal().x),
+                                                std::min((double)PWINDOW->m_sAdditionalConfigData.maxSize.toUnderlying().y, PWINDOW->m_vRealSize.goal().y));
+                g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal());
+                PWINDOW->setHidden(false);
+            }
+        } else if (PROP == "minsize") {
+            PWINDOW->m_sAdditionalConfigData.minSize.forceSetIgnoreLocked(configStringToVector2D(VAL + " " + vars[4]), lock);
+            if (lock) {
+                PWINDOW->m_vRealSize = Vector2D(std::max((double)PWINDOW->m_sAdditionalConfigData.minSize.toUnderlying().x, PWINDOW->m_vRealSize.goal().x),
+                                                std::max((double)PWINDOW->m_sAdditionalConfigData.minSize.toUnderlying().y, PWINDOW->m_vRealSize.goal().y));
+                g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal());
+                PWINDOW->setHidden(false);
+            }
         } else if (PROP == "dimaround") {
             PWINDOW->m_sAdditionalConfigData.dimAround.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "alphaoverride") {
@@ -1135,10 +1211,27 @@ std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
             PWINDOW->m_sSpecialRenderData.alphaInactiveOverride.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "alphainactive") {
             PWINDOW->m_sSpecialRenderData.alphaInactive.forceSetIgnoreLocked(std::stof(VAL), lock);
-        } else if (PROP == "activebordercolor") {
-            PWINDOW->m_sSpecialRenderData.activeBorderColor.forceSetIgnoreLocked(CGradientValueData(CColor(configStringToInt(VAL))), lock);
-        } else if (PROP == "inactivebordercolor") {
-            PWINDOW->m_sSpecialRenderData.inactiveBorderColor.forceSetIgnoreLocked(CGradientValueData(CColor(configStringToInt(VAL))), lock);
+        } else if (PROP == "alphafullscreenoverride") {
+            PWINDOW->m_sSpecialRenderData.alphaFullscreenOverride.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "alphafullscreen") {
+            PWINDOW->m_sSpecialRenderData.alphaFullscreen.forceSetIgnoreLocked(std::stof(VAL), lock);
+        } else if (PROP == "activebordercolor" || PROP == "inactivebordercolor") {
+            CGradientValueData colorData = {};
+            if (vars.size() > 4) {
+                for (int i = 3; i < static_cast<int>(lock ? vars.size() - 1 : vars.size()); ++i) {
+                    const auto TOKEN = vars[i];
+                    if (TOKEN.ends_with("deg"))
+                        colorData.m_fAngle = std::stoi(TOKEN.substr(0, TOKEN.size() - 3)) * (PI / 180.0);
+                    else
+                        colorData.m_vColors.push_back(configStringToInt(TOKEN));
+                }
+            } else if (VAL != "-1")
+                colorData.m_vColors.push_back(configStringToInt(VAL));
+
+            if (PROP == "activebordercolor")
+                PWINDOW->m_sSpecialRenderData.activeBorderColor.forceSetIgnoreLocked(colorData, lock);
+            else
+                PWINDOW->m_sSpecialRenderData.inactiveBorderColor.forceSetIgnoreLocked(colorData, lock);
         } else if (PROP == "forcergbx") {
             PWINDOW->m_sAdditionalConfigData.forceRGBX.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "bordersize") {
@@ -1156,6 +1249,12 @@ std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
 
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
+    if (!(PWINDOW->m_sAdditionalConfigData.noFocus.toUnderlying() == noFocus.toUnderlying())) {
+        g_pCompositor->focusWindow(nullptr);
+        g_pCompositor->focusWindow(PWINDOW);
+        g_pCompositor->focusWindow(PLASTWINDOW);
+    }
+
     for (auto& m : g_pCompositor->m_vMonitors)
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
 
@@ -1182,28 +1281,41 @@ std::string dispatchGetOption(eHyprCtlOutputFormat format, std::string request)
     nextItem();
     nextItem();
 
-    const auto PCFGOPT = g_pConfigManager->getConfigValuePtrSafe(curitem);
+    const auto VAR = g_pConfigManager->getHyprlangConfigValuePtr(curitem);
 
-    if (!PCFGOPT)
+    if (!VAR)
         return "no such option";
 
-    if (format == eHyprCtlOutputFormat::FORMAT_NORMAL)
-        return std::format("option {}\n\tint: {}\n\tfloat: {:.5f}\n\tstr: \"{}\"\n\tdata: {:x}\n\tset: {}", curitem, PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue,
-                           (uintptr_t)PCFGOPT->data.get(), PCFGOPT->set);
-    else {
-        return std::format(
-            R"#(
-{{
-    "option": "{}",
-    "int": {},
-    "float": {:.5f},
-    "str": "{}",
-    "data": "0x{:x}",
-    "set": {}
-}}
-)#",
-            curitem, PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue, (uintptr_t)PCFGOPT->data.get(), PCFGOPT->set);
+    const auto VAL  = VAR->getValue();
+    const auto TYPE = std::type_index(VAL.type());
+
+    if (format == FORMAT_NORMAL) {
+        if (TYPE == typeid(Hyprlang::INT))
+            return std::format("int: {}\nset: {}", std::any_cast<Hyprlang::INT>(VAL), VAR->m_bSetByUser);
+        else if (TYPE == typeid(Hyprlang::FLOAT))
+            return std::format("float: {:2f}\nset: {}", std::any_cast<Hyprlang::FLOAT>(VAL), VAR->m_bSetByUser);
+        else if (TYPE == typeid(Hyprlang::VEC2))
+            return std::format("vec2: [{}, {}]\nset: {}", 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("str: {}\nset: {}", std::any_cast<Hyprlang::STRING>(VAL), VAR->m_bSetByUser);
+        else if (TYPE == typeid(void*))
+            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("{{\"option\": \"{}\", \"int\": {}, \"set\": {} }}", curitem, std::any_cast<Hyprlang::INT>(VAL), VAR->m_bSetByUser);
+        else if (TYPE == typeid(Hyprlang::FLOAT))
+            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("{{\"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("{{\"option\": \"{}\", \"str\": \"{}\", \"set\": {} }}", curitem, escapeJSONStrings(std::any_cast<Hyprlang::STRING>(VAL)), VAR->m_bSetByUser);
+        else if (TYPE == typeid(void*))
+            return std::format("{{\"option\": \"{}\", \"custom\": \"{}\", \"set\": {} }}", curitem, ((ICustomConfigValueData*)std::any_cast<void*>(VAL))->toString(),
+                               VAR->m_bSetByUser);
     }
+
+    return "invalid type (internal error)";
 }
 
 std::string decorationRequest(eHyprCtlOutputFormat format, std::string request) {
@@ -1342,6 +1454,9 @@ std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string request) {
     } else if (OPERATION == "list") {
         const auto PLUGINS = g_pPluginSystem->getAllPlugins();
 
+        if (PLUGINS.size() == 0)
+            return "no plugins loaded";
+
         std::string list = "";
         for (auto& 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);
@@ -1383,15 +1498,47 @@ std::string dispatchNotify(eHyprCtlOutputFormat format, std::string request) {
 
     CColor color = configStringToInt(vars[3]);
 
-    std::string message = "";
+    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);
 
-    for (size_t i = 4; i < vars.size(); ++i) {
-        message += vars[i] + " ";
+        if (!isNumber(FONTSIZE, true))
+            return "invalid fontsize kwarg";
+
+        try {
+            fontsize = std::stoi(FONTSIZE);
+        } catch (std::exception& e) { return "invalid fontsize karg"; }
+
+        ++msgidx;
     }
 
-    message.pop_back();
+    if (vars.size() <= msgidx)
+        return "not enough args";
 
-    g_pHyprNotificationOverlay->addNotification(message, color, time, (eIcons)icon);
+    const auto MESSAGE = vars.join(" ", msgidx);
+
+    g_pHyprNotificationOverlay->addNotification(MESSAGE, color, time, (eIcons)icon, fontsize);
+
+    return "ok";
+}
+
+std::string dispatchDismissNotify(eHyprCtlOutputFormat format, std::string request) {
+    CVarList vars(request, 0, ' ');
+
+    int      amount = -1;
+
+    if (vars.size() > 1) {
+        const auto AMOUNT = vars[1];
+        if (!isNumber(AMOUNT))
+            return "invalid arg 1";
+
+        try {
+            amount = std::stoi(AMOUNT);
+        } catch (std::exception& e) { return "invalid arg 1"; }
+    }
+
+    g_pHyprNotificationOverlay->dismissNotifications(amount);
 
     return "ok";
 }
@@ -1414,11 +1561,13 @@ CHyprCtl::CHyprCtl() {
     registerCommand(SHyprCtlCommand{"animations", true, animationsRequest});
     registerCommand(SHyprCtlCommand{"rollinglog", true, rollinglogRequest});
     registerCommand(SHyprCtlCommand{"layouts", true, layoutsRequest});
+    registerCommand(SHyprCtlCommand{"configerrors", true, configErrorsRequest});
 
     registerCommand(SHyprCtlCommand{"monitors", false, monitorsRequest});
     registerCommand(SHyprCtlCommand{"reload", false, reloadRequest});
     registerCommand(SHyprCtlCommand{"plugin", false, dispatchPlugin});
     registerCommand(SHyprCtlCommand{"notify", false, dispatchNotify});
+    registerCommand(SHyprCtlCommand{"dismissnotify", false, dispatchDismissNotify});
     registerCommand(SHyprCtlCommand{"setprop", false, dispatchSetProp});
     registerCommand(SHyprCtlCommand{"seterror", false, dispatchSeterror});
     registerCommand(SHyprCtlCommand{"switchxkblayout", false, switchXKBLayoutRequest});
@@ -1443,6 +1592,8 @@ void CHyprCtl::unregisterCommand(const std::shared_ptr<SHyprCtlCommand>& cmd) {
 
 std::string CHyprCtl::getReply(std::string request) {
     auto format             = eHyprCtlOutputFormat::FORMAT_NORMAL;
+    bool reloadAll          = false;
+    m_sCurrentRequestParams = {};
 
     // process flags for non-batch requests
     if (!request.starts_with("[[BATCH]]") && request.contains("/")) {
@@ -1463,30 +1614,68 @@ std::string CHyprCtl::getReply(std::string request) {
 
             if (c == 'j')
                 format = eHyprCtlOutputFormat::FORMAT_JSON;
+            else if (c == 'r')
+                reloadAll = true;
+            else if (c == 'a')
+                m_sCurrentRequestParams.all = true;
         }
 
         if (sepIndex < request.size())
             request = request.substr(sepIndex + 1); // remove flags and separator so we can compare the rest of the string
     }
 
+    std::string result = "";
+
     // parse exact cmds first, then non-exact.
     for (auto& cmd : m_vCommands) {
         if (!cmd->exact)
             continue;
 
-        if (cmd->name == request)
-            return cmd->fn(format, request);
+        if (cmd->name == request) {
+            result = cmd->fn(format, request);
+            break;
+        }
     }
 
+    if (result.empty())
         for (auto& cmd : m_vCommands) {
             if (cmd->exact)
                 continue;
 
-        if (request.starts_with(cmd->name))
-            return cmd->fn(format, request);
+            if (request.starts_with(cmd->name)) {
+                result = cmd->fn(format, request);
+                break;
+            }
         }
 
+    if (result.empty())
         return "unknown request";
+
+    if (reloadAll) {
+        g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
+
+        g_pInputManager->setKeyboardLayout();     // update kb layout
+        g_pInputManager->setPointerConfigs();     // update mouse cfgs
+        g_pInputManager->setTouchDeviceConfigs(); // update touch device cfgs
+        g_pInputManager->setTabletConfigs();      // update tablets
+
+        static auto PLAYOUT = CConfigValue<std::string>("general:layout");
+
+        g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
+
+        g_pHyprOpenGL->m_bReloadScreenShader = true;
+
+        for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
+            rd.blurFBDirty = true;
+        }
+
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            g_pHyprRenderer->damageMonitor(m.get());
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+        }
+    }
+
+    return result;
 }
 
 std::string CHyprCtl::makeDynamicCall(const std::string& input) {

src/debug/HyprCtl.hpp

@@ -16,6 +16,10 @@ class CHyprCtl {
 
     int                              m_iSocketFD = -1;
 
+    struct {
+        bool all = false;
+    } m_sCurrentRequestParams;
+
   private:
     void                                          startHyprCtlSocket();
 

src/debug/HyprNotificationOverlay.cpp

@@ -36,7 +36,7 @@ CHyprNotificationOverlay::CHyprNotificationOverlay() {
     m_szIconFontName = fonts.substr(COLON + 2, LASTCHAR - (COLON + 2));
 }
 
-void CHyprNotificationOverlay::addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon) {
+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  = text;
@@ -44,12 +44,25 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CC
     PNOTIF->started.reset();
     PNOTIF->timeMs   = timeMs;
     PNOTIF->icon     = icon;
+    PNOTIF->fontSize = fontSize;
 
     for (auto& m : g_pCompositor->m_vMonitors) {
         g_pCompositor->scheduleFrameForMonitor(m.get());
     }
 }
 
+void CHyprNotificationOverlay::dismissNotifications(const int amount) {
+    if (amount == -1)
+        m_dNotifications.clear();
+    else {
+        const int AMT = std::min(amount, static_cast<int>(m_dNotifications.size()));
+
+        for (int i = 0; i < AMT; ++i) {
+            m_dNotifications.pop_front();
+        }
+    }
+}
+
 CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
     static constexpr auto ANIM_DURATION_MS   = 600.0;
     static constexpr auto ANIM_LAG_MS        = 100.0;
@@ -62,27 +75,24 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
     float                 maxWidth = 0;
 
     const auto            SCALE = pMonitor->scale;
-    const auto            FONTSIZE = std::clamp((int)(13.f * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
 
     const auto            MONSIZE = pMonitor->vecPixelSize;
 
     cairo_text_extents_t  cairoExtents;
     int                   iconW = 0, iconH = 0;
 
-    PangoLayout*          pangoLayout;
-    PangoFontDescription* pangoFD;
-
-    pangoLayout = pango_cairo_create_layout(m_pCairo);
-    pangoFD     = pango_font_description_from_string(("Sans " + std::to_string(FONTSIZE * ICON_SCALE)).c_str());
-    pango_layout_set_font_description(pangoLayout, pangoFD);
-
     cairo_select_font_face(m_pCairo, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
-    cairo_set_font_size(m_pCairo, FONTSIZE);
 
     const auto PBEZIER = g_pAnimationManager->getBezier("default");
 
     for (auto& 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);
+
+        PangoLayout*          pangoLayout = pango_cairo_create_layout(m_pCairo);
+        PangoFontDescription* pangoFD     = pango_font_description_from_string(("Sans " + std::to_string(FONTSIZE * ICON_SCALE)).c_str());
+        pango_layout_set_font_description(pangoLayout, pangoFD);
+        cairo_set_font_size(m_pCairo, FONTSIZE);
 
         // first rect (bg, col)
         const float FIRSTRECTANIMP =
@@ -162,10 +172,10 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
 
         if (maxWidth < NOTIFSIZE.x)
             maxWidth = NOTIFSIZE.x;
-    }
 
         pango_font_description_free(pangoFD);
         g_object_unref(pangoLayout);
+    }
 
     // cleanup notifs
     std::erase_if(m_dNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
@@ -227,3 +237,7 @@ void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
     CBox pMonBox = {0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y};
     g_pHyprOpenGL->renderTexture(m_tTexture, &pMonBox, 1.f);
 }
+
+bool CHyprNotificationOverlay::hasAny() {
+    return !m_dNotifications.empty();
+}

src/debug/HyprNotificationOverlay.hpp

@@ -33,6 +33,7 @@ struct SNotification {
     CTimer      started;
     float       timeMs   = 0;
     eIcons      icon     = ICON_NONE;
+    float       fontSize = 13.f;
 };
 
 class CHyprNotificationOverlay {
@@ -40,7 +41,9 @@ class CHyprNotificationOverlay {
     CHyprNotificationOverlay();
 
     void draw(CMonitor* pMonitor);
-    void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE);
+    void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
+    void dismissNotifications(const int amount);
+    bool hasAny();
 
   private:
     CBox                                       drawNotifications(CMonitor* pMonitor);

src/debug/Log.cpp

@@ -22,7 +22,7 @@ void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
 
     rollingLog += output + "\n";
 
-    if (!disableLogs || !*disableLogs) {
+    if (!disableLogs || !**disableLogs) {
         std::ofstream ofs;
         ofs.open(logFile, std::ios::out | std::ios::app);
         ofs << "[wlr] " << output << "\n";

src/debug/Log.hpp

@@ -22,8 +22,8 @@ enum LogLevel {
 
 namespace Debug {
     inline std::string     logFile;
-    inline int64_t*    disableLogs   = nullptr;
-    inline int64_t*    disableTime   = nullptr;
+    inline int64_t* const* disableLogs   = nullptr;
+    inline int64_t* const* disableTime   = nullptr;
     inline bool            disableStdout = false;
     inline bool            trace         = false;
     inline bool            shuttingDown  = false;
@@ -52,7 +52,7 @@ namespace Debug {
         }
 
         // print date and time to the ofs
-        if (disableTime && !*disableTime) {
+        if (disableTime && !**disableTime) {
 #ifndef _LIBCPP_VERSION
             logMsg += std::format("[{:%T}] ", std::chrono::hh_mm_ss{std::chrono::system_clock::now() - std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())});
 #else
@@ -73,7 +73,7 @@ namespace Debug {
         if (rollingLog.size() > ROLLING_LOG_SIZE)
             rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);
 
-        if (!disableLogs || !*disableLogs) {
+        if (!disableLogs || !**disableLogs) {
             // log to a file
             std::ofstream ofs;
             ofs.open(logFile, std::ios::out | std::ios::app);

src/desktop/Constraint.cpp

@@ -0,0 +1,131 @@
+#include "Constraint.hpp"
+#include "WLSurface.hpp"
+#include "../Compositor.hpp"
+
+CConstraint::CConstraint(wlr_pointer_constraint_v1* constraint, CWLSurface* owner) : m_pOwner(owner), m_pConstraint(constraint) {
+    RASSERT(!constraint->data, "CConstraint: attempted to duplicate ownership");
+
+    constraint->data = this;
+    initSignals();
+
+    m_vCursorPosOnActivate = g_pInputManager->getMouseCoordsInternal();
+
+    g_pInputManager->m_vConstraints.push_back(this);
+
+    if (g_pCompositor->m_pLastFocus == m_pOwner->wlr())
+        activate();
+}
+
+CConstraint::~CConstraint() {
+    std::erase(g_pInputManager->m_vConstraints, this);
+}
+
+static void onConstraintDestroy(void* owner, void* data) {
+    const auto CONSTRAINT = (CConstraint*)owner;
+    CONSTRAINT->onDestroy();
+}
+
+static void onConstraintSetRegion(void* owner, void* data) {
+    const auto CONSTRAINT = (CConstraint*)owner;
+    CONSTRAINT->onSetRegion();
+}
+
+void CConstraint::initSignals() {
+    hyprListener_setConstraintRegion.initCallback(&m_pConstraint->events.set_region, ::onConstraintSetRegion, this, "CConstraint");
+    hyprListener_destroyConstraint.initCallback(&m_pConstraint->events.destroy, ::onConstraintDestroy, this, "CConstraint");
+}
+
+void CConstraint::onDestroy() {
+    hyprListener_setConstraintRegion.removeCallback();
+    hyprListener_destroyConstraint.removeCallback();
+
+    if (active() && isLocked())
+        g_pCompositor->warpCursorTo(logicPositionHint(), true);
+
+    // this is us
+    m_pOwner->m_pConstraint.reset();
+}
+
+void CConstraint::onSetRegion() {
+    if (!m_bActive)
+        return;
+
+    m_rRegion.set(&m_pConstraint->region);
+    m_vPositionHint = m_rRegion.closestPoint(m_vPositionHint);
+    g_pInputManager->simulateMouseMovement(); // to warp the cursor if anything's amiss
+}
+
+void CConstraint::onCommit() {
+    if (!m_bActive)
+        return;
+
+    const auto COMMITTED = m_pConstraint->current.committed;
+
+    if (COMMITTED & WLR_POINTER_CONSTRAINT_V1_STATE_CURSOR_HINT) {
+        m_bHintSet      = true;
+        m_vPositionHint = {m_pConstraint->current.cursor_hint.x, m_pConstraint->current.cursor_hint.y};
+        g_pInputManager->simulateMouseMovement();
+    }
+
+    if (COMMITTED & WLR_POINTER_CONSTRAINT_V1_STATE_REGION)
+        onSetRegion();
+}
+
+CRegion CConstraint::logicConstraintRegion() {
+    CRegion    rg            = m_rRegion;
+    const auto SURFBOX       = m_pOwner->getSurfaceBoxGlobal();
+    const auto CONSTRAINTPOS = SURFBOX.has_value() ? SURFBOX->pos() : Vector2D{};
+    rg.translate(CONSTRAINTPOS);
+    return rg;
+}
+
+CWLSurface* CConstraint::owner() {
+    return m_pOwner;
+}
+
+bool CConstraint::isLocked() {
+    return m_pConstraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED;
+}
+
+Vector2D CConstraint::logicPositionHint() {
+    const auto SURFBOX       = m_pOwner->getSurfaceBoxGlobal();
+    const auto CONSTRAINTPOS = SURFBOX.has_value() ? SURFBOX->pos() : Vector2D{};
+
+    return m_bHintSet ? CONSTRAINTPOS + m_vPositionHint : m_vCursorPosOnActivate;
+}
+
+void CConstraint::deactivate() {
+    if (!m_bActive)
+        return;
+
+    m_bActive = false;
+
+    if (isLocked())
+        g_pCompositor->warpCursorTo(logicPositionHint(), true);
+
+    if (m_pConstraint->lifetime == ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT)
+        m_bDead = true;
+
+    wlr_pointer_constraint_v1_send_deactivated(m_pConstraint);
+}
+
+void CConstraint::activate() {
+    if (m_bActive || m_bDead)
+        return;
+
+    m_bActive = true;
+
+    // TODO: hack, probably not a super duper great idea
+    if (g_pCompositor->m_sSeat.seat->pointer_state.focused_surface != m_pOwner->wlr()) {
+        const auto SURFBOX = m_pOwner->getSurfaceBoxGlobal();
+        const auto LOCAL   = SURFBOX.has_value() ? logicPositionHint() - SURFBOX->pos() : Vector2D{};
+        wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, m_pOwner->wlr(), LOCAL.x, LOCAL.y);
+    }
+
+    g_pCompositor->warpCursorTo(logicPositionHint(), true);
+    wlr_pointer_constraint_v1_send_activated(m_pConstraint);
+}
+
+bool CConstraint::active() {
+    return m_bActive;
+}

src/desktop/Constraint.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "../includes.hpp"
+#include "../helpers/Region.hpp"
+#include "../helpers/WLListener.hpp"
+
+class CWLSurface;
+
+class CConstraint {
+  public:
+    CConstraint(wlr_pointer_constraint_v1* constraint, CWLSurface* owner);
+    ~CConstraint();
+
+    void        onCommit();
+    void        onDestroy();
+    void        onSetRegion();
+    CRegion     logicConstraintRegion();
+    bool        isLocked();
+    Vector2D    logicPositionHint();
+
+    void        deactivate();
+    void        activate();
+    bool        active();
+
+    CWLSurface* owner();
+
+  private:
+    bool                       m_bActive = false;
+    CWLSurface*                m_pOwner  = nullptr;
+    wlr_pointer_constraint_v1* m_pConstraint;
+
+    CRegion                    m_rRegion;
+    bool                       m_bHintSet             = false;
+    Vector2D                   m_vPositionHint        = {-1, -1};
+    Vector2D                   m_vCursorPosOnActivate = {-1, -1};
+
+    // for oneshot constraints that have been activated once
+    bool m_bDead = false;
+
+    DYNLISTENER(destroyConstraint);
+    DYNLISTENER(setConstraintRegion);
+
+    void initSignals();
+};

src/desktop/DesktopTypes.hpp

@@ -0,0 +1,6 @@
+#pragma once
+#include <memory>
+
+class CWorkspace;
+
+typedef std::shared_ptr<CWorkspace> PHLWORKSPACE;

src/desktop/Popup.cpp

@@ -0,0 +1,269 @@
+#include "Popup.hpp"
+#include "../config/ConfigValue.hpp"
+#include "../Compositor.hpp"
+
+CPopup::CPopup(CWindow* pOwner) : m_pWindowOwner(pOwner) {
+    initAllSignals();
+}
+
+CPopup::CPopup(SLayerSurface* pOwner) : m_pLayerOwner(pOwner) {
+    initAllSignals();
+}
+
+CPopup::CPopup(wlr_xdg_popup* popup, CPopup* pOwner) : m_pParent(pOwner), m_pWLR(popup) {
+    m_pWLR->base->data = this;
+    m_sWLSurface.assign(popup->base->surface, this);
+
+    m_pLayerOwner  = pOwner->m_pLayerOwner;
+    m_pWindowOwner = pOwner->m_pWindowOwner;
+
+    m_vLastSize = {m_pWLR->current.geometry.width, m_pWLR->current.geometry.height};
+    unconstrain();
+
+    initAllSignals();
+}
+
+CPopup::~CPopup() {
+    m_sWLSurface.unassign();
+    if (m_pWLR)
+        m_pWLR->base->data = nullptr;
+
+    hyprListener_commitPopup.removeCallback();
+    hyprListener_repositionPopup.removeCallback();
+    hyprListener_mapPopup.removeCallback();
+    hyprListener_unmapPopup.removeCallback();
+    hyprListener_newPopup.removeCallback();
+    hyprListener_destroyPopup.removeCallback();
+}
+
+static void onNewPopup(void* owner, void* data) {
+    const auto POPUP = (CPopup*)owner;
+    POPUP->onNewPopup((wlr_xdg_popup*)data);
+}
+
+static void onMapPopup(void* owner, void* data) {
+    const auto POPUP = (CPopup*)owner;
+    POPUP->onMap();
+}
+
+static void onDestroyPopup(void* owner, void* data) {
+    const auto POPUP = (CPopup*)owner;
+    POPUP->onDestroy();
+}
+
+static void onUnmapPopup(void* owner, void* data) {
+    const auto POPUP = (CPopup*)owner;
+    POPUP->onUnmap();
+}
+
+static void onCommitPopup(void* owner, void* data) {
+    const auto POPUP = (CPopup*)owner;
+    POPUP->onCommit();
+}
+
+static void onRepositionPopup(void* owner, void* data) {
+    const auto POPUP = (CPopup*)owner;
+    POPUP->onReposition();
+}
+
+void CPopup::initAllSignals() {
+
+    if (!m_pWLR) {
+        if (m_pWindowOwner)
+            hyprListener_newPopup.initCallback(&m_pWindowOwner->m_uSurface.xdg->events.new_popup, ::onNewPopup, this, "CPopup Head");
+        else if (m_pLayerOwner)
+            hyprListener_newPopup.initCallback(&m_pLayerOwner->layerSurface->events.new_popup, ::onNewPopup, this, "CPopup Head");
+        else
+            ASSERT(false);
+
+        return;
+    }
+
+    hyprListener_repositionPopup.initCallback(&m_pWLR->events.reposition, ::onRepositionPopup, this, "CPopup");
+    hyprListener_destroyPopup.initCallback(&m_pWLR->events.destroy, ::onDestroyPopup, this, "CPopup");
+    hyprListener_mapPopup.initCallback(&m_sWLSurface.wlr()->events.map, ::onMapPopup, this, "CPopup");
+    hyprListener_unmapPopup.initCallback(&m_sWLSurface.wlr()->events.unmap, ::onUnmapPopup, this, "CPopup");
+    hyprListener_commitPopup.initCallback(&m_sWLSurface.wlr()->events.commit, ::onCommitPopup, this, "CPopup");
+    hyprListener_newPopup.initCallback(&m_pWLR->base->events.new_popup, ::onNewPopup, this, "CPopup");
+}
+
+void CPopup::onNewPopup(wlr_xdg_popup* popup) {
+    const auto POPUP = m_vChildren.emplace_back(std::make_unique<CPopup>(popup, this)).get();
+    Debug::log(LOG, "New popup at wlr {:x} and hl {:x}", (uintptr_t)popup, (uintptr_t)POPUP);
+}
+
+void CPopup::onDestroy() {
+    m_bInert = true;
+
+    if (!m_pParent)
+        return; // head node
+
+    std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; });
+}
+
+void CPopup::onMap() {
+    m_vLastSize       = {m_pWLR->base->current.geometry.width, m_pWLR->base->current.geometry.height};
+    const auto COORDS = coordsGlobal();
+
+    CBox       box;
+    wlr_surface_get_extends(m_sWLSurface.wlr(), box.pWlr());
+    box.applyFromWlr().translate(COORDS).expand(4);
+    g_pHyprRenderer->damageBox(&box);
+
+    m_vLastPos = coordsRelativeToParent();
+
+    g_pInputManager->simulateMouseMovement();
+
+    m_pSubsurfaceHead = std::make_unique<CSubsurface>(this);
+
+    unconstrain();
+    sendScale();
+
+    if (m_pLayerOwner && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
+}
+
+void CPopup::onUnmap() {
+    m_vLastSize       = {m_pWLR->base->current.geometry.width, m_pWLR->base->current.geometry.height};
+    const auto COORDS = coordsGlobal();
+
+    CBox       box;
+    wlr_surface_get_extends(m_sWLSurface.wlr(), box.pWlr());
+    box.applyFromWlr().translate(COORDS).expand(4);
+    g_pHyprRenderer->damageBox(&box);
+
+    m_pSubsurfaceHead.reset();
+
+    g_pInputManager->simulateMouseMovement();
+
+    if (m_pLayerOwner && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
+}
+
+void CPopup::onCommit(bool ignoreSiblings) {
+    if (m_pWLR->base->initial_commit) {
+        wlr_xdg_surface_schedule_configure(m_pWLR->base);
+        return;
+    }
+
+    if (m_pWindowOwner && (!m_pWindowOwner->m_bIsMapped || !m_pWindowOwner->m_pWorkspace->m_bVisible)) {
+        m_vLastSize = {m_pWLR->base->current.geometry.width, m_pWLR->base->current.geometry.height};
+
+        static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
+        if (*PLOGDAMAGE)
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowOwner);
+        return;
+    }
+
+    if (!m_pWLR->base->surface->mapped)
+        return;
+
+    const auto COORDS      = coordsGlobal();
+    const auto COORDSLOCAL = coordsRelativeToParent();
+
+    if (m_vLastSize != Vector2D{m_pWLR->base->current.geometry.width, m_pWLR->base->current.geometry.height} || m_bRequestedReposition || m_vLastPos != COORDSLOCAL) {
+        CBox box = {localToGlobal(m_vLastPos), m_vLastSize};
+        g_pHyprRenderer->damageBox(&box);
+        m_vLastSize = {m_pWLR->base->current.geometry.width, m_pWLR->base->current.geometry.height};
+        box         = {COORDS, m_vLastSize};
+        g_pHyprRenderer->damageBox(&box);
+
+        m_vLastPos = COORDSLOCAL;
+    }
+
+    if (!ignoreSiblings && m_pSubsurfaceHead)
+        m_pSubsurfaceHead->recheckDamageForSubsurfaces();
+
+    g_pHyprRenderer->damageSurface(m_sWLSurface.wlr(), COORDS.x, COORDS.y);
+
+    m_bRequestedReposition = false;
+
+    if (m_pLayerOwner && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
+}
+
+void CPopup::onReposition() {
+    Debug::log(LOG, "Popup {:x} requests reposition", (uintptr_t)this);
+
+    m_bRequestedReposition = true;
+
+    m_vLastPos = coordsRelativeToParent();
+
+    unconstrain();
+}
+
+void CPopup::unconstrain() {
+    const auto COORDS   = t1ParentCoords();
+    const auto PMONITOR = g_pCompositor->getMonitorFromVector(COORDS);
+
+    if (!PMONITOR)
+        return;
+
+    CBox box = {PMONITOR->vecPosition.x - COORDS.x, PMONITOR->vecPosition.y - COORDS.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    wlr_xdg_popup_unconstrain_from_box(m_pWLR, box.pWlr());
+}
+
+Vector2D CPopup::coordsRelativeToParent() {
+    Vector2D offset;
+
+    CPopup*  current = this;
+
+    offset -= {m_pWLR->base->current.geometry.x, m_pWLR->base->current.geometry.y};
+
+    while (current->m_pParent) {
+
+        offset += {current->m_sWLSurface.wlr()->current.dx, current->m_sWLSurface.wlr()->current.dy};
+        offset += {current->m_pWLR->current.geometry.x, current->m_pWLR->current.geometry.y};
+
+        current = current->m_pParent;
+    }
+
+    return offset;
+}
+
+Vector2D CPopup::coordsGlobal() {
+    return localToGlobal(coordsRelativeToParent());
+}
+
+Vector2D CPopup::localToGlobal(const Vector2D& rel) {
+    return t1ParentCoords() + rel;
+}
+
+Vector2D CPopup::t1ParentCoords() {
+    if (m_pWindowOwner)
+        return m_pWindowOwner->m_vRealPosition.value();
+    if (m_pLayerOwner)
+        return m_pLayerOwner->realPosition.value();
+
+    ASSERT(false);
+    return {};
+}
+
+void CPopup::recheckTree() {
+    CPopup* curr = this;
+    while (curr->m_pParent) {
+        curr = curr->m_pParent;
+    }
+
+    curr->recheckChildrenRecursive();
+}
+
+void CPopup::recheckChildrenRecursive() {
+    for (auto& c : m_vChildren) {
+        c->onCommit(true);
+        c->recheckChildrenRecursive();
+    }
+}
+
+Vector2D CPopup::size() {
+    return m_vLastSize;
+}
+
+void CPopup::sendScale() {
+    if (m_pWindowOwner)
+        g_pCompositor->setPreferredScaleForSurface(m_sWLSurface.wlr(), m_pWindowOwner->m_pWLSurface.m_fLastScale);
+    else if (m_pLayerOwner)
+        g_pCompositor->setPreferredScaleForSurface(m_sWLSurface.wlr(), m_pLayerOwner->surface.m_fLastScale);
+    else
+        UNREACHABLE();
+}

src/desktop/Popup.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include "Subsurface.hpp"
+
+struct SLayerSurface;
+
+class CPopup {
+  public:
+    // dummy head nodes
+    CPopup(CWindow* pOwner);
+    CPopup(SLayerSurface* pOwner);
+
+    // real nodes
+    CPopup(wlr_xdg_popup* popup, CPopup* pOwner);
+
+    ~CPopup();
+
+    Vector2D   coordsRelativeToParent();
+    Vector2D   coordsGlobal();
+
+    Vector2D   size();
+
+    void       onNewPopup(wlr_xdg_popup* popup);
+    void       onDestroy();
+    void       onMap();
+    void       onUnmap();
+    void       onCommit(bool ignoreSiblings = false);
+    void       onReposition();
+
+    void       recheckTree();
+
+    CWLSurface m_sWLSurface;
+
+  private:
+    // T1 owners, each popup has to have one of these
+    CWindow*       m_pWindowOwner = nullptr;
+    SLayerSurface* m_pLayerOwner  = nullptr;
+
+    // T2 owners
+    CPopup*        m_pParent = nullptr;
+
+    wlr_xdg_popup* m_pWLR = nullptr;
+
+    Vector2D       m_vLastSize = {};
+    Vector2D       m_vLastPos  = {};
+
+    bool           m_bRequestedReposition = false;
+
+    bool           m_bInert = false;
+
+    //
+    std::vector<std::unique_ptr<CPopup>> m_vChildren;
+    std::unique_ptr<CSubsurface>         m_pSubsurfaceHead;
+
+    // signals
+    DYNLISTENER(newPopup);
+    DYNLISTENER(destroyPopup);
+    DYNLISTENER(mapPopup);
+    DYNLISTENER(unmapPopup);
+    DYNLISTENER(commitPopup);
+    DYNLISTENER(repositionPopup);
+
+    void     initAllSignals();
+    void     unconstrain();
+    void     recheckChildrenRecursive();
+    void     sendScale();
+
+    Vector2D localToGlobal(const Vector2D& rel);
+    Vector2D t1ParentCoords();
+};

src/desktop/Subsurface.cpp

@@ -0,0 +1,229 @@
+#include "Subsurface.hpp"
+#include "../events/Events.hpp"
+#include "../Compositor.hpp"
+#include "../config/ConfigValue.hpp"
+
+static void onNewSubsurface(void* owner, void* data);
+
+CSubsurface::CSubsurface(CWindow* pOwner) : m_pWindowParent(pOwner) {
+    initSignals();
+    initExistingSubsurfaces(pOwner->m_pWLSurface.wlr());
+}
+
+CSubsurface::CSubsurface(CPopup* pOwner) : m_pPopupParent(pOwner) {
+    initSignals();
+    initExistingSubsurfaces(pOwner->m_sWLSurface.wlr());
+}
+
+CSubsurface::CSubsurface(wlr_subsurface* pSubsurface, CWindow* pOwner) : m_pSubsurface(pSubsurface), m_pWindowParent(pOwner) {
+    m_sWLSurface.assign(pSubsurface->surface, this);
+    initSignals();
+    initExistingSubsurfaces(pSubsurface->surface);
+}
+
+CSubsurface::CSubsurface(wlr_subsurface* pSubsurface, CPopup* pOwner) : m_pSubsurface(pSubsurface), m_pPopupParent(pOwner) {
+    m_sWLSurface.assign(pSubsurface->surface, this);
+    initSignals();
+    initExistingSubsurfaces(pSubsurface->surface);
+}
+
+CSubsurface::~CSubsurface() {
+    hyprListener_newSubsurface.removeCallback();
+
+    if (!m_pSubsurface)
+        return;
+
+    m_pSubsurface->data = nullptr;
+
+    hyprListener_commitSubsurface.removeCallback();
+    hyprListener_destroySubsurface.removeCallback();
+}
+
+static void onNewSubsurface(void* owner, void* data) {
+    const auto PSUBSURFACE = (CSubsurface*)owner;
+    PSUBSURFACE->onNewSubsurface((wlr_subsurface*)data);
+}
+
+static void onDestroySubsurface(void* owner, void* data) {
+    const auto PSUBSURFACE = (CSubsurface*)owner;
+    PSUBSURFACE->onDestroy();
+}
+
+static void onCommitSubsurface(void* owner, void* data) {
+    const auto PSUBSURFACE = (CSubsurface*)owner;
+    PSUBSURFACE->onCommit();
+}
+
+static void onMapSubsurface(void* owner, void* data) {
+    const auto PSUBSURFACE = (CSubsurface*)owner;
+    PSUBSURFACE->onMap();
+}
+
+static void onUnmapSubsurface(void* owner, void* data) {
+    const auto PSUBSURFACE = (CSubsurface*)owner;
+    PSUBSURFACE->onUnmap();
+}
+
+void CSubsurface::initSignals() {
+    if (m_pSubsurface) {
+        m_pSubsurface->data = this;
+        hyprListener_commitSubsurface.initCallback(&m_pSubsurface->surface->events.commit, &onCommitSubsurface, this, "CSubsurface");
+        hyprListener_destroySubsurface.initCallback(&m_pSubsurface->events.destroy, &onDestroySubsurface, this, "CSubsurface");
+        hyprListener_newSubsurface.initCallback(&m_pSubsurface->surface->events.new_subsurface, &::onNewSubsurface, this, "CSubsurface");
+        hyprListener_mapSubsurface.initCallback(&m_pSubsurface->surface->events.map, &onMapSubsurface, this, "CSubsurface");
+        hyprListener_unmapSubsurface.initCallback(&m_pSubsurface->surface->events.unmap, &onUnmapSubsurface, this, "CSubsurface");
+    } else {
+        if (m_pWindowParent)
+            hyprListener_newSubsurface.initCallback(&m_pWindowParent->m_pWLSurface.wlr()->events.new_subsurface, &::onNewSubsurface, this, "CSubsurface Head");
+        else if (m_pPopupParent)
+            hyprListener_newSubsurface.initCallback(&m_pPopupParent->m_sWLSurface.wlr()->events.new_subsurface, &::onNewSubsurface, this, "CSubsurface Head");
+        else
+            RASSERT(false, "CSubsurface::initSignals empty subsurface");
+    }
+}
+
+void CSubsurface::checkSiblingDamage() {
+    if (!m_pParent)
+        return; // ??????????
+
+    const double SCALE = m_pWindowParent && m_pWindowParent->m_bIsX11 ? 1.0 / m_pWindowParent->m_fX11SurfaceScaledBy : 1.0;
+
+    for (auto& n : m_pParent->m_vChildren) {
+        if (n.get() == this)
+            continue;
+
+        const auto COORDS = n->coordsGlobal();
+        g_pHyprRenderer->damageSurface(n->m_sWLSurface.wlr(), COORDS.x, COORDS.y, SCALE);
+    }
+}
+
+void CSubsurface::recheckDamageForSubsurfaces() {
+    for (auto& n : m_vChildren) {
+        const auto COORDS = n->coordsGlobal();
+        g_pHyprRenderer->damageSurface(n->m_sWLSurface.wlr(), COORDS.x, COORDS.y);
+    }
+}
+
+void CSubsurface::onCommit() {
+    // no damaging if it's not visible
+    if (m_pWindowParent && (!m_pWindowParent->m_bIsMapped || !m_pWindowParent->m_pWorkspace->m_bVisible)) {
+        m_vLastSize = Vector2D{m_sWLSurface.wlr()->current.width, m_sWLSurface.wlr()->current.height};
+
+        static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
+        if (*PLOGDAMAGE)
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowParent);
+        return;
+    }
+
+    const auto COORDS = coordsGlobal();
+
+    g_pHyprRenderer->damageSurface(m_sWLSurface.wlr(), COORDS.x, COORDS.y);
+
+    if (m_pPopupParent)
+        m_pPopupParent->recheckTree();
+    if (m_pWindowParent) // I hate you firefox why are you doing this
+        m_pWindowParent->m_pPopupHead->recheckTree();
+
+    // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
+    checkSiblingDamage();
+
+    if (m_vLastSize != Vector2D{m_sWLSurface.wlr()->current.width, m_sWLSurface.wlr()->current.height}) {
+        CBox box{COORDS, m_vLastSize};
+        g_pHyprRenderer->damageBox(&box);
+        m_vLastSize = Vector2D{m_sWLSurface.wlr()->current.width, m_sWLSurface.wlr()->current.height};
+        box         = {COORDS, m_vLastSize};
+        g_pHyprRenderer->damageBox(&box);
+    }
+}
+
+void CSubsurface::onDestroy() {
+    // destroy children
+    m_vChildren.clear();
+
+    m_bInert = true;
+
+    if (!m_pSubsurface)
+        return; // dummy node, nothing to do, it's the parent dying
+
+    // kill ourselves
+    std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; });
+}
+
+void CSubsurface::onNewSubsurface(wlr_subsurface* pSubsurface) {
+    CSubsurface* PSUBSURFACE = nullptr;
+
+    if (m_pWindowParent)
+        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pWindowParent)).get();
+    else if (m_pPopupParent)
+        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pPopupParent)).get();
+    PSUBSURFACE->m_pParent = this;
+
+    ASSERT(PSUBSURFACE);
+}
+
+void CSubsurface::onMap() {
+    m_vLastSize = {m_sWLSurface.wlr()->current.width, m_sWLSurface.wlr()->current.height};
+
+    const auto COORDS = coordsGlobal();
+    CBox       box{COORDS, m_vLastSize};
+    box.expand(4);
+    g_pHyprRenderer->damageBox(&box);
+
+    if (m_pWindowParent)
+        m_pWindowParent->updateSurfaceScaleTransformDetails();
+}
+
+void CSubsurface::onUnmap() {
+    const auto COORDS = coordsGlobal();
+    CBox       box{COORDS, m_vLastSize};
+    box.expand(4);
+    g_pHyprRenderer->damageBox(&box);
+
+    if (m_sWLSurface.wlr() == g_pCompositor->m_pLastFocus)
+        g_pInputManager->releaseAllMouseButtons();
+
+    g_pInputManager->simulateMouseMovement();
+
+    // TODO: should this remove children? Currently it won't, only on .destroy
+}
+
+Vector2D CSubsurface::coordsRelativeToParent() {
+    Vector2D     offset;
+
+    CSubsurface* current = this;
+
+    while (current->m_pParent) {
+
+        offset += {current->m_sWLSurface.wlr()->current.dx, current->m_sWLSurface.wlr()->current.dy};
+        offset += {current->m_pSubsurface->current.x, current->m_pSubsurface->current.y};
+
+        current = current->m_pParent;
+    }
+
+    return offset;
+}
+
+Vector2D CSubsurface::coordsGlobal() {
+    Vector2D coords = coordsRelativeToParent();
+
+    if (m_pWindowParent)
+        coords += m_pWindowParent->m_vRealPosition.value();
+    else if (m_pPopupParent)
+        coords += m_pPopupParent->coordsGlobal();
+
+    return coords;
+}
+
+void CSubsurface::initExistingSubsurfaces(wlr_surface* pSurface) {
+    wlr_subsurface* wlrSubsurface;
+    wl_list_for_each(wlrSubsurface, &pSurface->current.subsurfaces_below, current.link) {
+        ::onNewSubsurface(this, wlrSubsurface);
+    }
+    wl_list_for_each(wlrSubsurface, &pSurface->current.subsurfaces_above, current.link) {
+        ::onNewSubsurface(this, wlrSubsurface);
+    }
+}
+
+Vector2D CSubsurface::size() {
+    return {m_sWLSurface.wlr()->current.width, m_sWLSurface.wlr()->current.height};
+}

src/desktop/Subsurface.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "../defines.hpp"
+#include <vector>
+#include "WLSurface.hpp"
+
+class CWindow;
+class CPopup;
+
+class CSubsurface {
+  public:
+    // root dummy nodes
+    CSubsurface(CWindow* pOwner);
+    CSubsurface(CPopup* pOwner);
+
+    // real nodes
+    CSubsurface(wlr_subsurface* pSubsurface, CWindow* pOwner);
+    CSubsurface(wlr_subsurface* pSubsurface, CPopup* pOwner);
+
+    ~CSubsurface();
+
+    Vector2D coordsRelativeToParent();
+    Vector2D coordsGlobal();
+
+    Vector2D size();
+
+    void     onCommit();
+    void     onDestroy();
+    void     onNewSubsurface(wlr_subsurface* pSubsurface);
+    void     onMap();
+    void     onUnmap();
+
+    void     recheckDamageForSubsurfaces();
+
+  private:
+    DYNLISTENER(destroySubsurface);
+    DYNLISTENER(commitSubsurface);
+    DYNLISTENER(newSubsurface);
+    DYNLISTENER(mapSubsurface);
+    DYNLISTENER(unmapSubsurface);
+
+    wlr_subsurface* m_pSubsurface = nullptr;
+    CWLSurface      m_sWLSurface;
+    Vector2D        m_vLastSize = {};
+
+    // if nullptr, means it's a dummy node
+    CSubsurface*                              m_pParent = nullptr;
+
+    CWindow*                                  m_pWindowParent = nullptr;
+    CPopup*                                   m_pPopupParent  = nullptr;
+
+    std::vector<std::unique_ptr<CSubsurface>> m_vChildren;
+
+    bool                                      m_bInert = false;
+
+    void                                      initSignals();
+    void                                      initExistingSubsurfaces(wlr_surface* pSurface);
+    void                                      checkSiblingDamage();
+};

src/desktop/WLSurface.cpp

@@ -0,0 +1,196 @@
+#include "WLSurface.hpp"
+#include "../Compositor.hpp"
+
+void CWLSurface::assign(wlr_surface* pSurface) {
+    m_pWLRSurface = pSurface;
+    init();
+    m_bInert = false;
+}
+
+void CWLSurface::assign(wlr_surface* pSurface, CWindow* pOwner) {
+    m_pWindowOwner = pOwner;
+    m_pWLRSurface  = pSurface;
+    init();
+    m_bInert = false;
+}
+
+void CWLSurface::assign(wlr_surface* pSurface, SLayerSurface* pOwner) {
+    m_pLayerOwner = pOwner;
+    m_pWLRSurface = pSurface;
+    init();
+    m_bInert = false;
+}
+
+void CWLSurface::assign(wlr_surface* pSurface, CSubsurface* pOwner) {
+    m_pSubsurfaceOwner = pOwner;
+    m_pWLRSurface      = pSurface;
+    init();
+    m_bInert = false;
+}
+
+void CWLSurface::assign(wlr_surface* pSurface, CPopup* pOwner) {
+    m_pPopupOwner = pOwner;
+    m_pWLRSurface = pSurface;
+    init();
+    m_bInert = false;
+}
+
+void CWLSurface::unassign() {
+    destroy();
+}
+
+CWLSurface::~CWLSurface() {
+    destroy();
+}
+
+bool CWLSurface::exists() const {
+    return m_pWLRSurface;
+}
+
+wlr_surface* CWLSurface::wlr() const {
+    return m_pWLRSurface;
+}
+
+bool CWLSurface::small() const {
+    if (!m_pWindowOwner || !exists())
+        return false;
+
+    return m_pWindowOwner->m_vReportedSize.x > m_pWLRSurface->current.buffer_width + 1 || m_pWindowOwner->m_vReportedSize.y > m_pWLRSurface->current.buffer_height + 1;
+}
+
+Vector2D CWLSurface::correctSmallVec() const {
+    if (!m_pWindowOwner || !exists() || !small() || m_bFillIgnoreSmall)
+        return {};
+
+    const auto SIZE = getViewporterCorrectedSize();
+
+    return Vector2D{(m_pWindowOwner->m_vReportedSize.x - SIZE.x) / 2, (m_pWindowOwner->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) *
+        (m_pWindowOwner->m_vRealSize.value() / m_pWindowOwner->m_vReportedSize);
+}
+
+Vector2D CWLSurface::getViewporterCorrectedSize() const {
+    if (!exists())
+        return {};
+
+    return m_pWLRSurface->current.viewport.has_dst ? Vector2D{m_pWLRSurface->current.viewport.dst_width, m_pWLRSurface->current.viewport.dst_height} :
+                                                     Vector2D{m_pWLRSurface->current.buffer_width, m_pWLRSurface->current.buffer_height};
+}
+
+CRegion CWLSurface::logicalDamage() const {
+    CRegion damage{&m_pWLRSurface->buffer_damage};
+    damage.transform(m_pWLRSurface->current.transform, m_pWLRSurface->current.buffer_width, m_pWLRSurface->current.buffer_height);
+    damage.scale(1.0 / m_pWLRSurface->current.scale);
+
+    const auto VPSIZE     = getViewporterCorrectedSize();
+    const auto CORRECTVEC = correctSmallVec();
+
+    if (m_pWLRSurface->current.viewport.has_src) {
+        damage.intersect(CBox{std::floor(m_pWLRSurface->current.viewport.src.x), std::floor(m_pWLRSurface->current.viewport.src.y),
+                              std::ceil(m_pWLRSurface->current.viewport.src.width), std::ceil(m_pWLRSurface->current.viewport.src.height)});
+    }
+
+    const auto SCALEDSRCSIZE = m_pWLRSurface->current.viewport.has_src ?
+        Vector2D{m_pWLRSurface->current.viewport.src.width, m_pWLRSurface->current.viewport.src.height} * m_pWLRSurface->current.scale :
+        Vector2D{m_pWLRSurface->current.buffer_width, m_pWLRSurface->current.buffer_height};
+
+    damage.scale({VPSIZE.x / SCALEDSRCSIZE.x, VPSIZE.y / SCALEDSRCSIZE.y});
+    damage.translate(CORRECTVEC);
+
+    return damage;
+}
+
+void CWLSurface::destroy() {
+    if (!m_pWLRSurface)
+        return;
+
+    m_pConstraint.reset();
+
+    hyprListener_destroy.removeCallback();
+    hyprListener_commit.removeCallback();
+    m_pWLRSurface->data = nullptr;
+    m_pWindowOwner      = nullptr;
+    m_pLayerOwner       = nullptr;
+    m_pPopupOwner       = nullptr;
+    m_pSubsurfaceOwner  = nullptr;
+    m_bInert            = true;
+
+    if (g_pCompositor && g_pCompositor->m_pLastFocus == m_pWLRSurface)
+        g_pCompositor->m_pLastFocus = nullptr;
+    if (g_pInputManager && g_pInputManager->m_pLastMouseSurface == m_pWLRSurface)
+        g_pInputManager->m_pLastMouseSurface = nullptr;
+    if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf == m_pWLRSurface)
+        g_pHyprRenderer->m_sLastCursorData.surf.reset();
+
+    m_pWLRSurface = nullptr;
+
+    Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this);
+}
+
+static void onCommit(void* owner, void* data) {
+    const auto SURF = (CWLSurface*)owner;
+    SURF->onCommit();
+}
+
+void CWLSurface::init() {
+    if (!m_pWLRSurface)
+        return;
+
+    RASSERT(!m_pWLRSurface->data, "Attempted to duplicate CWLSurface ownership!");
+
+    m_pWLRSurface->data = this;
+
+    hyprListener_destroy.initCallback(
+        &m_pWLRSurface->events.destroy, [&](void* owner, void* data) { destroy(); }, this, "CWLSurface");
+    hyprListener_commit.initCallback(&m_pWLRSurface->events.commit, ::onCommit, this, "CWLSurface");
+
+    Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
+}
+
+CWindow* CWLSurface::getWindow() {
+    return m_pWindowOwner;
+}
+
+SLayerSurface* CWLSurface::getLayer() {
+    return m_pLayerOwner;
+}
+
+CPopup* CWLSurface::getPopup() {
+    return m_pPopupOwner;
+}
+
+CSubsurface* CWLSurface::getSubsurface() {
+    return m_pSubsurfaceOwner;
+}
+
+bool CWLSurface::desktopComponent() {
+    return m_pLayerOwner || m_pWindowOwner || m_pSubsurfaceOwner || m_pPopupOwner;
+}
+
+std::optional<CBox> CWLSurface::getSurfaceBoxGlobal() {
+    if (!desktopComponent())
+        return {};
+
+    if (m_pWindowOwner)
+        return m_pWindowOwner->getWindowMainSurfaceBox();
+    if (m_pLayerOwner)
+        return m_pLayerOwner->geometry;
+    if (m_pPopupOwner)
+        return CBox{m_pPopupOwner->coordsGlobal(), m_pPopupOwner->size()};
+    if (m_pSubsurfaceOwner)
+        return CBox{m_pSubsurfaceOwner->coordsGlobal(), m_pSubsurfaceOwner->size()};
+
+    return {};
+}
+
+void CWLSurface::appendConstraint(wlr_pointer_constraint_v1* constraint) {
+    m_pConstraint = std::make_unique<CConstraint>(constraint, this);
+}
+
+void CWLSurface::onCommit() {
+    if (m_pConstraint)
+        m_pConstraint->onCommit();
+}
+
+CConstraint* CWLSurface::constraint() {
+    return m_pConstraint.get();
+}

src/desktop/WLSurface.hpp

@@ -1,16 +1,25 @@
 #pragma once
 
 #include "../defines.hpp"
+#include "../helpers/Region.hpp"
+#include "Constraint.hpp"
 
 class CWindow;
+struct SLayerSurface;
+class CSubsurface;
+class CPopup;
 
 class CWLSurface {
   public:
     CWLSurface() = default;
-    CWLSurface(wlr_surface* pSurface);
     ~CWLSurface();
 
+    // anonymous surfaces are non-desktop components, e.g. a cursor surface or a DnD
     void assign(wlr_surface* pSurface);
+    void assign(wlr_surface* pSurface, CWindow* pOwner);
+    void assign(wlr_surface* pSurface, SLayerSurface* pOwner);
+    void assign(wlr_surface* pSurface, CSubsurface* pOwner);
+    void assign(wlr_surface* pSurface, CPopup* pOwner);
     void unassign();
 
     CWLSurface(const CWLSurface&)             = delete;
@@ -23,13 +32,23 @@ class CWLSurface {
     bool         small() const;           // means surface is smaller than the requested size
     Vector2D     correctSmallVec() const; // returns a corrective vector for small() surfaces
     Vector2D     getViewporterCorrectedSize() const;
+    CRegion      logicalDamage() const;
+    void         onCommit();
+
+    // getters for owners.
+    CWindow*       getWindow();
+    SLayerSurface* getLayer();
+    CPopup*        getPopup();
+    CSubsurface*   getSubsurface();
+
+    // desktop components misc utils
+    std::optional<CBox> getSurfaceBoxGlobal();
+    void                appendConstraint(wlr_pointer_constraint_v1* constraint);
+    CConstraint*        constraint();
 
     // allow stretching. Useful for plugins.
     bool m_bFillIgnoreSmall = false;
 
-    // if present, means this is a base surface of a window. Cleaned on unassign()
-    CWindow* m_pOwner = nullptr;
-
     // track surface data and avoid dupes
     float               m_fLastScale     = 0;
     int                 m_iLastScale     = 0;
@@ -57,14 +76,30 @@ class CWLSurface {
     }
 
     static CWLSurface* surfaceFromWlr(wlr_surface* pSurface) {
+        if (!pSurface)
+            return nullptr;
         return (CWLSurface*)pSurface->data;
     }
 
   private:
+    bool           m_bInert = true;
+
     wlr_surface*   m_pWLRSurface = nullptr;
 
+    CWindow*       m_pWindowOwner     = nullptr;
+    SLayerSurface* m_pLayerOwner      = nullptr;
+    CPopup*        m_pPopupOwner      = nullptr;
+    CSubsurface*   m_pSubsurfaceOwner = nullptr;
+
+    //
+    std::unique_ptr<CConstraint> m_pConstraint;
+
     void                         destroy();
     void                         init();
+    bool                         desktopComponent();
 
     DYNLISTENER(destroy);
+    DYNLISTENER(commit);
+
+    friend class CConstraint;
 };

src/desktop/Window.cpp

@@ -1,18 +1,20 @@
 #include "Window.hpp"
-#include "Compositor.hpp"
-#include "render/decorations/CHyprDropShadowDecoration.hpp"
-#include "render/decorations/CHyprGroupBarDecoration.hpp"
-#include "render/decorations/CHyprBorderDecoration.hpp"
+#include "../Compositor.hpp"
+#include "../render/decorations/CHyprDropShadowDecoration.hpp"
+#include "../render/decorations/CHyprGroupBarDecoration.hpp"
+#include "../render/decorations/CHyprBorderDecoration.hpp"
+#include "../config/ConfigValue.hpp"
+#include <any>
 
 CWindow::CWindow() {
-    m_vRealPosition.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*)this, AVARDAMAGE_ENTIRE);
-    m_vRealSize.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*)this, AVARDAMAGE_ENTIRE);
-    m_fBorderFadeAnimationProgress.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("border"), (void*)this, AVARDAMAGE_BORDER);
-    m_fBorderAngleAnimationProgress.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("borderangle"), (void*)this, AVARDAMAGE_BORDER);
-    m_fAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), (void*)this, AVARDAMAGE_ENTIRE);
-    m_fActiveInactiveAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), (void*)this, AVARDAMAGE_ENTIRE);
-    m_cRealShadowColor.create(AVARTYPE_COLOR, g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), (void*)this, AVARDAMAGE_SHADOW);
-    m_fDimPercent.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeDim"), (void*)this, AVARDAMAGE_ENTIRE);
+    m_vRealPosition.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), this, AVARDAMAGE_ENTIRE);
+    m_vRealSize.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), this, AVARDAMAGE_ENTIRE);
+    m_fBorderFadeAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("border"), this, AVARDAMAGE_BORDER);
+    m_fBorderAngleAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("borderangle"), this, AVARDAMAGE_BORDER);
+    m_fAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeIn"), this, AVARDAMAGE_ENTIRE);
+    m_fActiveInactiveAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), this, AVARDAMAGE_ENTIRE);
+    m_cRealShadowColor.create(g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), this, AVARDAMAGE_SHADOW);
+    m_fDimPercent.create(g_pConfigManager->getAnimationPropertyConfig("fadeDim"), this, AVARDAMAGE_ENTIRE);
 
     addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(this));
     addWindowDeco(std::make_unique<CHyprBorderDecoration>(this));
@@ -39,8 +41,8 @@ SWindowDecorationExtents CWindow::getFullWindowExtents() {
 
     if (m_sAdditionalConfigData.dimAround) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
-        return {{m_vRealPosition.vec().x - PMONITOR->vecPosition.x, m_vRealPosition.vec().y - PMONITOR->vecPosition.y},
-                {PMONITOR->vecSize.x - (m_vRealPosition.vec().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_vRealPosition.vec().y - PMONITOR->vecPosition.y)}};
+        return {{m_vRealPosition.value().x - PMONITOR->vecPosition.x, m_vRealPosition.value().y - PMONITOR->vecPosition.y},
+                {PMONITOR->vecSize.x - (m_vRealPosition.value().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_vRealPosition.value().y - PMONITOR->vecPosition.y)}};
     }
 
     SWindowDecorationExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
@@ -101,8 +103,8 @@ CBox CWindow::getFullWindowBoundingBox() {
 
     auto maxExtents = getFullWindowExtents();
 
-    CBox finalBox = {m_vRealPosition.vec().x - maxExtents.topLeft.x, m_vRealPosition.vec().y - maxExtents.topLeft.y,
-                     m_vRealSize.vec().x + maxExtents.topLeft.x + maxExtents.bottomRight.x, m_vRealSize.vec().y + maxExtents.topLeft.y + maxExtents.bottomRight.y};
+    CBox finalBox = {m_vRealPosition.value().x - maxExtents.topLeft.x, m_vRealPosition.value().y - maxExtents.topLeft.y,
+                     m_vRealSize.value().x + maxExtents.topLeft.x + maxExtents.bottomRight.x, m_vRealSize.value().y + maxExtents.topLeft.y + maxExtents.bottomRight.y};
 
     return finalBox;
 }
@@ -154,14 +156,14 @@ CBox CWindow::getWindowBoxUnified(uint64_t properties) {
     if (properties & FULL_EXTENTS)
         EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationExtents(this, false));
 
-    CBox box = {m_vRealPosition.vec().x, m_vRealPosition.vec().y, m_vRealSize.vec().x, m_vRealSize.vec().y};
+    CBox box = {m_vRealPosition.value().x, m_vRealPosition.value().y, m_vRealSize.value().x, m_vRealSize.value().y};
     box.addExtents(EXTENTS);
 
     return box;
 }
 
 CBox CWindow::getWindowMainSurfaceBox() {
-    return {m_vRealPosition.vec().x, m_vRealPosition.vec().y, m_vRealSize.vec().x, m_vRealSize.vec().y};
+    return {m_vRealPosition.value().x, m_vRealPosition.value().y, m_vRealSize.value().x, m_vRealSize.value().y};
 }
 
 SWindowDecorationExtents CWindow::getFullWindowReservedArea() {
@@ -193,7 +195,14 @@ void CWindow::updateWindowDecos() {
 
     m_vDecosToRemove.clear();
 
+    // make a copy because updateWindow can remove decos.
+    std::vector<IHyprWindowDecoration*> decos;
+
     for (auto& wd : m_dWindowDecorations) {
+        decos.push_back(wd.get());
+    }
+
+    for (auto& wd : decos) {
         wd->updateWindow(this);
     }
 }
@@ -239,13 +248,12 @@ bool CWindow::checkInputOnDecos(const eInputType type, const Vector2D& mouseCoor
 pid_t CWindow::getPID() {
     pid_t PID = -1;
     if (!m_bIsX11) {
-
-        if (!m_bIsMapped)
+        if (!m_uSurface.xdg)
             return -1;
 
         wl_client_get_credentials(wl_resource_get_client(m_uSurface.xdg->resource), &PID, nullptr, nullptr);
     } else {
-        if (!m_bIsMapped)
+        if (!m_uSurface.xwayland)
             return -1;
 
         PID = m_uSurface.xwayland->pid;
@@ -336,7 +344,7 @@ void sendLeaveIter(wlr_surface* pSurface, int x, int y, void* data) {
 }
 
 void CWindow::updateSurfaceScaleTransformDetails() {
-    if (!m_bIsMapped || m_bHidden)
+    if (!m_bIsMapped || m_bHidden || g_pCompositor->m_bUnsafeState)
         return;
 
     const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(m_iLastSurfaceMonitorID);
@@ -345,6 +353,9 @@ void CWindow::updateSurfaceScaleTransformDetails() {
 
     const auto PNEWMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
 
+    if (!PNEWMONITOR)
+        return;
+
     if (PNEWMONITOR != PLASTMONITOR) {
         if (PLASTMONITOR && PLASTMONITOR->m_bEnabled)
             wlr_surface_for_each_surface(m_pWLSurface.wlr(), sendLeaveIter, PLASTMONITOR->output);
@@ -367,41 +378,42 @@ void CWindow::updateSurfaceScaleTransformDetails() {
         this);
 }
 
-void CWindow::moveToWorkspace(int workspaceID) {
-    if (m_iWorkspaceID == workspaceID)
+void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
+    if (m_pWorkspace == pWorkspace)
         return;
 
-    static auto* const PCLOSEONLASTSPECIAL = &g_pConfigManager->getConfigValuePtr("misc:close_special_on_empty")->intValue;
+    static auto PCLOSEONLASTSPECIAL = CConfigValue<Hyprlang::INT>("misc:close_special_on_empty");
 
-    const int          OLDWORKSPACE = m_iWorkspaceID;
+    const auto  OLDWORKSPACE = m_pWorkspace;
 
-    m_iWorkspaceID = workspaceID;
+    m_pWorkspace = pWorkspace;
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
+    setAnimationsToMove();
 
-    updateSpecialRenderData();
+    g_pCompositor->updateWorkspaceWindows(OLDWORKSPACE->m_iID);
+    g_pCompositor->updateWorkspaceSpecialRenderData(OLDWORKSPACE->m_iID);
+    g_pCompositor->updateWorkspaceWindows(workspaceID());
+    g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
-    if (PWORKSPACE) {
-        g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", std::format("{:x},{}", (uintptr_t)this, PWORKSPACE->m_szName)});
-        EMIT_HOOK_EVENT("moveWindow", (std::vector<void*>{this, PWORKSPACE}));
+    if (valid(pWorkspace)) {
+        g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", std::format("{:x},{}", (uintptr_t)this, pWorkspace->m_szName)});
+        g_pEventManager->postEvent(SHyprIPCEvent{"movewindowv2", std::format("{:x},{},{}", (uintptr_t)this, pWorkspace->m_iID, pWorkspace->m_szName)});
+        EMIT_HOOK_EVENT("moveWindow", (std::vector<std::any>{this, pWorkspace}));
     }
 
     if (m_pSwallowed) {
-        m_pSwallowed->moveToWorkspace(workspaceID);
+        m_pSwallowed->moveToWorkspace(pWorkspace);
         m_pSwallowed->m_iMonitorID = m_iMonitorID;
     }
 
     // update xwayland coords
-    g_pXWaylandManager->setWindowSize(this, m_vRealSize.vec());
+    g_pXWaylandManager->setWindowSize(this, m_vRealSize.value());
 
-    if (g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE) && g_pCompositor->getWindowsOnWorkspace(OLDWORKSPACE) == 0 && *PCLOSEONLASTSPECIAL) {
-        const auto PWS = g_pCompositor->getWorkspaceByID(OLDWORKSPACE);
-
-        if (PWS) {
-            if (const auto PMONITOR = g_pCompositor->getMonitorFromID(PWS->m_iMonitorID); PMONITOR)
+    if (OLDWORKSPACE && g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE->m_iID) && g_pCompositor->getWindowsOnWorkspace(OLDWORKSPACE->m_iID) == 0 && *PCLOSEONLASTSPECIAL) {
+        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(OLDWORKSPACE->m_iMonitorID); PMONITOR)
             PMONITOR->setSpecialWorkspace(nullptr);
     }
-    }
 }
 
 CWindow* CWindow::X11TransientFor() {
@@ -433,15 +445,17 @@ void CWindow::removeDecorationByType(eDecorationType type) {
 }
 
 void unregisterVar(void* ptr) {
-    ((CAnimatedVariable*)ptr)->unregister();
+    ((CBaseAnimatedVariable*)ptr)->unregister();
 }
 
 void CWindow::onUnmap() {
-    static auto* const PCLOSEONLASTSPECIAL = &g_pConfigManager->getConfigValuePtr("misc:close_special_on_empty")->intValue;
+    static auto PCLOSEONLASTSPECIAL = CConfigValue<Hyprlang::INT>("misc:close_special_on_empty");
 
     if (g_pCompositor->m_pLastWindow == this)
         g_pCompositor->m_pLastWindow = nullptr;
 
+    m_iLastWorkspace = m_pWorkspace->m_iID;
+
     m_vRealPosition.setCallbackOnEnd(unregisterVar);
     m_vRealSize.setCallbackOnEnd(unregisterVar);
     m_fBorderFadeAnimationProgress.setCallbackOnEnd(unregisterVar);
@@ -455,13 +469,11 @@ void CWindow::onUnmap() {
 
     std::erase_if(g_pCompositor->m_vWindowFocusHistory, [&](const auto& other) { return other == this; });
 
-    m_pWLSurface.unassign();
-
     hyprListener_unmapWindow.removeCallback();
 
-    if (*PCLOSEONLASTSPECIAL && g_pCompositor->getWindowsOnWorkspace(m_iWorkspaceID) == 0 && g_pCompositor->isWorkspaceSpecial(m_iWorkspaceID)) {
+    if (*PCLOSEONLASTSPECIAL && g_pCompositor->getWindowsOnWorkspace(workspaceID()) == 0 && onSpecialWorkspace()) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
-        if (PMONITOR && PMONITOR->specialWorkspaceID == m_iWorkspaceID)
+        if (PMONITOR && PMONITOR->activeSpecialWorkspace && PMONITOR->activeSpecialWorkspace == m_pWorkspace)
             PMONITOR->setSpecialWorkspace(nullptr);
     }
 
@@ -470,14 +482,20 @@ void CWindow::onUnmap() {
     if (PMONITOR && PMONITOR->solitaryClient == this)
         PMONITOR->solitaryClient = nullptr;
 
-    g_pCompositor->updateWorkspaceWindows(m_iWorkspaceID);
+    g_pCompositor->updateWorkspaceWindows(workspaceID());
+    g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
+
+    m_pWorkspace.reset();
+
+    if (m_bIsX11)
+        return;
+
+    m_pSubsurfaceHead.reset();
+    m_pPopupHead.reset();
 }
 
 void CWindow::onMap() {
-
-    m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(this));
-    m_pWLSurface.m_pOwner = this;
-
     // JIC, reset the callbacks. If any are set, we'll make sure they are cleared so we don't accidentally unset them. (In case a window got remapped)
     m_vRealPosition.resetAllCallbacks();
     m_vRealSize.resetAllCallbacks();
@@ -508,6 +526,7 @@ void CWindow::onMap() {
                                           "CWindow");
 
     m_vReportedSize = m_vPendingReportedSize;
+    m_bAnimatingIn  = true;
 
     for (const auto& ctrl : g_pHyprRenderer->m_vTearingControllers) {
         if (ctrl->pWlrHint->surface != m_pWLSurface.wlr())
@@ -516,10 +535,16 @@ void CWindow::onMap() {
         m_bTearingHint = ctrl->pWlrHint->current;
         break;
     }
+
+    if (m_bIsX11)
+        return;
+
+    m_pSubsurfaceHead = std::make_unique<CSubsurface>(this);
+    m_pPopupHead      = std::make_unique<CPopup>(this);
 }
 
 void CWindow::onBorderAngleAnimEnd(void* ptr) {
-    const auto        PANIMVAR = (CAnimatedVariable*)ptr;
+    const auto        PANIMVAR = (CAnimatedVariable<float>*)ptr;
 
     const std::string STYLE = PANIMVAR->getConfig()->pValues->internalStyle;
 
@@ -585,25 +610,36 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
                     continue;
 
                 if (r == "override") {
-                    if (opacityIDX == 1) {
+                    if (opacityIDX == 1)
                         m_sSpecialRenderData.alphaOverride = true;
+                    else if (opacityIDX == 2)
                         m_sSpecialRenderData.alphaInactiveOverride = true;
-                    } else if (opacityIDX == 2)
-                        m_sSpecialRenderData.alphaInactiveOverride = true;
+                    else if (opacityIDX == 3)
+                        m_sSpecialRenderData.alphaFullscreenOverride = true;
                 } else {
                     if (opacityIDX == 0) {
                         m_sSpecialRenderData.alpha         = std::stof(r);
-                        m_sSpecialRenderData.alphaInactive = std::stof(r);
+                        m_sSpecialRenderData.alphaOverride = false;
                     } else if (opacityIDX == 1) {
                         m_sSpecialRenderData.alphaInactive         = std::stof(r);
                         m_sSpecialRenderData.alphaInactiveOverride = false;
+                    } else if (opacityIDX == 2) {
+                        m_sSpecialRenderData.alphaFullscreen         = std::stof(r);
+                        m_sSpecialRenderData.alphaFullscreenOverride = false;
                     } else {
-                        throw std::runtime_error("more than 2 alpha values");
+                        throw std::runtime_error("more than 3 alpha values");
                     }
 
                     opacityIDX++;
                 }
             }
+
+            if (opacityIDX == 1) {
+                m_sSpecialRenderData.alphaInactiveOverride   = m_sSpecialRenderData.alphaOverride;
+                m_sSpecialRenderData.alphaInactive           = m_sSpecialRenderData.alpha;
+                m_sSpecialRenderData.alphaFullscreenOverride = m_sSpecialRenderData.alphaOverride;
+                m_sSpecialRenderData.alphaFullscreen         = m_sSpecialRenderData.alpha;
+            }
         } catch (std::exception& e) { Debug::log(ERR, "Opacity rule \"{}\" failed with: {}", r.szRule, e.what()); }
     } else if (r.szRule == "noanim") {
         m_sAdditionalConfigData.forceNoAnims = true;
@@ -673,6 +709,38 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
             m_eIdleInhibitMode = IDLEINHIBIT_FULLSCREEN;
         else
             Debug::log(ERR, "Rule idleinhibit: unknown mode {}", IDLERULE);
+    } else if (r.szRule.starts_with("maxsize")) {
+        try {
+            if (!m_bIsFloating)
+                return;
+            const auto VEC = configStringToVector2D(r.szRule.substr(8));
+            if (VEC.x < 1 || VEC.y < 1) {
+                Debug::log(ERR, "Invalid size for maxsize");
+                return;
+            }
+
+            m_sAdditionalConfigData.maxSize = VEC;
+            m_vRealSize                     = Vector2D(std::min((double)m_sAdditionalConfigData.maxSize.toUnderlying().x, m_vRealSize.goal().x),
+                                                       std::min((double)m_sAdditionalConfigData.maxSize.toUnderlying().y, m_vRealSize.goal().y));
+            g_pXWaylandManager->setWindowSize(this, m_vRealSize.goal());
+            setHidden(false);
+        } catch (std::exception& e) { Debug::log(ERR, "maxsize rule \"{}\" failed with: {}", r.szRule, e.what()); }
+    } else if (r.szRule.starts_with("minsize")) {
+        try {
+            if (!m_bIsFloating)
+                return;
+            const auto VEC = configStringToVector2D(r.szRule.substr(8));
+            if (VEC.x < 1 || VEC.y < 1) {
+                Debug::log(ERR, "Invalid size for minsize");
+                return;
+            }
+
+            m_sAdditionalConfigData.minSize = VEC;
+            m_vRealSize                     = Vector2D(std::max((double)m_sAdditionalConfigData.minSize.toUnderlying().x, m_vRealSize.goal().x),
+                                                       std::max((double)m_sAdditionalConfigData.minSize.toUnderlying().y, m_vRealSize.goal().y));
+            g_pXWaylandManager->setWindowSize(this, m_vRealSize.goal());
+            setHidden(false);
+        } catch (std::exception& e) { Debug::log(ERR, "minsize rule \"{}\" failed with: {}", r.szRule, e.what()); }
     }
 }
 
@@ -687,6 +755,8 @@ void CWindow::updateDynamicRules() {
     m_sAdditionalConfigData.forceNoDim       = false;
     if (!m_sAdditionalConfigData.forceOpaqueOverridden)
         m_sAdditionalConfigData.forceOpaque = false;
+    m_sAdditionalConfigData.maxSize         = Vector2D(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
+    m_sAdditionalConfigData.minSize         = Vector2D(20, 20);
     m_sAdditionalConfigData.forceNoAnims    = false;
     m_sAdditionalConfigData.animationStyle  = std::string("");
     m_sAdditionalConfigData.rounding        = -1;
@@ -716,10 +786,10 @@ bool CWindow::isInCurvedCorner(double x, double y) {
         return false;
 
     // (x0, y0), (x0, y1), ... are the center point of rounding at each corner
-    double x0 = m_vRealPosition.vec().x + ROUNDING;
-    double y0 = m_vRealPosition.vec().y + ROUNDING;
-    double x1 = m_vRealPosition.vec().x + m_vRealSize.vec().x - ROUNDING;
-    double y1 = m_vRealPosition.vec().y + m_vRealSize.vec().y - ROUNDING;
+    double x0 = m_vRealPosition.value().x + ROUNDING;
+    double y0 = m_vRealPosition.value().y + ROUNDING;
+    double x1 = m_vRealPosition.value().x + m_vRealSize.value().x - ROUNDING;
+    double y1 = m_vRealPosition.value().y + m_vRealSize.value().y - ROUNDING;
 
     if (x < x0 && y < y0) {
         return Vector2D{x0, y0}.distance(Vector2D{x, y}) > (double)ROUNDING;
@@ -752,7 +822,7 @@ bool CWindow::hasPopupAt(const Vector2D& pos) {
         return false;
 
     wlr_surface*          resultSurf = nullptr;
-    Vector2D              origin     = m_vRealPosition.vec();
+    Vector2D              origin     = m_vRealPosition.value();
     SExtensionFindingData data       = {origin, pos, &resultSurf};
     wlr_xdg_surface_for_each_popup_surface(m_uSurface.xdg, findExtensionForVector2D, &data);
 
@@ -782,6 +852,8 @@ void CWindow::createGroup() {
         addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(this));
 
         g_pLayoutManager->getCurrentLayout()->recalculateWindow(this);
+        g_pCompositor->updateWorkspaceWindows(workspaceID());
+        g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
     }
 }
@@ -793,7 +865,11 @@ void CWindow::destroyGroup() {
             return;
         }
         m_sGroupData.pNextWindow = nullptr;
+        m_sGroupData.head        = false;
         updateWindowDecos();
+        g_pCompositor->updateWorkspaceWindows(workspaceID());
+        g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+        g_pCompositor->updateAllWindowsAnimatedDecorationValues();
         return;
     }
 
@@ -820,6 +896,10 @@ void CWindow::destroyGroup() {
         w->updateWindowDecos();
     }
     g_pKeybindManager->m_bGroupsLocked = GROUPSLOCKEDPREV;
+
+    g_pCompositor->updateWorkspaceWindows(workspaceID());
+    g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 }
 
 CWindow* CWindow::getGroupHead() {
@@ -889,10 +969,10 @@ void CWindow::setGroupCurrent(CWindow* pWindow) {
 
     const auto PCURRENT   = getGroupCurrent();
     const bool FULLSCREEN = PCURRENT->m_bIsFullscreen;
-    const auto WORKSPACE  = g_pCompositor->getWorkspaceByID(PCURRENT->m_iWorkspaceID);
+    const auto WORKSPACE  = PCURRENT->m_pWorkspace;
 
-    const auto PWINDOWSIZE = PCURRENT->m_vRealSize.goalv();
-    const auto PWINDOWPOS  = PCURRENT->m_vRealPosition.goalv();
+    const auto PWINDOWSIZE = PCURRENT->m_vRealSize.goal();
+    const auto PWINDOWPOS  = PCURRENT->m_vRealPosition.goal();
 
     const auto CURRENTISFOCUS = PCURRENT == g_pCompositor->m_pLastWindow;
 
@@ -982,31 +1062,36 @@ void CWindow::updateGroupOutputs() {
 
     CWindow*   curr = m_sGroupData.pNextWindow;
 
+    const auto WS = m_pWorkspace;
+
     while (curr != this) {
         curr->m_iMonitorID = m_iMonitorID;
-        curr->moveToWorkspace(m_iWorkspaceID);
+        curr->moveToWorkspace(WS);
 
-        curr->m_vRealPosition = m_vRealPosition.goalv();
-        curr->m_vRealSize     = m_vRealSize.goalv();
+        curr->m_vRealPosition = m_vRealPosition.goal();
+        curr->m_vRealSize     = m_vRealSize.goal();
 
         curr = curr->m_sGroupData.pNextWindow;
     }
 }
 
 Vector2D CWindow::middle() {
-    return m_vRealPosition.goalv() + m_vRealSize.goalv() / 2.f;
+    return m_vRealPosition.goal() + m_vRealSize.goal() / 2.f;
 }
 
 bool CWindow::opaque() {
-    if (m_fAlpha.fl() != 1.f || m_fActiveInactiveAlpha.fl() != 1.f)
+    if (m_fAlpha.value() != 1.f || m_fActiveInactiveAlpha.value() != 1.f)
         return false;
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
+    if (m_vRealSize.goal().floor() != m_vReportedSize)
+        return false;
+
+    const auto PWORKSPACE = m_pWorkspace;
 
     if (m_pWLSurface.small() && !m_pWLSurface.m_bFillIgnoreSmall)
         return false;
 
-    if (PWORKSPACE->m_fAlpha.fl() != 1.f)
+    if (PWORKSPACE->m_fAlpha.value() != 1.f)
         return false;
 
     if (m_bIsX11)
@@ -1023,7 +1108,7 @@ bool CWindow::opaque() {
 }
 
 float CWindow::rounding() {
-    static auto* const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
+    static auto PROUNDING = CConfigValue<Hyprlang::INT>("decoration:rounding");
 
     float       rounding = m_sAdditionalConfigData.rounding.toUnderlying() == -1 ? *PROUNDING : m_sAdditionalConfigData.rounding.toUnderlying();
 
@@ -1031,18 +1116,23 @@ float CWindow::rounding() {
 }
 
 void CWindow::updateSpecialRenderData() {
-    const auto PWORKSPACE    = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
+    const auto PWORKSPACE    = m_pWorkspace;
     const auto WORKSPACERULE = PWORKSPACE ? g_pConfigManager->getWorkspaceRuleFor(PWORKSPACE) : SWorkspaceRule{};
-    bool       border        = true;
+    updateSpecialRenderData(WORKSPACERULE);
+}
 
-    if (m_bIsFloating && g_pConfigManager->getConfigValuePtr("general:no_border_on_floating")->intValue == 1)
+void CWindow::updateSpecialRenderData(const SWorkspaceRule& workspaceRule) {
+    static auto PNOBORDERONFLOATING = CConfigValue<Hyprlang::INT>("general:no_border_on_floating");
+
+    bool        border = true;
+    if (m_bIsFloating && *PNOBORDERONFLOATING == 1)
         border = false;
 
-    m_sSpecialRenderData.border     = WORKSPACERULE.border.value_or(border);
-    m_sSpecialRenderData.borderSize = WORKSPACERULE.borderSize.value_or(-1);
-    m_sSpecialRenderData.decorate   = WORKSPACERULE.decorate.value_or(true);
-    m_sSpecialRenderData.rounding   = WORKSPACERULE.rounding.value_or(true);
-    m_sSpecialRenderData.shadow     = WORKSPACERULE.shadow.value_or(true);
+    m_sSpecialRenderData.border     = workspaceRule.border.value_or(border);
+    m_sSpecialRenderData.borderSize = workspaceRule.borderSize.value_or(-1);
+    m_sSpecialRenderData.decorate   = workspaceRule.decorate.value_or(true);
+    m_sSpecialRenderData.rounding   = workspaceRule.rounding.value_or(true);
+    m_sSpecialRenderData.shadow     = workspaceRule.shadow.value_or(true);
 }
 
 int CWindow::getRealBorderSize() {
@@ -1055,7 +1145,9 @@ int CWindow::getRealBorderSize() {
     if (m_sSpecialRenderData.borderSize.toUnderlying() != -1)
         return m_sSpecialRenderData.borderSize.toUnderlying();
 
-    return g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+    static auto PBORDERSIZE = CConfigValue<Hyprlang::INT>("general:border_size");
+
+    return *PBORDERSIZE;
 }
 
 bool CWindow::canBeTorn() {
@@ -1063,8 +1155,8 @@ bool CWindow::canBeTorn() {
 }
 
 bool CWindow::shouldSendFullscreenState() {
-    const auto MODE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID)->m_efFullscreenMode;
-    return m_bFakeFullscreenState || (m_bIsFullscreen && (MODE == FULLSCREEN_FULL));
+    const auto MODE = m_pWorkspace->m_efFullscreenMode;
+    return m_bDontSendFullscreen ? false : (m_bFakeFullscreenState || (m_bIsFullscreen && (MODE == FULLSCREEN_FULL)));
 }
 
 void CWindow::setSuspended(bool suspend) {
@@ -1077,3 +1169,72 @@ void CWindow::setSuspended(bool suspend) {
     wlr_xdg_toplevel_set_suspended(m_uSurface.xdg->toplevel, suspend);
     m_bSuspended = suspend;
 }
+
+bool CWindow::visibleOnMonitor(CMonitor* pMonitor) {
+    CBox wbox = {m_vRealPosition.value(), m_vRealSize.value()};
+
+    return wlr_output_layout_intersects(g_pCompositor->m_sWLROutputLayout, pMonitor->output, wbox.pWlr());
+}
+
+void CWindow::setAnimationsToMove() {
+    auto* const PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
+    m_vRealPosition.setConfig(PANIMCFG);
+    m_vRealSize.setConfig(PANIMCFG);
+    m_bAnimatingIn = false;
+}
+
+void CWindow::onWorkspaceAnimUpdate() {
+    // clip box for animated offsets
+    if (!m_bIsFloating || m_bPinned || m_bIsFullscreen) {
+        m_vFloatingOffset = Vector2D(0, 0);
+        return;
+    }
+
+    Vector2D   offset;
+    const auto PWORKSPACE = m_pWorkspace;
+    if (!PWORKSPACE)
+        return;
+
+    const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+    if (!PWSMON)
+        return;
+
+    const auto WINBB = getFullWindowBoundingBox();
+    if (PWORKSPACE->m_vRenderOffset.value().x != 0) {
+        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.value().x / PWSMON->vecSize.x;
+
+        if (WINBB.x < PWSMON->vecPosition.x)
+            offset.x += (PWSMON->vecPosition.x - WINBB.x) * PROGRESS;
+
+        if (WINBB.x + WINBB.width > PWSMON->vecPosition.x + PWSMON->vecSize.x)
+            offset.x += (WINBB.x + WINBB.width - PWSMON->vecPosition.x - PWSMON->vecSize.x) * PROGRESS;
+    } else if (PWORKSPACE->m_vRenderOffset.value().y != 0) {
+        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.value().y / PWSMON->vecSize.y;
+
+        if (WINBB.y < PWSMON->vecPosition.y)
+            offset.y += (PWSMON->vecPosition.y - WINBB.y) * PROGRESS;
+
+        if (WINBB.y + WINBB.height > PWSMON->vecPosition.y + PWSMON->vecSize.y)
+            offset.y += (WINBB.y + WINBB.height - PWSMON->vecPosition.y - PWSMON->vecSize.y) * PROGRESS;
+    }
+
+    m_vFloatingOffset = offset;
+}
+
+int CWindow::popupsCount() {
+    if (m_bIsX11)
+        return 1;
+
+    int no = 0;
+    wlr_xdg_surface_for_each_popup_surface(
+        m_uSurface.xdg, [](wlr_surface* s, int x, int y, void* data) { *(int*)data += 1; }, &no);
+    return no;
+}
+
+int CWindow::workspaceID() {
+    return m_pWorkspace ? m_pWorkspace->m_iID : m_iLastWorkspace;
+}
+
+bool CWindow::onSpecialWorkspace() {
+    return m_pWorkspace ? m_pWorkspace->m_bIsSpecialWorkspace : g_pCompositor->isWorkspaceSpecial(m_iLastWorkspace);
+}

src/desktop/Window.hpp

@@ -1,15 +1,17 @@
 #pragma once
 
-#include "defines.hpp"
-#include "helpers/SubsurfaceTree.hpp"
-#include "helpers/AnimatedVariable.hpp"
-#include "render/decorations/IHyprWindowDecoration.hpp"
+#include "../defines.hpp"
+#include "Subsurface.hpp"
+#include "../helpers/AnimatedVariable.hpp"
+#include "../render/decorations/IHyprWindowDecoration.hpp"
 #include <deque>
-#include "config/ConfigDataValues.hpp"
-#include "helpers/Vector2D.hpp"
-#include "helpers/WLSurface.hpp"
-#include "macros.hpp"
-#include "managers/XWaylandManager.hpp"
+#include "../config/ConfigDataValues.hpp"
+#include "../helpers/Vector2D.hpp"
+#include "WLSurface.hpp"
+#include "Popup.hpp"
+#include "../macros.hpp"
+#include "../managers/XWaylandManager.hpp"
+#include "DesktopTypes.hpp"
 
 enum eIdleInhibitMode {
     IDLEINHIBIT_NONE = 0,
@@ -37,7 +39,15 @@ enum eGetWindowProperties {
     FULL_EXTENTS     = 1 << 2,
     FLOATING_ONLY    = 1 << 3,
     ALLOW_FLOATING   = 1 << 4,
-    USE_PROP_TILED   = 1 << 5
+    USE_PROP_TILED   = 1 << 5,
+};
+
+enum eSuppressEvents {
+    SUPPRESS_NONE               = 0,
+    SUPPRESS_FULLSCREEN         = 1 << 0,
+    SUPPRESS_MAXIMIZE           = 1 << 1,
+    SUPPRESS_ACTIVATE           = 1 << 2,
+    SUPPRESS_ACTIVATE_FOCUSONLY = 1 << 3,
 };
 
 class IWindowTransformer;
@@ -120,6 +130,8 @@ struct SWindowSpecialRenderData {
     CWindowOverridableVar<float>              alpha                   = 1.f;
     CWindowOverridableVar<bool>               alphaInactiveOverride   = false;
     CWindowOverridableVar<float>              alphaInactive           = -1.f; // -1 means unset
+    CWindowOverridableVar<bool>               alphaFullscreenOverride = false;
+    CWindowOverridableVar<float>              alphaFullscreen         = -1.f; // -1 means unset
 
     CWindowOverridableVar<CGradientValueData> activeBorderColor   = CGradientValueData(); // empty color vector means unset
     CWindowOverridableVar<CGradientValueData> inactiveBorderColor = CGradientValueData(); // empty color vector means unset
@@ -143,8 +155,11 @@ struct SWindowAdditionalConfigData {
     CWindowOverridableVar<bool>     forceNoBorder         = false;
     CWindowOverridableVar<bool>     forceNoShadow         = false;
     CWindowOverridableVar<bool>     forceNoDim            = false;
+    CWindowOverridableVar<bool>     noFocus               = false;
     CWindowOverridableVar<bool>     windowDanceCompat     = false;
     CWindowOverridableVar<bool>     noMaxSize             = false;
+    CWindowOverridableVar<Vector2D> maxSize               = Vector2D(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
+    CWindowOverridableVar<Vector2D> minSize               = Vector2D(20, 20);
     CWindowOverridableVar<bool>     dimAround             = false;
     CWindowOverridableVar<bool>     forceRGBX             = false;
     CWindowOverridableVar<bool>     keepAspectRatio       = false;
@@ -168,7 +183,7 @@ struct SWindowRule {
     int         bFullscreen   = -1;
     int         bPinned       = -1;
     int         bFocus        = -1;
-    int         iOnWorkspace = -1;
+    std::string szOnWorkspace = ""; // empty means any
     std::string szWorkspace   = ""; // empty means any
 };
 
@@ -184,7 +199,6 @@ class CWindow {
     DYNLISTENER(setTitleWindow);
     DYNLISTENER(setGeometryX11U);
     DYNLISTENER(fullscreenWindow);
-    DYNLISTENER(newPopupXDG);
     DYNLISTENER(requestMove);
     DYNLISTENER(requestMinimize);
     DYNLISTENER(requestMaximize);
@@ -201,7 +215,6 @@ class CWindow {
     // DYNLISTENER(newSubsurfaceWindow);
 
     CWLSurface m_pWLSurface;
-    std::list<CWLSurface> m_lPopupSurfaces;
 
     union {
         wlr_xdg_surface*      xdg;
@@ -213,8 +226,8 @@ class CWindow {
     Vector2D m_vSize     = Vector2D(0, 0);
 
     // this is the real position and size used to draw the thing
-    CAnimatedVariable m_vRealPosition;
-    CAnimatedVariable m_vRealSize;
+    CAnimatedVariable<Vector2D> m_vRealPosition;
+    CAnimatedVariable<Vector2D> m_vRealSize;
 
     // for not spamming the protocols
     Vector2D                                     m_vReportedPosition;
@@ -227,6 +240,9 @@ class CWindow {
     Vector2D m_vLastFloatingSize;
     Vector2D m_vLastFloatingPosition;
 
+    // for floating window offset in workspace animations
+    Vector2D m_vFloatingOffset = Vector2D(0, 0);
+
     // this is used for pseudotiling
     bool         m_bIsPseudotiled = false;
     Vector2D     m_vPseudoSize    = Vector2D(0, 0);
@@ -235,12 +251,13 @@ class CWindow {
     bool         m_bIsFloating         = false;
     bool         m_bDraggingTiled      = false; // for dragging around tiled windows
     bool         m_bIsFullscreen       = false;
+    bool         m_bDontSendFullscreen = false;
     bool         m_bWasMaximized       = false;
     uint64_t     m_iMonitorID          = -1;
     std::string  m_szTitle             = "";
     std::string  m_szInitialTitle      = "";
     std::string  m_szInitialClass      = "";
-    int         m_iWorkspaceID   = -1;
+    PHLWORKSPACE m_pWorkspace;
 
     bool         m_bIsMapped = false;
 
@@ -260,29 +277,32 @@ class CWindow {
     //
 
     // For nofocus
-    bool m_bNoFocus        = false;
     bool m_bNoInitialFocus = false;
 
     // Fullscreen and Maximize
     bool m_bWantsInitialFullscreen = false;
-    bool              m_bNoFullscreenRequest    = false;
-    bool              m_bNoMaximizeRequest      = false;
 
-    SSurfaceTreeNode* m_pSurfaceTree = nullptr;
+    // bitfield eSuppressEvents
+    uint64_t m_eSuppressedEvents = SUPPRESS_NONE;
+
+    // desktop components
+    std::unique_ptr<CSubsurface> m_pSubsurfaceHead;
+    std::unique_ptr<CPopup>      m_pPopupHead;
 
     // Animated border
     CGradientValueData       m_cRealBorderColor         = {0};
     CGradientValueData       m_cRealBorderColorPrevious = {0};
-    CAnimatedVariable  m_fBorderFadeAnimationProgress;
-    CAnimatedVariable  m_fBorderAngleAnimationProgress;
+    CAnimatedVariable<float> m_fBorderFadeAnimationProgress;
+    CAnimatedVariable<float> m_fBorderAngleAnimationProgress;
 
     // Fade in-out
-    CAnimatedVariable        m_fAlpha;
+    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
     SWindowDecorationExtents m_eOriginalClosedExtents;
+    bool                     m_bAnimatingIn = false;
 
     // For pinned (sticky) windows
     bool m_bPinned = false;
@@ -311,13 +331,13 @@ class CWindow {
     std::vector<std::unique_ptr<IWindowTransformer>> m_vTransformers;
 
     // for alpha
-    CAnimatedVariable m_fActiveInactiveAlpha;
+    CAnimatedVariable<float> m_fActiveInactiveAlpha;
 
     // animated shadow color
-    CAnimatedVariable m_cRealShadowColor;
+    CAnimatedVariable<CColor> m_cRealShadowColor;
 
     // animated tint
-    CAnimatedVariable m_fDimPercent;
+    CAnimatedVariable<float> m_fDimPercent;
 
     // swallowing
     CWindow* m_pSwallowed = nullptr;
@@ -367,7 +387,7 @@ class CWindow {
     void                     destroyToplevelHandle();
     void                     updateToplevel();
     void                     updateSurfaceScaleTransformDetails();
-    void                     moveToWorkspace(int);
+    void                     moveToWorkspace(PHLWORKSPACE);
     CWindow*                 X11TransientFor();
     void                     onUnmap();
     void                     onMap();
@@ -382,13 +402,18 @@ class CWindow {
     bool                     canBeTorn();
     bool                     shouldSendFullscreenState();
     void                     setSuspended(bool suspend);
+    bool                     visibleOnMonitor(CMonitor* pMonitor);
+    int                      workspaceID();
+    bool                     onSpecialWorkspace();
 
     int                      getRealBorderSize();
     void                     updateSpecialRenderData();
+    void                     updateSpecialRenderData(const struct SWorkspaceRule&);
 
     void                     onBorderAngleAnimEnd(void* ptr);
     bool                     isInCurvedCorner(double x, double y);
     bool                     hasPopupAt(const Vector2D& pos);
+    int                      popupsCount();
 
     void                     applyGroupRules();
     void                     createGroup();
@@ -404,11 +429,14 @@ class CWindow {
     void                     insertWindowToGroup(CWindow* pWindow);
     void                     updateGroupOutputs();
     void                     switchWithWindowInGroup(CWindow* pWindow);
+    void                     setAnimationsToMove();
+    void                     onWorkspaceAnimUpdate();
 
   private:
     // For hidden windows and stuff
     bool m_bHidden        = false;
     bool m_bSuspended     = false;
+    int  m_iLastWorkspace = WORKSPACE_INVALID;
 };
 
 /**
@@ -443,7 +471,7 @@ struct std::formatter<CWindow*, CharT> : std::formatter<CharT> {
         std::format_to(out, "[");
         std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w, w->m_szTitle);
         if (formatWorkspace)
-            std::format_to(out, ", workspace: {}", w->m_iWorkspaceID);
+            std::format_to(out, ", workspace: {}", w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID);
         if (formatMonitor)
             std::format_to(out, ", monitor: {}", w->m_iMonitorID);
         if (formatClass)

src/desktop/Workspace.cpp

@@ -0,0 +1,456 @@
+#include "Workspace.hpp"
+#include "../Compositor.hpp"
+#include "../config/ConfigValue.hpp"
+
+PHLWORKSPACE CWorkspace::create(int id, int monitorID, std::string name, bool special) {
+    PHLWORKSPACE workspace = std::make_shared<CWorkspace>(id, monitorID, name, special);
+    workspace->init(workspace);
+    return workspace;
+}
+
+CWorkspace::CWorkspace(int id, int monitorID, std::string name, bool special) {
+    m_iMonitorID          = monitorID;
+    m_iID                 = id;
+    m_szName              = name;
+    m_bIsSpecialWorkspace = special;
+}
+
+void CWorkspace::init(PHLWORKSPACE self) {
+    m_pSelf = self;
+
+    m_vRenderOffset.create(m_bIsSpecialWorkspace ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"),
+                           self, AVARDAMAGE_ENTIRE);
+    m_fAlpha.create(AVARTYPE_FLOAT,
+                    m_bIsSpecialWorkspace ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"), 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())
+        m_szName = RULEFORTHIS.defaultName.value();
+
+    m_pFocusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
+        const auto PWINDOW = std::any_cast<CWindow*>(param);
+
+        if (PWINDOW == m_pLastFocusedWindow)
+            m_pLastFocusedWindow = nullptr;
+    });
+
+    m_bInert = false;
+
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(self);
+    m_bPersistent            = WORKSPACERULE.isPersistent;
+
+    if (auto cmd = WORKSPACERULE.onCreatedEmptyRunCmd)
+        g_pKeybindManager->spawn(*cmd);
+
+    g_pEventManager->postEvent({"createworkspace", m_szName});
+    g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_iID, m_szName)});
+    EMIT_HOOK_EVENT("createWorkspace", this);
+}
+
+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.
+    if (g_pHookSystem)
+        g_pHookSystem->unhook(m_pFocusedWindowHook);
+
+    if (g_pEventManager) {
+        g_pEventManager->postEvent({"destroyworkspace", m_szName});
+        g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_iID, m_szName)});
+        EMIT_HOOK_EVENT("destroyWorkspace", this);
+    }
+}
+
+void CWorkspace::startAnim(bool in, bool left, bool instant) {
+    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([&](void*) {
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (!g_pCompositor->windowValidMapped(w.get()) || w->workspaceID() != m_iID)
+                continue;
+
+            w->onWorkspaceAnimUpdate();
+        };
+    });
+
+    if (ANIMSTYLE.starts_with("slidefade")) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        float      movePerc = 100.f;
+
+        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));
+
+        if (ANIMSTYLE.starts_with("slidefadevert")) {
+            if (in) {
+                m_fAlpha.setValueAndWarp(0.f);
+                m_vRenderOffset.setValueAndWarp(Vector2D(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, (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));
+                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);
+            }
+        }
+    } else if (ANIMSTYLE == "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;
+        } else {
+            m_fAlpha.setValueAndWarp(1.f);
+            m_fAlpha = 0.f;
+        }
+    } else if (ANIMSTYLE == "slidevert") {
+        // fallback is slide
+        const auto PMONITOR  = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
+
+        m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+
+        if (in) {
+            m_vRenderOffset.setValueAndWarp(Vector2D(0, left ? YDISTANCE : -YDISTANCE));
+            m_vRenderOffset = Vector2D(0, 0);
+        } else {
+            m_vRenderOffset = Vector2D(0, left ? -YDISTANCE : YDISTANCE);
+        }
+    } else {
+        // fallback is slide
+        const auto PMONITOR  = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
+
+        m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+
+        if (in) {
+            m_vRenderOffset.setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0));
+            m_vRenderOffset = Vector2D(0, 0);
+        } else {
+            m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0);
+        }
+    }
+
+    if (m_bIsSpecialWorkspace) {
+        // required for open/close animations
+        if (in) {
+            m_fAlpha.setValueAndWarp(0.f);
+            m_fAlpha = 1.f;
+        } else {
+            m_fAlpha.setValueAndWarp(1.f);
+            m_fAlpha = 0.f;
+        }
+    }
+
+    if (instant) {
+        m_vRenderOffset.warp();
+        m_fAlpha.warp();
+    }
+}
+
+void CWorkspace::setActive(bool on) {
+    ; // empty until https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/40
+}
+
+void CWorkspace::moveToMonitor(const int& id) {
+    ; // empty until https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/40
+}
+
+CWindow* CWorkspace::getLastFocusedWindow() {
+    if (!g_pCompositor->windowValidMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow->workspaceID() != m_iID)
+        return nullptr;
+
+    return m_pLastFocusedWindow;
+}
+
+void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
+    if (!prev) {
+        m_sPrevWorkspace.iID  = -1;
+        m_sPrevWorkspace.name = "";
+        return;
+    }
+
+    if (prev->m_iID == m_iID) {
+        Debug::log(LOG, "Tried to set prev workspace to the same as current one");
+        return;
+    }
+
+    m_sPrevWorkspace.iID  = prev->m_iID;
+    m_sPrevWorkspace.name = prev->m_szName;
+}
+
+std::string CWorkspace::getConfigName() {
+    if (m_bIsSpecialWorkspace) {
+        return "special:" + m_szName;
+    }
+
+    if (m_iID > 0)
+        return std::to_string(m_iID);
+
+    return "name:" + m_szName;
+}
+
+bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
+    auto selector = removeBeginEndSpacesTabs(selector_);
+
+    if (selector.empty())
+        return true;
+
+    if (isNumber(selector)) {
+
+        std::string wsname = "";
+        int         wsid   = getWorkspaceIDFromString(selector, wsname);
+
+        if (wsid == WORKSPACE_INVALID)
+            return false;
+
+        return wsid == m_iID;
+
+    } else if (selector.starts_with("name:")) {
+        return m_szName == selector.substr(5);
+    } else if (selector.starts_with("special")) {
+        return m_szName == selector;
+    } else {
+        // parse selector
+
+        for (size_t i = 0; i < selector.length(); ++i) {
+            const char& cur = selector[i];
+            if (std::isspace(cur))
+                continue;
+
+            // Allowed selectors:
+            // r - range: r[1-5]
+            // s - special: s[true]
+            // 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 g to count groups instead of windows, e.g. w[t1-2], w[fg4]
+
+            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') {
+                int from = 0, to = 0;
+                if (!prop.starts_with("r[") || !prop.ends_with("]")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                prop = prop.substr(2, prop.length() - 3);
+
+                if (!prop.contains("-")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                const auto DASHPOS = prop.find("-");
+                const auto LHS = prop.substr(0, DASHPOS), RHS = prop.substr(DASHPOS + 1);
+
+                if (!isNumber(LHS) || !isNumber(RHS)) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                try {
+                    from = std::stoll(LHS);
+                    to   = std::stoll(RHS);
+                } catch (std::exception& e) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                if (to < from || to < 1 || from < 1) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                if (std::clamp(m_iID, from, to) != m_iID)
+                    return false;
+                continue;
+            }
+
+            if (cur == 's') {
+                if (!prop.starts_with("s[") || !prop.ends_with("]")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                prop = prop.substr(2, prop.length() - 3);
+
+                const auto SHOULDBESPECIAL = configStringToInt(prop);
+
+                if ((bool)SHOULDBESPECIAL != m_bIsSpecialWorkspace)
+                    return false;
+                continue;
+            }
+
+            if (cur == 'm') {
+                if (!prop.starts_with("m[") || !prop.ends_with("]")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                prop = prop.substr(2, prop.length() - 3);
+
+                const auto PMONITOR = g_pCompositor->getMonitorFromString(prop);
+
+                if (!(PMONITOR ? PMONITOR->ID == m_iMonitorID : false))
+                    return false;
+                continue;
+            }
+
+            if (cur == 'n') {
+                if (!prop.starts_with("n[") || !prop.ends_with("]")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                prop = prop.substr(2, prop.length() - 3);
+
+                if (prop.starts_with("s:") && !m_szName.starts_with(prop.substr(2)))
+                    return false;
+                if (prop.starts_with("e:") && !m_szName.ends_with(prop.substr(2)))
+                    return false;
+
+                const auto WANTSNAMED = configStringToInt(prop);
+
+                if (WANTSNAMED != (m_iID <= -1337))
+                    return false;
+                continue;
+            }
+
+            if (cur == 'w') {
+                int from = 0, to = 0;
+                if (!prop.starts_with("w[") || !prop.ends_with("]")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                prop = prop.substr(2, prop.length() - 3);
+
+                int  wantsOnlyTiled  = -1;
+                bool wantsCountGroup = false;
+
+                int  flagCount = 0;
+                for (auto& flag : prop) {
+                    if (flag == 't' && wantsOnlyTiled == -1) {
+                        wantsOnlyTiled = 1;
+                        flagCount++;
+                    } else if (flag == 'f' && wantsOnlyTiled == -1) {
+                        wantsOnlyTiled = 0;
+                        flagCount++;
+                    } else if (flag == 'g' && !wantsCountGroup) {
+                        wantsCountGroup = true;
+                        flagCount++;
+                    } else {
+                        break;
+                    }
+                }
+                prop = prop.substr(flagCount);
+
+                if (!prop.contains("-")) {
+                    // try single
+
+                    if (!isNumber(prop)) {
+                        Debug::log(LOG, "Invalid selector {}", selector);
+                        return false;
+                    }
+
+                    try {
+                        from = std::stoll(prop);
+                    } catch (std::exception& e) {
+                        Debug::log(LOG, "Invalid selector {}", selector);
+                        return false;
+                    }
+
+                    int count;
+                    if (wantsCountGroup)
+                        count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+                    else
+                        count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+
+                    if (count != from)
+                        return false;
+                    continue;
+                }
+
+                const auto DASHPOS = prop.find("-");
+                const auto LHS = prop.substr(0, DASHPOS), RHS = prop.substr(DASHPOS + 1);
+
+                if (!isNumber(LHS) || !isNumber(RHS)) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                try {
+                    from = std::stoll(LHS);
+                    to   = std::stoll(RHS);
+                } catch (std::exception& e) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                if (to < from || to < 1 || from < 1) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                int count;
+                if (wantsCountGroup)
+                    count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+                else
+                    count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+
+                if (std::clamp(count, from, to) != count)
+                    return false;
+                continue;
+            }
+
+            Debug::log(LOG, "Invalid selector {}", selector);
+            return false;
+        }
+
+        return true;
+    }
+
+    UNREACHABLE();
+    return false;
+}
+
+void CWorkspace::markInert() {
+    m_bInert     = true;
+    m_iID        = WORKSPACE_INVALID;
+    m_iMonitorID = -1;
+    m_bVisible   = false;
+}
+
+bool CWorkspace::inert() {
+    return m_bInert;
+}

src/desktop/Workspace.hpp

@@ -1,8 +1,9 @@
 #pragma once
 
-#include "AnimatedVariable.hpp"
+#include "../helpers/AnimatedVariable.hpp"
 #include <string>
 #include "../defines.hpp"
+#include "DesktopTypes.hpp"
 
 enum eFullscreenMode : int8_t {
     FULLSCREEN_INVALID = -1,
@@ -14,7 +15,9 @@ class CWindow;
 
 class CWorkspace {
   public:
-    CWorkspace(int monitorID, std::string name, bool special = false);
+    static PHLWORKSPACE create(int id, int monitorID, std::string name, bool special = false);
+    // use create() don't use this
+    CWorkspace(int id, int monitorID, std::string name, bool special = false);
     ~CWorkspace();
 
     // Workspaces ID-based have IDs > 0
@@ -35,10 +38,13 @@ class CWorkspace {
     wl_array        m_wlrCoordinateArr;
 
     // for animations
-    CAnimatedVariable m_vRenderOffset;
-    CAnimatedVariable m_fAlpha;
+    CAnimatedVariable<Vector2D> m_vRenderOffset;
+    CAnimatedVariable<float>    m_fAlpha;
     bool                        m_bForceRendering = false;
 
+    // allows damage to propagate.
+    bool m_bVisible = false;
+
     // "scratchpad"
     bool m_bIsSpecialWorkspace = false;
 
@@ -52,8 +58,10 @@ class CWorkspace {
     // last monitor (used on reconnect)
     std::string m_szLastMonitor = "";
 
-    // Whether the user configured command for on-created-empty has been executed, if any
-    bool        m_bOnCreatedEmptyExecuted = false;
+    bool        m_bPersistent = false;
+
+    // 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);
@@ -61,7 +69,25 @@ class CWorkspace {
     void        moveToMonitor(const int&);
 
     CWindow*    getLastFocusedWindow();
-    void        rememberPrevWorkspace(const CWorkspace* prevWorkspace);
+    void        rememberPrevWorkspace(const PHLWORKSPACE& prevWorkspace);
 
     std::string getConfigName();
+
+    bool        matchesStaticSelector(const std::string& selector);
+
+    void        markInert();
+
+  private:
+    void                      init(PHLWORKSPACE self);
+
+    HOOK_CALLBACK_FN*         m_pFocusedWindowHook = nullptr;
+    bool                      m_bInert             = true;
+    std::weak_ptr<CWorkspace> m_pSelf;
 };
+
+inline bool valid(const PHLWORKSPACE& ref) {
+    if (!ref)
+        return false;
+
+    return !ref->inert();
+}

src/events/Devices.cpp

@@ -74,7 +74,7 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
             Debug::log(LOG, "Attached a touch device with name {}", DEVICE->name);
             g_pInputManager->newTouchDevice(DEVICE);
             break;
-        case WLR_INPUT_DEVICE_TABLET_TOOL:
+        case WLR_INPUT_DEVICE_TABLET:
             Debug::log(LOG, "Attached a tablet tool with name {}", DEVICE->name);
             g_pInputManager->newTabletTool(DEVICE);
             break;
@@ -97,44 +97,14 @@ void Events::listener_newConstraint(wl_listener* listener, void* data) {
 
     Debug::log(LOG, "New mouse constraint at {:x}", (uintptr_t)PCONSTRAINT);
 
-    g_pInputManager->m_lConstraints.emplace_back();
-    const auto CONSTRAINT = &g_pInputManager->m_lConstraints.back();
+    const auto SURFACE = CWLSurface::surfaceFromWlr(PCONSTRAINT->surface);
 
-    CONSTRAINT->pMouse     = g_pCompositor->m_sSeat.mouse;
-    CONSTRAINT->constraint = PCONSTRAINT;
-
-    CONSTRAINT->hyprListener_destroyConstraint.initCallback(&PCONSTRAINT->events.destroy, &Events::listener_destroyConstraint, CONSTRAINT, "Constraint");
-    CONSTRAINT->hyprListener_setConstraintRegion.initCallback(&PCONSTRAINT->events.set_region, &Events::listener_setConstraintRegion, CONSTRAINT, "Constraint");
-
-    if (g_pCompositor->m_pLastFocus == PCONSTRAINT->surface) {
-        g_pInputManager->constrainMouse(CONSTRAINT->pMouse, PCONSTRAINT);
-
-        if (!CONSTRAINT->hintSet)
-            CONSTRAINT->positionHint = Vector2D{-1, -1};
-    }
-}
-
-void Events::listener_destroyConstraint(void* owner, void* data) {
-    const auto PCONSTRAINT = (SConstraint*)owner;
-
-    if (PCONSTRAINT->pMouse->currentConstraint == PCONSTRAINT->constraint) {
-        PCONSTRAINT->pMouse->hyprListener_commitConstraint.removeCallback();
-
-        const auto PWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
-
-        if (PWINDOW && PCONSTRAINT->active && PCONSTRAINT->constraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED)
-            g_pInputManager->warpMouseToConstraintMiddle(PCONSTRAINT);
-
-        PCONSTRAINT->pMouse->currentConstraint = nullptr;
+    if (!SURFACE) {
+        Debug::log(ERR, "Refusing a constraint from an unassigned wl_surface {:x}", (uintptr_t)PCONSTRAINT->surface);
+        return;
     }
 
-    Debug::log(LOG, "Unconstrained mouse from {:x}", (uintptr_t)PCONSTRAINT->constraint);
-
-    g_pInputManager->m_lConstraints.remove(*PCONSTRAINT);
-}
-
-void Events::listener_setConstraintRegion(void* owner, void* data) {
-    // no
+    SURFACE->appendConstraint(PCONSTRAINT);
 }
 
 void Events::listener_newVirtPtr(wl_listener* listener, void* data) {

src/events/Events.hpp

@@ -22,25 +22,6 @@ namespace Events {
     DYNLISTENFUNC(unmapLayerSurface);
     DYNLISTENFUNC(commitLayerSurface);
 
-    // Subsurfaces
-    DYNLISTENFUNC(newSubsurfaceNode);
-    DYNLISTENFUNC(destroySubsurfaceNode);
-    DYNLISTENFUNC(mapSubsurface);
-    DYNLISTENFUNC(unmapSubsurface);
-    DYNLISTENFUNC(destroySubsurface);
-    DYNLISTENFUNC(commitSubsurface);
-
-    // Popups
-    DYNLISTENFUNC(newPopup); // LayerSurface
-
-    DYNLISTENFUNC(newPopupXDG);
-    DYNLISTENFUNC(mapPopupXDG);
-    DYNLISTENFUNC(unmapPopupXDG);
-    DYNLISTENFUNC(destroyPopupXDG);
-    DYNLISTENFUNC(commitPopupXDG);
-    DYNLISTENFUNC(newPopupFromPopupXDG);
-    DYNLISTENFUNC(repositionPopupXDG);
-
     // Surface XDG (window)
     LISTENER(newXDGToplevel);
     LISTENER(activateXDG);
@@ -84,10 +65,7 @@ namespace Events {
     DYNLISTENFUNC(keyboardMod);
     DYNLISTENFUNC(keyboardDestroy);
 
-    DYNLISTENFUNC(commitConstraint);
     LISTENER(newConstraint);
-    DYNLISTENFUNC(setConstraintRegion);
-    DYNLISTENFUNC(destroyConstraint);
 
     // Various
     LISTENER(requestMouse);
@@ -148,12 +126,6 @@ namespace Events {
     LISTENER(newTextInput);
     LISTENER(newVirtualKeyboard);
 
-    // IME Popups
-    DYNLISTENFUNC(mapInputPopup);
-    DYNLISTENFUNC(unmapInputPopup);
-    DYNLISTENFUNC(commitInputPopup);
-    DYNLISTENFUNC(destroyInputPopup);
-
     // Touch
     LISTENER(touchBegin);
     LISTENER(touchEnd);
@@ -174,4 +146,7 @@ namespace Events {
 
     // Tearing hints
     LISTENER(newTearingHint);
+
+    // Shortcut inhibitor
+    LISTENER(newShortcutInhibitor);
 };

src/events/Layers.cpp

@@ -46,12 +46,12 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
     layerSurface->hyprListener_destroyLayerSurface.initCallback(&WLRLAYERSURFACE->events.destroy, &Events::listener_destroyLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_mapLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.map, &Events::listener_mapLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_unmapLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.unmap, &Events::listener_unmapLayerSurface, layerSurface, "layerSurface");
-    layerSurface->hyprListener_newPopup.initCallback(&WLRLAYERSURFACE->events.new_popup, &Events::listener_newPopup, layerSurface, "layerSurface");
 
     layerSurface->layerSurface = WLRLAYERSURFACE;
     layerSurface->layer        = WLRLAYERSURFACE->current.layer;
     WLRLAYERSURFACE->data      = layerSurface;
     layerSurface->monitorID    = PMONITOR->ID;
+    layerSurface->popupHead    = std::make_unique<CPopup>(layerSurface);
 
     layerSurface->forceBlur = g_pConfigManager->shouldBlurLS(layerSurface->szNamespace);
 
@@ -66,6 +66,8 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
 
+    layersurface->popupHead.reset();
+
     if (!g_pCompositor->getMonitorFromID(layersurface->monitorID))
         Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
 
@@ -87,7 +89,6 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
     layersurface->hyprListener_destroyLayerSurface.removeCallback();
     layersurface->hyprListener_mapLayerSurface.removeCallback();
     layersurface->hyprListener_unmapLayerSurface.removeCallback();
-    layersurface->hyprListener_newPopup.removeCallback();
 
     // rearrange to fix the reserved areas
     if (PMONITOR) {
@@ -113,9 +114,6 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     layersurface->keyboardExclusive = layersurface->layerSurface->current.keyboard_interactive;
     layersurface->surface           = layersurface->layerSurface->surface;
 
-    // anim
-    layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
-
     // fix if it changed its mon
     const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
 
@@ -147,15 +145,17 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
 
     const bool GRABSFOCUS = layersurface->layerSurface->current.keyboard_interactive != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
         // don't focus if constrained
-        (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint);
+        (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained());
 
     if (GRABSFOCUS) {
+        g_pInputManager->releaseAllMouseButtons();
         g_pCompositor->focusSurface(layersurface->layerSurface->surface);
 
         const auto LOCAL =
             g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
         wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layersurface->layerSurface->surface, LOCAL.x, LOCAL.y);
         wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
+        g_pInputManager->m_bEmptyFocusCursorSet = false;
     }
 
     layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
@@ -163,11 +163,10 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     CBox geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
                       layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
-    const auto WORKSPACE  = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+    const auto WORKSPACE  = PMONITOR->activeWorkspace;
     const bool FULLSCREEN = WORKSPACE->m_bHasFullscreenWindow && WORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL;
 
-    layersurface->alpha.setValue(0);
-    layersurface->alpha         = ((layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS) ? 0.f : 1.f);
+    layersurface->startAnimation(!(layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
     layersurface->readyToDelete = false;
     layersurface->fadingOut     = false;
 
@@ -198,23 +197,17 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
         layersurface->mapped = false;
 
-        layersurface->fadingOut = true;
-
-        layersurface->alpha.setValueAndWarp(0.f);
+        layersurface->startAnimation(false);
         return;
     }
 
-    // anim
-    layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
-
     // make a snapshot and start fade
     g_pHyprOpenGL->makeLayerSnapshot(layersurface);
-    layersurface->alpha = 0.f;
+
+    layersurface->startAnimation(false);
 
     layersurface->mapped = false;
 
-    layersurface->fadingOut = true;
-
     g_pCompositor->addToFadingOutSafe(layersurface);
 
     const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
@@ -244,7 +237,7 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
             foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
                                                                &surfaceCoords, &pFoundLayerSurface);
 
-        if (!foundSurface) {
+        if (!foundSurface && g_pCompositor->m_pLastWindow && g_pCompositor->isWorkspaceVisible(g_pCompositor->m_pLastWindow->m_pWorkspace)) {
             // if there isn't any, focus the last window
             const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
             g_pCompositor->focusWindow(nullptr);
@@ -335,8 +328,20 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
         }
     }
 
-    if (layersurface->layerSurface->current.keyboard_interactive &&
-        (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint) // don't focus if constrained
+    if (layersurface->realPosition.goal() != layersurface->geometry.pos()) {
+        if (layersurface->realPosition.isBeingAnimated())
+            layersurface->realPosition = layersurface->geometry.pos();
+        else
+            layersurface->realPosition.setValueAndWarp(layersurface->geometry.pos());
+    }
+    if (layersurface->realSize.goal() != layersurface->geometry.size()) {
+        if (layersurface->realSize.isBeingAnimated())
+            layersurface->realSize = layersurface->geometry.size();
+        else
+            layersurface->realSize.setValueAndWarp(layersurface->geometry.size());
+    }
+
+    if (layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained()) // don't focus if constrained
         && !layersurface->keyboardExclusive && layersurface->mapped) {
         g_pCompositor->focusSurface(layersurface->layerSurface->surface);
 
@@ -344,7 +349,8 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
             g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
         wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layersurface->layerSurface->surface, LOCAL.x, LOCAL.y);
         wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
-    } else if (!layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint) &&
+        g_pInputManager->m_bEmptyFocusCursorSet = false;
+    } else if (!layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained()) &&
                layersurface->keyboardExclusive) {
         g_pInputManager->refocus();
     }

src/events/Misc.cpp

@@ -4,6 +4,7 @@
 #include "../helpers/WLClasses.hpp"
 #include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
+#include "../managers/CursorManager.hpp"
 
 // ------------------------------ //
 //   __  __ _____  _____  _____   //
@@ -63,15 +64,26 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
         }
 
         ATOM.second = reply->atom;
+
+        free(reply);
     }
 
     wlr_xwayland_set_seat(g_pXWaylandManager->m_sWLRXWayland, g_pCompositor->m_sSeat.seat);
 
-    const auto XCURSOR = wlr_xcursor_manager_get_xcursor(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", 1);
-    if (XCURSOR) {
-        wlr_xwayland_set_cursor(g_pXWaylandManager->m_sWLRXWayland, XCURSOR->images[0]->buffer, XCURSOR->images[0]->width * 4, XCURSOR->images[0]->width,
-                                XCURSOR->images[0]->height, XCURSOR->images[0]->hotspot_x, XCURSOR->images[0]->hotspot_y);
-    }
+    g_pCursorManager->setXWaylandCursor(g_pXWaylandManager->m_sWLRXWayland);
+
+    const auto  ROOT   = xcb_setup_roots_iterator(xcb_get_setup(XCBCONNECTION)).data->root;
+    auto        cookie = xcb_get_property(XCBCONNECTION, 0, ROOT, HYPRATOMS["_NET_SUPPORTING_WM_CHECK"], XCB_ATOM_ANY, 0, 2048);
+    auto        reply  = xcb_get_property_reply(XCBCONNECTION, cookie, nullptr);
+
+    const auto  XWMWINDOW = *(xcb_window_t*)xcb_get_property_value(reply);
+    const char* name      = "Hyprland";
+
+    xcb_change_property(wlr_xwayland_get_xwm_connection(g_pXWaylandManager->m_sWLRXWayland), XCB_PROP_MODE_REPLACE, XWMWINDOW, HYPRATOMS["_NET_WM_NAME"], HYPRATOMS["UTF8_STRING"],
+                        8, // format
+                        strlen(name), name);
+
+    free(reply);
 
     xcb_disconnect(XCBCONNECTION);
 #endif
@@ -128,6 +140,8 @@ void Events::listener_destroyDrag(void* owner, void* data) {
     g_pInputManager->m_sDrag.drag     = nullptr;
     g_pInputManager->m_sDrag.dragIcon = nullptr;
     g_pInputManager->m_sDrag.hyprListener_destroy.removeCallback();
+
+    g_pCompositor->focusWindow(g_pCompositor->m_pLastWindow, g_pCompositor->m_pLastWindow ? g_pXWaylandManager->getWindowSurface(g_pCompositor->m_pLastWindow) : nullptr);
 }
 
 void Events::listener_mapDragIcon(void* owner, void* data) {
@@ -167,6 +181,7 @@ void Events::listener_sessionActive(wl_listener* listener, void* data) {
 
     for (auto& m : g_pCompositor->m_vMonitors) {
         g_pCompositor->scheduleFrameForMonitor(m.get());
+        g_pHyprRenderer->applyMonitorRule(m.get(), &m->activeMonitorRule, true);
     }
 
     g_pConfigManager->m_bWantsMonitorReload = true;
@@ -231,8 +246,6 @@ void Events::listener_setCursorShape(wl_listener* listener, void* data) {
 }
 
 void Events::listener_newTearingHint(wl_listener* listener, void* data) {
-    const auto TCTL = (wlr_tearing_control_v1*)data;
-
     Debug::log(LOG, "New tearing hint at {:x}", (uintptr_t)data);
 
     const auto NEWCTRL = g_pHyprRenderer->m_vTearingControllers.emplace_back(std::make_unique<STearingController>()).get();
@@ -262,3 +275,20 @@ void Events::listener_newTearingHint(wl_listener* listener, void* data) {
         },
         NEWCTRL, "TearingController");
 }
+
+void Events::listener_newShortcutInhibitor(wl_listener* listener, void* data) {
+    const auto INHIBITOR = (wlr_keyboard_shortcuts_inhibitor_v1*)data;
+
+    const auto PINH = &g_pKeybindManager->m_lShortcutInhibitors.emplace_back();
+    PINH->hyprListener_destroy.initCallback(
+        &INHIBITOR->events.destroy,
+        [](void* owner, void* data) {
+            const auto OWNER = (SShortcutInhibitor*)owner;
+            g_pKeybindManager->m_lShortcutInhibitors.remove(*OWNER);
+        },
+        PINH, "ShortcutInhibitor");
+
+    PINH->pWlrInhibitor = INHIBITOR;
+
+    Debug::log(LOG, "New shortcut inhibitor for surface {:x}", (uintptr_t)INHIBITOR->surface);
+}

src/events/Monitors.cpp

@@ -4,6 +4,7 @@
 #include "../render/Renderer.hpp"
 #include "Events.hpp"
 #include "../debug/HyprCtl.hpp"
+#include "../config/ConfigValue.hpp"
 
 // --------------------------------------------------------- //
 //   __  __  ____  _   _ _____ _______ ____  _____   _____   //
@@ -116,6 +117,13 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
 }
 
 void Events::listener_monitorFrame(void* owner, void* data) {
+    if (g_pCompositor->m_bExitTriggered) {
+        // Only signal cleanup once
+        g_pCompositor->m_bExitTriggered = false;
+        g_pCompositor->cleanup();
+        return;
+    }
+
     CMonitor* const PMONITOR = (CMonitor*)owner;
 
     if ((g_pCompositor->m_sWLRSession && !g_pCompositor->m_sWLRSession->active) || !g_pCompositor->m_bSessionActive || g_pCompositor->m_bUnsafeState) {
@@ -147,8 +155,8 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         PMONITOR->tearingState.frameScheduledWhileBusy = false;
     }
 
-    static auto* const PENABLERAT = &g_pConfigManager->getConfigValuePtr("misc:render_ahead_of_time")->intValue;
-    static auto* const PRATSAFE   = &g_pConfigManager->getConfigValuePtr("misc:render_ahead_safezone")->intValue;
+    static auto PENABLERAT = CConfigValue<Hyprlang::INT>("misc:render_ahead_of_time");
+    static auto PRATSAFE   = CConfigValue<Hyprlang::INT>("misc:render_ahead_safezone");
 
     PMONITOR->lastPresentationTimer.reset();
 
@@ -209,10 +217,20 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
 }
 
 void Events::listener_monitorStateRequest(void* owner, void* data) {
-    //const auto PMONITOR = (CMonitor*)owner;
-    //const auto E        = (wlr_output_event_request_state*)data;
+    const auto PMONITOR = (CMonitor*)owner;
+    const auto E        = (wlr_output_event_request_state*)data;
 
-    // TODO: maybe don't ignore?
+    if (!PMONITOR->createdByUser)
+        return;
+
+    const auto SIZE = E->state->mode ? Vector2D{E->state->mode->width, E->state->mode->height} : Vector2D{E->state->custom_mode.width, E->state->custom_mode.height};
+
+    PMONITOR->forceSize = SIZE;
+
+    SMonitorRule rule = PMONITOR->activeMonitorRule;
+    rule.resolution   = SIZE;
+
+    g_pHyprRenderer->applyMonitorRule(PMONITOR, &rule);
 }
 
 void Events::listener_monitorDamage(void* owner, void* data) {

src/events/Popups.cpp

@@ -1,264 +0,0 @@
-#include "Events.hpp"
-
-#include "../Compositor.hpp"
-#include "../helpers/WLClasses.hpp"
-#include "../managers/input/InputManager.hpp"
-#include "../render/Renderer.hpp"
-
-// --------------------------------------------- //
-//   _____   ____  _____  _    _ _____   _____   //
-//  |  __ \ / __ \|  __ \| |  | |  __ \ / ____|  //
-//  | |__) | |  | | |__) | |  | | |__) | (___    //
-//  |  ___/| |  | |  ___/| |  | |  ___/ \___ \   //
-//  | |    | |__| | |    | |__| | |     ____) |  //
-//  |_|     \____/|_|     \____/|_|    |_____/   //
-//                                               //
-// --------------------------------------------- //
-
-void addPopupGlobalCoords(void* pPopup, int* x, int* y) {
-    SXDGPopup* const PPOPUP = (SXDGPopup*)pPopup;
-
-    auto             curPopup = PPOPUP;
-
-    int              px = 0;
-    int              py = 0;
-
-    while (true) {
-        px += curPopup->popup->current.geometry.x;
-        py += curPopup->popup->current.geometry.y;
-
-        if (curPopup == PPOPUP && PPOPUP->parentWindow) {
-            px -= curPopup->popup->base->current.geometry.x;
-            py -= curPopup->popup->base->current.geometry.y;
-        }
-
-        if (curPopup->popup && !curPopup->parentPopup && !curPopup->parentWindow) {
-            const auto EXTENTSSURFACE = pixman_region32_extents(&curPopup->popup->base->surface->input_region);
-            px -= EXTENTSSURFACE->x1;
-            py -= EXTENTSSURFACE->y1;
-        }
-
-        if (curPopup->parentPopup) {
-            curPopup = curPopup->parentPopup;
-        } else {
-            break;
-        }
-    }
-
-    px += PPOPUP->lx;
-    py += PPOPUP->ly;
-
-    *x += px;
-    *y += py;
-}
-
-void createNewPopup(wlr_xdg_popup* popup, SXDGPopup* pHyprPopup) {
-    pHyprPopup->popup = popup;
-
-    pHyprPopup->hyprListener_destroyPopupXDG.initCallback(&popup->base->events.destroy, &Events::listener_destroyPopupXDG, pHyprPopup, "HyprPopup");
-    pHyprPopup->hyprListener_mapPopupXDG.initCallback(&popup->base->surface->events.map, &Events::listener_mapPopupXDG, pHyprPopup, "HyprPopup");
-    pHyprPopup->hyprListener_unmapPopupXDG.initCallback(&popup->base->surface->events.unmap, &Events::listener_unmapPopupXDG, pHyprPopup, "HyprPopup");
-    pHyprPopup->hyprListener_newPopupFromPopupXDG.initCallback(&popup->base->events.new_popup, &Events::listener_newPopupFromPopupXDG, pHyprPopup, "HyprPopup");
-    pHyprPopup->hyprListener_commitPopupXDG.initCallback(&popup->base->surface->events.commit, &Events::listener_commitPopupXDG, pHyprPopup, "HyprPopup");
-    pHyprPopup->hyprListener_repositionPopupXDG.initCallback(&popup->events.reposition, &Events::listener_repositionPopupXDG, pHyprPopup, "HyprPopup");
-
-    const auto PMONITOR = g_pCompositor->m_pLastMonitor;
-
-    CBox       box = {PMONITOR->vecPosition.x - pHyprPopup->lx, PMONITOR->vecPosition.y - pHyprPopup->ly, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
-
-    wlr_xdg_popup_unconstrain_from_box(popup, box.pWlr());
-
-    pHyprPopup->monitor = PMONITOR;
-
-    Debug::log(LOG, "Popup: Unconstrained from lx ly: {:j5}, pHyprPopup lx ly: {:.5f} {:.5f}", PMONITOR->vecPosition, (float)pHyprPopup->lx, (float)pHyprPopup->ly);
-}
-
-void Events::listener_newPopup(void* owner, void* data) {
-    SLayerSurface* layersurface = (SLayerSurface*)owner;
-
-    ASSERT(layersurface);
-
-    Debug::log(LOG, "New layer popup created from surface {:x}", (uintptr_t)layersurface);
-
-    const auto WLRPOPUP = (wlr_xdg_popup*)data;
-
-    const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-
-    PNEWPOPUP->popup    = WLRPOPUP;
-    PNEWPOPUP->lx       = layersurface->position.x;
-    PNEWPOPUP->ly       = layersurface->position.y;
-    PNEWPOPUP->monitor  = PMONITOR;
-    PNEWPOPUP->parentLS = layersurface;
-    createNewPopup(WLRPOPUP, PNEWPOPUP);
-}
-
-void Events::listener_newPopupXDG(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
-
-    ASSERT(PWINDOW);
-
-    if (!PWINDOW->m_bIsMapped)
-        return;
-
-    Debug::log(LOG, "New layer popup created from XDG window {}", PWINDOW);
-
-    const auto WLRPOPUP = (wlr_xdg_popup*)data;
-
-    const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
-
-    PNEWPOPUP->popup        = WLRPOPUP;
-    PNEWPOPUP->lx           = PWINDOW->m_vRealPosition.goalv().x;
-    PNEWPOPUP->ly           = PWINDOW->m_vRealPosition.goalv().y;
-    PNEWPOPUP->parentWindow = PWINDOW;
-    PNEWPOPUP->monitor      = PMONITOR;
-    createNewPopup(WLRPOPUP, PNEWPOPUP);
-}
-
-void Events::listener_newPopupFromPopupXDG(void* owner, void* data) {
-    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
-
-    ASSERT(PPOPUP);
-
-    if (PPOPUP->parentWindow)
-        Debug::log(LOG, "New popup created from XDG Window popup {:x} -> {}", (uintptr_t)PPOPUP, PPOPUP->parentWindow);
-    else
-        Debug::log(LOG, "New popup created from Non-Window popup {:x}", (uintptr_t)PPOPUP);
-
-    const auto WLRPOPUP = (wlr_xdg_popup*)data;
-
-    const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
-
-    PNEWPOPUP->popup        = WLRPOPUP;
-    PNEWPOPUP->parentPopup  = PPOPUP;
-    PNEWPOPUP->lx           = PPOPUP->lx;
-    PNEWPOPUP->ly           = PPOPUP->ly;
-    PNEWPOPUP->parentWindow = PPOPUP->parentWindow;
-    PNEWPOPUP->monitor      = PPOPUP->monitor;
-
-    createNewPopup(WLRPOPUP, PNEWPOPUP);
-}
-
-void Events::listener_mapPopupXDG(void* owner, void* data) {
-    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
-
-    ASSERT(PPOPUP);
-
-    Debug::log(LOG, "New XDG Popup mapped at {} {}", (int)PPOPUP->lx, (int)PPOPUP->ly);
-
-    if (PPOPUP->parentWindow)
-        PPOPUP->parentWindow->m_lPopupSurfaces.emplace_back(PPOPUP->popup->base->surface);
-    else if (PPOPUP->parentLS)
-        PPOPUP->parentLS->popupSurfaces.emplace_back(PPOPUP->popup->base->surface);
-
-    PPOPUP->pSurfaceTree = SubsurfaceTree::createTreeRoot(PPOPUP->popup->base->surface, addPopupGlobalCoords, PPOPUP, PPOPUP->parentWindow);
-
-    int lx = 0, ly = 0;
-    addPopupGlobalCoords(PPOPUP, &lx, &ly);
-
-    CBox extents;
-    wlr_surface_get_extends(PPOPUP->popup->base->surface, extents.pWlr());
-    extents.applyFromWlr();
-
-    g_pHyprRenderer->damageBox(lx - extents.x, ly - extents.y, extents.width + 2, extents.height + 2);
-
-    if (PPOPUP->monitor) {
-        g_pCompositor->setPreferredScaleForSurface(PPOPUP->popup->base->surface, PPOPUP->monitor->scale);
-        g_pCompositor->setPreferredTransformForSurface(PPOPUP->popup->base->surface, PPOPUP->monitor->transform);
-    }
-
-    Debug::log(LOG, "XDG Popup got assigned a surfaceTreeNode {:x}", (uintptr_t)PPOPUP->pSurfaceTree);
-}
-
-void Events::listener_repositionPopupXDG(void* owner, void* data) {
-    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
-
-    Debug::log(LOG, "XDG Popup {:x} asks for a reposition", (uintptr_t)PPOPUP);
-
-    int lx = 0, ly = 0;
-    addPopupGlobalCoords(PPOPUP, &lx, &ly);
-
-    CBox extents;
-    wlr_surface_get_extends(PPOPUP->popup->base->surface, extents.pWlr());
-    extents.applyFromWlr();
-
-    PPOPUP->lastPos             = {lx - extents.x, ly - extents.y};
-    PPOPUP->repositionRequested = true;
-
-    const auto PMONITOR = g_pCompositor->m_pLastMonitor;
-
-    CBox       box = {PMONITOR->vecPosition.x - lx + PPOPUP->popup->current.geometry.x, PMONITOR->vecPosition.y - ly + PPOPUP->popup->current.geometry.y, PMONITOR->vecSize.x,
-                      PMONITOR->vecSize.y};
-    wlr_xdg_popup_unconstrain_from_box(PPOPUP->popup, box.pWlr());
-}
-
-void Events::listener_unmapPopupXDG(void* owner, void* data) {
-    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
-    Debug::log(LOG, "XDG Popup unmapped");
-
-    ASSERT(PPOPUP);
-
-    if (PPOPUP->popup->base->surface == g_pCompositor->m_pLastFocus)
-        g_pInputManager->releaseAllMouseButtons();
-
-    SubsurfaceTree::destroySurfaceTree(PPOPUP->pSurfaceTree);
-
-    int lx = 0, ly = 0;
-    addPopupGlobalCoords(PPOPUP, &lx, &ly);
-
-    CBox extents;
-    wlr_surface_get_extends(PPOPUP->popup->base->surface, extents.pWlr());
-    extents.applyFromWlr();
-
-    g_pHyprRenderer->damageBox(lx - extents.x, ly - extents.y, extents.width + 2, extents.height + 2);
-
-    if (PPOPUP->parentWindow)
-        std::erase(PPOPUP->parentWindow->m_lPopupSurfaces, PPOPUP->popup->base->surface);
-    else if (PPOPUP->parentLS)
-        std::erase(PPOPUP->parentLS->popupSurfaces, PPOPUP->popup->base->surface);
-
-    PPOPUP->pSurfaceTree = nullptr;
-
-    g_pInputManager->simulateMouseMovement(); // to focus and return back to an appropriate surface
-}
-
-void Events::listener_commitPopupXDG(void* owner, void* data) {
-    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
-
-    if (g_pCompositor->windowValidMapped(PPOPUP->parentWindow)) {
-        PPOPUP->lx = PPOPUP->parentWindow->m_vRealPosition.vec().x;
-        PPOPUP->ly = PPOPUP->parentWindow->m_vRealPosition.vec().y;
-    }
-
-    int lx = 0, ly = 0;
-    addPopupGlobalCoords(PPOPUP, &lx, &ly);
-
-    CBox extents;
-    wlr_surface_get_extends(PPOPUP->popup->base->surface, extents.pWlr());
-    extents.applyFromWlr();
-
-    if (PPOPUP->repositionRequested)
-        g_pHyprRenderer->damageBox(PPOPUP->lastPos.x, PPOPUP->lastPos.y, extents.width + 2, extents.height + 2);
-
-    PPOPUP->repositionRequested = false;
-
-    g_pHyprRenderer->damageSurface(PPOPUP->popup->base->surface, lx, ly);
-}
-
-void Events::listener_destroyPopupXDG(void* owner, void* data) {
-    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
-
-    ASSERT(PPOPUP);
-
-    Debug::log(LOG, "Destroyed popup XDG {:x}", (uintptr_t)PPOPUP);
-
-    if (PPOPUP->pSurfaceTree) {
-        SubsurfaceTree::destroySurfaceTree(PPOPUP->pSurfaceTree);
-        PPOPUP->pSurfaceTree = nullptr;
-    }
-
-    std::erase_if(g_pCompositor->m_vXDGPopups, [&](std::unique_ptr<SXDGPopup>& el) { return el.get() == PPOPUP; });
-}

src/events/Windows.cpp

@@ -4,6 +4,7 @@
 #include "../helpers/WLClasses.hpp"
 #include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
+#include "../config/ConfigValue.hpp"
 
 // ------------------------------------------------------------ //
 //  __          _______ _   _ _____   ______          _______   //
@@ -17,8 +18,8 @@
 
 void addViewCoords(void* pWindow, int* x, int* y) {
     const auto PWINDOW = (CWindow*)pWindow;
-    *x += PWINDOW->m_vRealPosition.goalv().x;
-    *y += PWINDOW->m_vRealPosition.goalv().y;
+    *x += PWINDOW->m_vRealPosition.goal().x;
+    *y += PWINDOW->m_vRealPosition.goal().y;
 
     if (!PWINDOW->m_bIsX11 && PWINDOW->m_bIsMapped) {
         wlr_box geom;
@@ -32,27 +33,33 @@ void addViewCoords(void* pWindow, int* x, int* y) {
 void setAnimToMove(void* data) {
     auto* const            PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
 
-    CAnimatedVariable* animvar = (CAnimatedVariable*)data;
+    CBaseAnimatedVariable* animvar = (CBaseAnimatedVariable*)data;
 
+    if (animvar->getWindow() && !animvar->getWindow()->m_vRealPosition.isBeingAnimated() && !animvar->getWindow()->m_vRealSize.isBeingAnimated()) {
         animvar->setConfig(PANIMCFG);
+        animvar->getWindow()->m_bAnimatingIn = false;
+    }
 }
 
 void Events::listener_mapWindow(void* owner, void* data) {
     CWindow*    PWINDOW = (CWindow*)owner;
 
-    static auto* const PINACTIVEALPHA  = &g_pConfigManager->getConfigValuePtr("decoration:inactive_opacity")->floatValue;
-    static auto* const PACTIVEALPHA    = &g_pConfigManager->getConfigValuePtr("decoration:active_opacity")->floatValue;
-    static auto* const PDIMSTRENGTH    = &g_pConfigManager->getConfigValuePtr("decoration:dim_strength")->floatValue;
-    static auto* const PSWALLOW        = &g_pConfigManager->getConfigValuePtr("misc:enable_swallow")->intValue;
-    static auto* const PSWALLOWREGEX   = &g_pConfigManager->getConfigValuePtr("misc:swallow_regex")->strValue;
-    static auto* const PSWALLOWEXREGEX = &g_pConfigManager->getConfigValuePtr("misc:swallow_exception_regex")->strValue;
-    static auto* const PNEWTAKESOVERFS = &g_pConfigManager->getConfigValuePtr("misc:new_window_takes_over_fullscreen")->intValue;
+    static auto PINACTIVEALPHA  = CConfigValue<Hyprlang::FLOAT>("decoration:inactive_opacity");
+    static auto PACTIVEALPHA    = CConfigValue<Hyprlang::FLOAT>("decoration:active_opacity");
+    static auto PDIMSTRENGTH    = CConfigValue<Hyprlang::FLOAT>("decoration:dim_strength");
+    static auto PSWALLOW        = CConfigValue<Hyprlang::INT>("misc:enable_swallow");
+    static auto PSWALLOWREGEX   = CConfigValue<std::string>("misc:swallow_regex");
+    static auto PSWALLOWEXREGEX = CConfigValue<std::string>("misc:swallow_exception_regex");
+    static auto PNEWTAKESOVERFS = CConfigValue<Hyprlang::INT>("misc:new_window_takes_over_fullscreen");
 
     auto        PMONITOR = g_pCompositor->m_pLastMonitor;
-    const auto         PWORKSPACE =
-        PMONITOR->specialWorkspaceID ? g_pCompositor->getWorkspaceByID(PMONITOR->specialWorkspaceID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+    if (!g_pCompositor->m_pLastMonitor) {
+        g_pCompositor->setActiveMonitor(g_pCompositor->getMonitorFromVector({}));
+        PMONITOR = g_pCompositor->m_pLastMonitor;
+    }
+    auto PWORKSPACE           = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
     PWINDOW->m_iMonitorID     = PMONITOR->ID;
-    PWINDOW->m_iWorkspaceID   = PMONITOR->specialWorkspaceID ? PMONITOR->specialWorkspaceID : PMONITOR->activeWorkspace;
+    PWINDOW->m_pWorkspace     = PWORKSPACE;
     PWINDOW->m_bIsMapped      = true;
     PWINDOW->m_bReadyToDelete = false;
     PWINDOW->m_bFadingOut     = false;
@@ -101,7 +108,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     }
 
     // window rules
-    const auto  WINDOWRULES        = g_pConfigManager->getMatchingRules(PWINDOW);
+    const auto  WINDOWRULES        = g_pConfigManager->getMatchingRules(PWINDOW, false);
     std::string requestedWorkspace = "";
     bool        workspaceSilent    = false;
     bool        requestsFullscreen = PWINDOW->m_bWantsInitialFullscreen ||
@@ -146,7 +153,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->m_iMonitorID));
                     PMONITOR = PMONITORFROMID;
                 }
-                PWINDOW->m_iWorkspaceID = PMONITOR->specialWorkspaceID ? PMONITOR->specialWorkspaceID : PMONITOR->activeWorkspace;
+                PWINDOW->m_pWorkspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace;
 
                 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()); }
@@ -173,13 +180,23 @@ void Events::listener_mapWindow(void* owner, void* data) {
         } else if (r.szRule.starts_with("pseudo")) {
             PWINDOW->m_bIsPseudotiled = true;
         } else if (r.szRule.starts_with("nofocus")) {
-            PWINDOW->m_bNoFocus = true;
+            PWINDOW->m_sAdditionalConfigData.noFocus = true;
         } else if (r.szRule.starts_with("noinitialfocus")) {
             PWINDOW->m_bNoInitialFocus = true;
-        } else if (r.szRule.starts_with("nofullscreenrequest")) {
-            PWINDOW->m_bNoFullscreenRequest = true;
-        } else if (r.szRule.starts_with("nomaximizerequest")) {
-            PWINDOW->m_bNoMaximizeRequest = true;
+        } 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
+                    Debug::log(ERR, "Error while parsing suppressevent windowrule: unknown event type {}", vars[i]);
+            }
         } else if (r.szRule == "fullscreen") {
             requestsFullscreen     = true;
             overridingNoFullscreen = true;
@@ -249,8 +266,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->applyDynamicRule(r);
     }
 
-    PWINDOW->updateSpecialRenderData();
-
     // disallow tiled pinned
     if (PWINDOW->m_bPinned && !PWINDOW->m_bIsFloating)
         PWINDOW->m_bPinned = false;
@@ -270,16 +285,18 @@ void Events::listener_mapWindow(void* owner, void* data) {
             if (!pWorkspace)
                 pWorkspace = g_pCompositor->createNewWorkspace(REQUESTEDWORKSPACEID, PWINDOW->m_iMonitorID, requestedWorkspaceName);
 
-            PWINDOW->m_iWorkspaceID = pWorkspace->m_iID;
+            PWORKSPACE = pWorkspace;
+
+            PWINDOW->m_pWorkspace = pWorkspace;
             PWINDOW->m_iMonitorID = pWorkspace->m_iMonitorID;
 
-            if (g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->specialWorkspaceID && !pWorkspace->m_bIsSpecialWorkspace)
+            if (g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeSpecialWorkspace && !pWorkspace->m_bIsSpecialWorkspace)
                 workspaceSilent = true;
 
             if (!workspaceSilent) {
                 if (pWorkspace->m_bIsSpecialWorkspace)
                     g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID)->setSpecialWorkspace(pWorkspace);
-                else
+                else if (PMONITOR->activeWorkspaceID() != REQUESTEDWORKSPACEID)
                     g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspaceName);
 
                 PMONITOR = g_pCompositor->m_pLastMonitor;
@@ -288,6 +305,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
             workspaceSilent = false;
     }
 
+    PWINDOW->updateSpecialRenderData();
+
     if (PWINDOW->m_bIsFloating) {
         g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(PWINDOW);
         PWINDOW->m_bCreatedOverFullscreen = true;
@@ -312,38 +331,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     Debug::log(LOG, "Rule size, applying to {}", PWINDOW);
 
                     PWINDOW->m_vRealSize = Vector2D(SIZEX, SIZEY);
-                    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
+                    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal());
 
                     PWINDOW->setHidden(false);
                 } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r.szRule, r.szValue); }
-            } else if (r.szRule.starts_with("minsize")) {
-                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 SIZE =
-                        Vector2D(std::max((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::max((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
-
-                    PWINDOW->m_vRealSize = SIZE;
-                    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
-
-                    PWINDOW->setHidden(false);
-                } catch (...) { Debug::log(LOG, "Rule minsize failed, rule: {} -> {}", r.szRule, r.szValue); }
-            } else if (r.szRule.starts_with("maxsize")) {
-                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 SIZE =
-                        Vector2D(std::min((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::min((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
-
-                    PWINDOW->m_vRealSize = SIZE;
-                    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
-
-                    PWINDOW->setHidden(false);
-                } catch (...) { Debug::log(LOG, "Rule maxsize failed, rule: {} -> {}", r.szRule, r.szValue); }
             } else if (r.szRule.starts_with("move")) {
                 try {
                     auto       value = r.szRule.substr(r.szRule.find(' ') + 1);
@@ -379,7 +370,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                             posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x;
                         } else {
                             posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x +
-                                (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().x);
+                                (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goal().x);
                         }
                     }
 
@@ -398,7 +389,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                             posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y;
                         } else {
                             posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y +
-                                (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().y);
+                                (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goal().y);
                         }
                     }
 
@@ -406,10 +397,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         int borderSize = PWINDOW->getRealBorderSize();
 
                         posX = std::clamp(posX, (int)(PMONITOR->vecReservedTopLeft.x + borderSize),
-                                          (int)(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PWINDOW->m_vRealSize.goalv().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.goalv().y - borderSize));
+                                          (int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_vRealSize.goal().y - borderSize));
                     }
 
                     Debug::log(LOG, "Rule move, applying to {}", PWINDOW);
@@ -424,26 +415,26 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 if (ARGS[1] == "1")
                     RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;
 
-                PWINDOW->m_vRealPosition = PMONITOR->middle() - PWINDOW->m_vRealSize.goalv() / 2.f + RESERVEDOFFSET;
+                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.goalv();
+        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goal();
 
         g_pCompositor->changeWindowZOrder(PWINDOW, true);
     } else {
         g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
 
         // Set the pseudo size here too so that it doesnt end up being 0x0
-        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv() - Vector2D(10, 10);
+        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goal() - Vector2D(10, 10);
     }
 
     const auto PFOCUSEDWINDOWPREV = g_pCompositor->m_pLastWindow;
 
     if (PWINDOW->m_sAdditionalConfigData.forceAllowsInput) {
-        PWINDOW->m_bNoFocus          = false;
+        PWINDOW->m_sAdditionalConfigData.noFocus = false;
         PWINDOW->m_bNoInitialFocus               = false;
         PWINDOW->m_bX11ShouldntFocus             = false;
     }
@@ -464,9 +455,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
             requestsFullscreen = true;
     }
 
-    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus &&
-        (PWINDOW->m_iX11Type != 2 || (PWINDOW->m_bIsX11 && wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland))) && !workspaceSilent &&
-        (!PFORCEFOCUS || PFORCEFOCUS == PWINDOW)) {
+    if (!PWINDOW->m_sAdditionalConfigData.noFocus && !PWINDOW->m_bNoInitialFocus &&
+        (PWINDOW->m_iX11Type != 2 ||
+         (PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xwayland->window_type_len > 0 && wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland))) &&
+        !workspaceSilent && (!PFORCEFOCUS || PFORCEFOCUS == PWINDOW) && !g_pInputManager->isConstrained()) {
         g_pCompositor->focusWindow(PWINDOW);
         PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PACTIVEALPHA);
         PWINDOW->m_fDimPercent.setValueAndWarp(PWINDOW->m_sAdditionalConfigData.forceNoDim ? 0.f : *PDIMSTRENGTH);
@@ -475,11 +467,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_fDimPercent.setValueAndWarp(0);
     }
 
-    Debug::log(LOG, "Window got assigned a surfaceTreeNode {:x}", (uintptr_t)PWINDOW->m_pSurfaceTree);
-
     if (!PWINDOW->m_bIsX11) {
         PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_newPopupXDG.initCallback(&PWINDOW->m_uSurface.xdg->events.new_popup, &Events::listener_newPopupXDG, PWINDOW, "XDG Window Late");
         PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_maximize, &Events::listener_requestMaximize, PWINDOW,
                                                            "XDG Window Late");
         PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_minimize, &Events::listener_requestMinimize, PWINDOW,
@@ -504,8 +493,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                                                                "XWayland Window Late");
     }
 
-    if ((requestsFullscreen && (!PWINDOW->m_bNoFullscreenRequest || overridingNoFullscreen)) || (requestsMaximize && (!PWINDOW->m_bNoMaximizeRequest || overridingNoMaximize)) ||
-        requestsFakeFullscreen) {
+    if ((requestsFullscreen && (!(PWINDOW->m_eSuppressedEvents & SUPPRESS_FULLSCREEN) || overridingNoFullscreen)) ||
+        (requestsMaximize && (!(PWINDOW->m_eSuppressedEvents & SUPPRESS_MAXIMIZE) || overridingNoMaximize)) || requestsFakeFullscreen) {
         // fix fullscreen on requested (basically do a switcheroo)
         if (PWORKSPACE->m_bHasFullscreenWindow) {
             const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
@@ -527,8 +516,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // recheck idle inhibitors
     g_pInputManager->recheckIdleInhibitorStatus();
 
-    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(PWINDOW->m_pWLSurface.wlr(), addViewCoords, PWINDOW, PWINDOW);
-
     PWINDOW->updateToplevel();
 
     if (workspaceSilent) {
@@ -540,7 +527,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     }
 
     // verify swallowing
-    if (*PSWALLOW && *PSWALLOWREGEX != STRVAL_EMPTY) {
+    if (*PSWALLOW && std::string{*PSWALLOWREGEX} != STRVAL_EMPTY) {
         // don't swallow ourselves
         std::regex rgx(*PSWALLOWREGEX);
         if (!std::regex_match(g_pXWaylandManager->getAppIDClass(PWINDOW), rgx)) {
@@ -587,7 +574,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 if (finalFound) {
                     bool valid = std::regex_match(g_pXWaylandManager->getAppIDClass(finalFound), rgx);
 
-                    if (*PSWALLOWEXREGEX != STRVAL_EMPTY) {
+                    if (std::string{*PSWALLOWEXREGEX} != STRVAL_EMPTY) {
                         std::regex exc(*PSWALLOWEXREGEX);
 
                         valid = valid && !std::regex_match(g_pXWaylandManager->getTitle(finalFound), exc);
@@ -611,7 +598,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.goalv(), PWINDOW->m_vRealSize.goalv());
+    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, g_pXWaylandManager->getAppIDClass(PWINDOW), PWINDOW->m_szTitle)});
@@ -639,13 +626,16 @@ void Events::listener_mapWindow(void* owner, void* data) {
     g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->scale);
     g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->transform);
 
-    if (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->constraintActive)
+    if (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained())
         g_pInputManager->sendMotionEventsToFocused();
 
     // fix some xwayland apps that don't behave nicely
     PWINDOW->m_vReportedSize = PWINDOW->m_vPendingReportedSize;
 
-    g_pCompositor->updateWorkspaceWindows(PWINDOW->m_iWorkspaceID);
+    g_pCompositor->updateWorkspaceWindows(PWINDOW->workspaceID());
+
+    if (PMONITOR && PWINDOW->m_iX11Type == 2)
+        PWINDOW->m_fX11SurfaceScaledBy = PMONITOR->scale;
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
@@ -661,8 +651,8 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
     if (PMONITOR) {
-        PWINDOW->m_vOriginalClosedPos     = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
-        PWINDOW->m_vOriginalClosedSize    = PWINDOW->m_vRealSize.vec();
+        PWINDOW->m_vOriginalClosedPos     = PWINDOW->m_vRealPosition.value() - PMONITOR->vecPosition;
+        PWINDOW->m_vOriginalClosedSize    = PWINDOW->m_vRealSize.value();
         PWINDOW->m_eOriginalClosedExtents = PWINDOW->getFullWindowExtents();
     }
 
@@ -674,7 +664,6 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     if (!PWINDOW->m_bIsX11) {
         Debug::log(LOG, "Unregistered late callbacks XDG");
         PWINDOW->hyprListener_setTitleWindow.removeCallback();
-        PWINDOW->hyprListener_newPopupXDG.removeCallback();
         PWINDOW->hyprListener_requestMaximize.removeCallback();
         PWINDOW->hyprListener_requestMinimize.removeCallback();
         PWINDOW->hyprListener_requestMove.removeCallback();
@@ -715,7 +704,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     }
 
     // remove the fullscreen window status from workspace if we closed it
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
+    const auto PWORKSPACE = PWINDOW->m_pWorkspace;
 
     if (PWORKSPACE->m_bHasFullscreenWindow && PWINDOW->m_bIsFullscreen)
         PWORKSPACE->m_bHasFullscreenWindow = false;
@@ -734,6 +723,9 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         if (PWINDOWCANDIDATE != g_pCompositor->m_pLastWindow && PWINDOWCANDIDATE)
             g_pCompositor->focusWindow(PWINDOWCANDIDATE);
 
+        if (!PWINDOWCANDIDATE && g_pCompositor->getWindowsOnWorkspace(PWINDOW->workspaceID()) == 0)
+            g_pInputManager->refocus();
+
         g_pInputManager->sendMotionEventsToFocused();
 
         // CWindow::onUnmap will remove this window's active status, but we can't really do it above.
@@ -746,11 +738,6 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         Debug::log(LOG, "Unmapped was not focused, ignoring a refocus.");
     }
 
-    Debug::log(LOG, "Destroying the SubSurface tree of unmapped window {}", PWINDOW);
-    SubsurfaceTree::destroySurfaceTree(PWINDOW->m_pSurfaceTree);
-
-    PWINDOW->m_pSurfaceTree = nullptr;
-
     PWINDOW->m_bFadingOut = true;
 
     g_pCompositor->addToFadingOutSafe(PWINDOW);
@@ -758,7 +745,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID));
 
     if (!PWINDOW->m_bX11DoesntWantBorders)                                                    // don't animate out if they weren't animated in.
-        PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f); // it has to be animated, otherwise onWindowPostCreateClose will ignore it
+        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);
@@ -771,7 +758,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     g_pInputManager->recheckIdleInhibitorStatus();
 
     // force report all sizes (QT sometimes has an issue with this)
-    g_pCompositor->forceReportSizesToWindowsOnWorkspace(PWINDOW->m_iWorkspaceID);
+    g_pCompositor->forceReportSizesToWindowsOnWorkspace(PWINDOW->workspaceID());
 
     // update lastwindow after focus
     PWINDOW->onUnmap();
@@ -794,6 +781,15 @@ void Events::listener_ackConfigure(void* owner, void* data) {
 void Events::listener_commitWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
+    if (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->initial_commit) {
+        Vector2D predSize = g_pLayoutManager->getCurrentLayout()->predictSizeForNewWindow(PWINDOW);
+
+        Debug::log(LOG, "Layout predicts size {} for {}", predSize, PWINDOW);
+
+        wlr_xdg_toplevel_set_size(PWINDOW->m_uSurface.xdg->toplevel, predSize.x, predSize.y);
+        return;
+    }
+
     if (!PWINDOW->m_bIsMapped || PWINDOW->isHidden())
         return;
 
@@ -804,19 +800,12 @@ void Events::listener_commitWindow(void* owner, void* data) {
         PWINDOW->m_pPendingSizeAck.reset();
     }
 
-    g_pHyprRenderer->damageSurface(PWINDOW->m_pWLSurface.wlr(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y,
-                                   PWINDOW->m_bIsX11 ? 1.0 / PWINDOW->m_fX11SurfaceScaledBy : 1.0);
-
-    if (PWINDOW->m_bIsX11 || !PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen)
-        return;
-
+    if (!PWINDOW->m_bIsX11 && !PWINDOW->m_bIsFullscreen && PWINDOW->m_bIsFloating) {
         const auto MINSIZE = Vector2D{PWINDOW->m_uSurface.xdg->toplevel->current.min_width, PWINDOW->m_uSurface.xdg->toplevel->current.min_height};
         const auto MAXSIZE = Vector2D{PWINDOW->m_uSurface.xdg->toplevel->current.max_width, PWINDOW->m_uSurface.xdg->toplevel->current.max_height};
 
-    if (MAXSIZE < Vector2D{1, 1})
-        return;
-
-    const auto REALSIZE = PWINDOW->m_vRealSize.goalv();
+        if (MAXSIZE > Vector2D{1, 1}) {
+            const auto REALSIZE = PWINDOW->m_vRealSize.goal();
             Vector2D   newSize  = REALSIZE;
 
             if (MAXSIZE.x < newSize.x)
@@ -830,10 +819,39 @@ void Events::listener_commitWindow(void* owner, void* data) {
 
             const Vector2D DELTA = REALSIZE - newSize;
 
-    PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.goalv() + DELTA / 2.0;
+            PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.goal() + DELTA / 2.0;
             PWINDOW->m_vRealSize     = newSize;
             g_pXWaylandManager->setWindowSize(PWINDOW, newSize, true);
             g_pHyprRenderer->damageWindow(PWINDOW);
+        }
+    }
+
+    if (!PWINDOW->m_pWorkspace->m_bVisible)
+        return;
+
+    g_pHyprRenderer->damageSurface(PWINDOW->m_pWLSurface.wlr(), PWINDOW->m_vRealPosition.goal().x, PWINDOW->m_vRealPosition.goal().y,
+                                   PWINDOW->m_bIsX11 ? 1.0 / PWINDOW->m_fX11SurfaceScaledBy : 1.0);
+
+    if (!PWINDOW->m_bIsX11) {
+        PWINDOW->m_pSubsurfaceHead->recheckDamageForSubsurfaces();
+        PWINDOW->m_pPopupHead->recheckTree();
+    }
+
+    // tearing: if solitary, redraw it. This still might be a single surface window
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    if (PMONITOR && PMONITOR->solitaryClient == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear &&
+        PWINDOW->m_pWLSurface.wlr()->current.committed & WLR_SURFACE_STATE_BUFFER) {
+        CRegion damageBox{&PWINDOW->m_pWLSurface.wlr()->buffer_damage};
+
+        if (!damageBox.empty()) {
+            if (PMONITOR->tearingState.busy) {
+                PMONITOR->tearingState.frameScheduledWhileBusy = true;
+            } else {
+                PMONITOR->tearingState.nextRenderTorn = true;
+                g_pHyprRenderer->renderMonitor(PMONITOR);
+            }
+        }
+    }
 }
 
 void Events::listener_destroyWindow(void* owner, void* data) {
@@ -849,6 +867,8 @@ void Events::listener_destroyWindow(void* owner, void* data) {
         g_pCompositor->m_pLastFocus  = nullptr;
     }
 
+    PWINDOW->m_pWLSurface.unassign();
+
     PWINDOW->hyprListener_commitWindow.removeCallback();
     PWINDOW->hyprListener_mapWindow.removeCallback();
     PWINDOW->hyprListener_unmapWindow.removeCallback();
@@ -860,14 +880,10 @@ void Events::listener_destroyWindow(void* owner, void* data) {
 
     g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
 
-    if (PWINDOW->m_pSurfaceTree) {
-        Debug::log(LOG, "Destroying Subsurface tree of {} in destroyWindow", PWINDOW);
-        SubsurfaceTree::destroySurfaceTree(PWINDOW->m_pSurfaceTree);
-        PWINDOW->m_pSurfaceTree = nullptr;
-    }
-
     PWINDOW->m_bReadyToDelete = true;
 
+    PWINDOW->m_uSurface.xdg = nullptr;
+
     if (!PWINDOW->m_bFadingOut) {
         Debug::log(LOG, "Unmapped {} removed instantly", PWINDOW);
         g_pCompositor->removeWindowFromVectorSafe(PWINDOW); // most likely X11 unmanaged or sumn
@@ -880,7 +896,12 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return;
 
-    PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
+    const auto NEWTITLE = g_pXWaylandManager->getTitle(PWINDOW);
+
+    if (NEWTITLE == PWINDOW->m_szTitle)
+        return;
+
+    PWINDOW->m_szTitle = NEWTITLE;
     g_pEventManager->postEvent(SHyprIPCEvent{"windowtitle", std::format("{:x}", (uintptr_t)PWINDOW)});
     EMIT_HOOK_EVENT("windowTitle", PWINDOW);
 
@@ -905,7 +926,7 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
         return;
     }
 
-    if (PWINDOW->isHidden() || PWINDOW->m_bNoFullscreenRequest)
+    if (PWINDOW->isHidden() || (PWINDOW->m_eSuppressedEvents & SUPPRESS_FULLSCREEN))
         return;
 
     bool requestedFullState = false;
@@ -914,7 +935,7 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
         const auto REQUESTED = &PWINDOW->m_uSurface.xdg->toplevel->requested;
 
         if (REQUESTED->fullscreen && PWINDOW->m_bIsFullscreen) {
-            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
+            const auto PWORKSPACE = PWINDOW->m_pWorkspace;
             if (PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) {
                 // Store that we were maximized
                 PWINDOW->m_bWasMaximized = true;
@@ -959,7 +980,7 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
 void Events::listener_activateXDG(wl_listener* listener, void* data) {
     const auto  E = (wlr_xdg_activation_v1_request_activate_event*)data;
 
-    static auto* const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
+    static auto PFOCUSONACTIVATE = CConfigValue<Hyprlang::INT>("misc:focus_on_activate");
 
     Debug::log(LOG, "Activate request for surface at {:x}", (uintptr_t)E->surface);
 
@@ -968,7 +989,7 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
 
     const auto PWINDOW = g_pCompositor->getWindowFromSurface(E->surface);
 
-    if (!PWINDOW || PWINDOW == g_pCompositor->m_pLastWindow)
+    if (!PWINDOW || PWINDOW == g_pCompositor->m_pLastWindow || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE))
         return;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)PWINDOW)});
@@ -976,7 +997,7 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
 
     PWINDOW->m_bIsUrgent = true;
 
-    if (!*PFOCUSONACTIVATE)
+    if (!*PFOCUSONACTIVATE || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE_FOCUSONLY))
         return;
 
     if (PWINDOW->m_bIsFloating)
@@ -989,7 +1010,7 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
 void Events::listener_activateX11(void* owner, void* data) {
     const auto  PWINDOW = (CWindow*)owner;
 
-    static auto* const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
+    static auto PFOCUSONACTIVATE = CConfigValue<Hyprlang::INT>("misc:focus_on_activate");
 
     Debug::log(LOG, "X11 Activate request for window {}", PWINDOW);
 
@@ -1000,17 +1021,20 @@ void Events::listener_activateX11(void* owner, void* data) {
         if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->getPID() != PWINDOW->getPID())
             return;
 
+        if (!wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland))
+            return;
+
         g_pCompositor->focusWindow(PWINDOW);
         return;
     }
 
-    if (PWINDOW == g_pCompositor->m_pLastWindow)
+    if (PWINDOW == g_pCompositor->m_pLastWindow || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE))
         return;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)PWINDOW)});
     EMIT_HOOK_EVENT("urgent", PWINDOW);
 
-    if (!*PFOCUSONACTIVATE)
+    if (!*PFOCUSONACTIVATE || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE_FOCUSONLY))
         return;
 
     if (PWINDOW->m_bIsFloating)
@@ -1029,13 +1053,15 @@ void Events::listener_configureX11(void* owner, void* data) {
         wlr_xwayland_surface_configure(PWINDOW->m_uSurface.xwayland, E->x, E->y, E->width, E->height);
         PWINDOW->m_vPendingReportedSize = {E->width, E->height};
         PWINDOW->m_vReportedSize        = {E->width, E->height};
+        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID); PMONITOR)
+            PWINDOW->m_fX11SurfaceScaledBy = PMONITOR->scale;
         return;
     }
 
     g_pHyprRenderer->damageWindow(PWINDOW);
 
     if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen || g_pInputManager->currentlyDraggedWindow == PWINDOW) {
-        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv(), true);
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal(), true);
         g_pInputManager->refocus();
         g_pHyprRenderer->damageWindow(PWINDOW);
         return;
@@ -1051,14 +1077,16 @@ void Events::listener_configureX11(void* owner, void* data) {
     PWINDOW->m_vRealPosition.setValueAndWarp(LOGICALPOS);
     PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(E->width, E->height));
 
-    static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
+    static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
     if (*PXWLFORCESCALEZERO) {
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID); PMONITOR)
-            PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goalv() / PMONITOR->scale);
+        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID); PMONITOR) {
+            PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goal() / PMONITOR->scale);
+            PWINDOW->m_fX11SurfaceScaledBy = PMONITOR->scale;
+        }
     }
 
-    PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.vec();
-    PWINDOW->m_vSize     = PWINDOW->m_vRealSize.vec();
+    PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.value();
+    PWINDOW->m_vSize     = PWINDOW->m_vRealSize.value();
 
     wlr_xwayland_surface_configure(PWINDOW->m_uSurface.xwayland, E->x, E->y, E->width, E->height);
 
@@ -1067,10 +1095,10 @@ void Events::listener_configureX11(void* owner, void* data) {
 
     PWINDOW->updateWindowDecos();
 
-    if (!g_pCompositor->isWorkspaceVisible(PWINDOW->m_iWorkspaceID))
+    if (!g_pCompositor->isWorkspaceVisible(PWINDOW->m_pWorkspace))
         return; // further things are only for visible windows
 
-    PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 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);
 
@@ -1088,8 +1116,8 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
     if (!PWINDOW->m_bIsMapped)
         return;
 
-    const auto POS = PWINDOW->m_vRealPosition.goalv();
-    const auto SIZ = PWINDOW->m_vRealSize.goalv();
+    const auto POS = PWINDOW->m_vRealPosition.goal();
+    const auto SIZ = PWINDOW->m_vRealSize.goal();
 
     if (PWINDOW->m_uSurface.xwayland->width > 1 && PWINDOW->m_uSurface.xwayland->height > 1)
         PWINDOW->setHidden(false);
@@ -1097,12 +1125,12 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
         PWINDOW->setHidden(true);
 
     if (PWINDOW->m_bIsFullscreen || !PWINDOW->m_bIsFloating) {
-        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv(), true);
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal(), true);
         g_pHyprRenderer->damageWindow(PWINDOW);
         return;
     }
 
-    static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
+    static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
 
     const auto  LOGICALPOS = g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOW->m_uSurface.xwayland->x, PWINDOW->m_uSurface.xwayland->y});
 
@@ -1119,23 +1147,23 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
 
         if (*PXWLFORCESCALEZERO) {
             if (const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID); PMONITOR) {
-                const Vector2D DELTA = PWINDOW->m_vRealSize.goalv() - PWINDOW->m_vRealSize.goalv() / PMONITOR->scale;
-                PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goalv() / PMONITOR->scale);
-                PWINDOW->m_vRealPosition.setValueAndWarp(PWINDOW->m_vRealPosition.goalv() + DELTA / 2.0);
+                const Vector2D DELTA = PWINDOW->m_vRealSize.goal() - PWINDOW->m_vRealSize.goal() / PMONITOR->scale;
+                PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goal() / PMONITOR->scale);
+                PWINDOW->m_vRealPosition.setValueAndWarp(PWINDOW->m_vRealPosition.goal() + DELTA / 2.0);
             }
         }
 
-        PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.goalv();
-        PWINDOW->m_vSize     = PWINDOW->m_vRealSize.goalv();
+        PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.goal();
+        PWINDOW->m_vSize     = PWINDOW->m_vRealSize.goal();
 
-        PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 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.goalv();
-        PWINDOW->m_vPendingReportedSize = PWINDOW->m_vRealSize.goalv();
+        PWINDOW->m_vReportedPosition    = PWINDOW->m_vRealPosition.goal();
+        PWINDOW->m_vPendingReportedSize = PWINDOW->m_vRealSize.goal();
     }
 }
 
@@ -1152,11 +1180,15 @@ void Events::listener_associateX11(void* owner, void* data) {
 
     PWINDOW->hyprListener_mapWindow.initCallback(&PWINDOW->m_uSurface.xwayland->surface->events.map, &Events::listener_mapWindow, PWINDOW, "XWayland Window");
     PWINDOW->hyprListener_commitWindow.initCallback(&PWINDOW->m_uSurface.xwayland->surface->events.commit, &Events::listener_commitWindow, PWINDOW, "XWayland Window");
+
+    PWINDOW->m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW);
 }
 
 void Events::listener_dissociateX11(void* owner, void* data) {
     const auto PWINDOW = (CWindow*)owner;
 
+    PWINDOW->m_pWLSurface.unassign();
+
     PWINDOW->hyprListener_mapWindow.removeCallback();
     PWINDOW->hyprListener_commitWindow.removeCallback();
 }
@@ -1196,6 +1228,8 @@ void Events::listener_newXDGToplevel(wl_listener* listener, void* data) {
     PNEWWINDOW->hyprListener_mapWindow.initCallback(&XDGSURFACE->surface->events.map, &Events::listener_mapWindow, PNEWWINDOW, "XDG Window");
     PNEWWINDOW->hyprListener_destroyWindow.initCallback(&XDGSURFACE->events.destroy, &Events::listener_destroyWindow, PNEWWINDOW, "XDG Window");
     PNEWWINDOW->hyprListener_commitWindow.initCallback(&XDGSURFACE->surface->events.commit, &Events::listener_commitWindow, PNEWWINDOW, "XDG Window");
+
+    PNEWWINDOW->m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(PNEWWINDOW), PNEWWINDOW);
 }
 
 void Events::listener_NewXDGDeco(wl_listener* listener, void* data) {
@@ -1206,7 +1240,7 @@ void Events::listener_NewXDGDeco(wl_listener* listener, void* data) {
 void Events::listener_requestMaximize(void* owner, void* data) {
     const auto PWINDOW = (CWindow*)owner;
 
-    if (PWINDOW->m_bNoMaximizeRequest)
+    if (PWINDOW->m_eSuppressedEvents & SUPPRESS_MAXIMIZE)
         return;
 
     Debug::log(LOG, "Maximize request for {}", PWINDOW);

src/helpers/AnimatedVariable.cpp

@@ -2,12 +2,11 @@
 #include "../managers/AnimationManager.hpp"
 #include "../config/ConfigManager.hpp"
 
-CAnimatedVariable::CAnimatedVariable() {
+CBaseAnimatedVariable::CBaseAnimatedVariable(ANIMATEDVARTYPE type) : m_Type(type) {
     ; // dummy var
 }
 
-void CAnimatedVariable::create(ANIMATEDVARTYPE type, SAnimationPropertyConfig* pAnimConfig, void* pWindow, AVARDAMAGEPOLICY policy) {
-    m_eVarType      = type;
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, CWindow* pWindow, AVARDAMAGEPOLICY policy) {
     m_eDamagePolicy = policy;
     m_pConfig       = pAnimConfig;
     m_pWindow       = pWindow;
@@ -15,42 +14,34 @@ void CAnimatedVariable::create(ANIMATEDVARTYPE type, SAnimationPropertyConfig* p
     m_bDummy = false;
 }
 
-void CAnimatedVariable::create(ANIMATEDVARTYPE type, std::any val, SAnimationPropertyConfig* pAnimConfig, void* pWindow, AVARDAMAGEPOLICY policy) {
-    create(type, pAnimConfig, pWindow, policy);
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, SLayerSurface* pLayer, AVARDAMAGEPOLICY policy) {
+    m_eDamagePolicy = policy;
+    m_pConfig       = pAnimConfig;
+    m_pLayer        = pLayer;
 
-    try {
-        switch (type) {
-            case AVARTYPE_FLOAT: {
-                const auto V = std::any_cast<float>(val);
-                m_fValue     = V;
-                m_fGoal      = V;
-                break;
-            }
-            case AVARTYPE_VECTOR: {
-                const auto V = std::any_cast<Vector2D>(val);
-                m_vValue     = V;
-                m_vGoal      = V;
-                break;
-            }
-            case AVARTYPE_COLOR: {
-                const auto V = std::any_cast<CColor>(val);
-                m_cValue     = V;
-                m_cGoal      = V;
-                break;
-            }
-            default: ASSERT(false); break;
-        }
-    } catch (std::exception& e) {
-        Debug::log(ERR, "CAnimatedVariable create error: {}", e.what());
-        RASSERT(false, "CAnimatedVariable create error: {}", e.what());
-    }
+    m_bDummy = false;
 }
 
-CAnimatedVariable::~CAnimatedVariable() {
+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 CAnimatedVariable::unregister() {
+void CBaseAnimatedVariable::unregister() {
     if (!g_pAnimationManager)
         return;
     std::erase_if(g_pAnimationManager->m_vAnimatedVariables, [&](const auto& other) { return other == this; });
@@ -58,23 +49,26 @@ void CAnimatedVariable::unregister() {
     disconnectFromActive();
 }
 
-void CAnimatedVariable::registerVar() {
+void CBaseAnimatedVariable::registerVar() {
     if (!m_bIsRegistered)
         g_pAnimationManager->m_vAnimatedVariables.push_back(this);
     m_bIsRegistered = true;
 }
 
-int CAnimatedVariable::getDurationLeftMs() {
+int CBaseAnimatedVariable::getDurationLeftMs() {
     return std::max(
         (int)(m_pConfig->pValues->internalSpeed * 100) - (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - animationBegin).count(), 0);
 }
 
-float CAnimatedVariable::getPercent() {
+float CBaseAnimatedVariable::getPercent() {
     const auto DURATIONPASSED = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - animationBegin).count();
     return std::clamp((DURATIONPASSED / 100.f) / m_pConfig->pValues->internalSpeed, 0.f, 1.f);
 }
 
-float CAnimatedVariable::getCurveValue() {
+float CBaseAnimatedVariable::getCurveValue() {
+    if (!m_bIsBeingAnimated)
+        return 1.f;
+
     const auto SPENT = getPercent();
 
     if (SPENT >= 1.f)
@@ -83,7 +77,7 @@ float CAnimatedVariable::getCurveValue() {
     return g_pAnimationManager->getBezier(m_pConfig->pValues->internalBezier)->getYForPoint(SPENT);
 }
 
-void CAnimatedVariable::connectToActive() {
+void CBaseAnimatedVariable::connectToActive() {
     g_pAnimationManager->scheduleTick(); // otherwise the animation manager will never pick this up
 
     if (!m_bIsConnectedToActive)
@@ -92,7 +86,7 @@ void CAnimatedVariable::connectToActive() {
     m_bIsConnectedToActive = true;
 }
 
-void CAnimatedVariable::disconnectFromActive() {
+void CBaseAnimatedVariable::disconnectFromActive() {
     std::erase_if(g_pAnimationManager->m_vActiveAnimatedVariables, [&](const auto& other) { return other == this; });
     m_bIsConnectedToActive = false;
 }

src/helpers/AnimatedVariable.hpp

@@ -3,10 +3,12 @@
 #include <functional>
 #include <any>
 #include <chrono>
+#include <type_traits>
 #include "Vector2D.hpp"
 #include "Color.hpp"
 #include "../macros.hpp"
 #include "../debug/Log.hpp"
+#include "../desktop/DesktopTypes.hpp"
 
 enum ANIMATEDVARTYPE {
     AVARTYPE_INVALID = -1,
@@ -15,6 +17,30 @@ enum ANIMATEDVARTYPE {
     AVARTYPE_COLOR
 };
 
+// Utility to bind a type with its corresponding ANIMATEDVARTYPE
+template <class T>
+struct typeToANIMATEDVARTYPE_t {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_INVALID;
+};
+
+template <>
+struct typeToANIMATEDVARTYPE_t<float> {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_FLOAT;
+};
+
+template <>
+struct typeToANIMATEDVARTYPE_t<Vector2D> {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_VECTOR;
+};
+
+template <>
+struct typeToANIMATEDVARTYPE_t<CColor> {
+    static constexpr ANIMATEDVARTYPE value = AVARTYPE_COLOR;
+};
+
+template <class T>
+inline constexpr ANIMATEDVARTYPE typeToANIMATEDVARTYPE = typeToANIMATEDVARTYPE_t<T>::value;
+
 enum AVARDAMAGEPOLICY {
     AVARDAMAGE_NONE   = -1,
     AVARDAMAGE_ENTIRE = 0,
@@ -23,179 +49,43 @@ enum AVARDAMAGEPOLICY {
 };
 
 class CAnimationManager;
-class CWorkspace;
 struct SLayerSurface;
 struct SAnimationPropertyConfig;
 class CHyprRenderer;
+class CWindow;
+class CWorkspace;
 
-class CAnimatedVariable {
+// Utility to define a concept as a list of possible type
+template <class T, class... U>
+concept OneOf = (... or std::same_as<T, U>);
+
+// Concept to describe which type can be placed into CAnimatedVariable
+// 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, CColor>;
+
+class CBaseAnimatedVariable {
   public:
-    CAnimatedVariable(); // dummy var
+    CBaseAnimatedVariable(ANIMATEDVARTYPE type);
+    void create(SAnimationPropertyConfig* pAnimConfig, CWindow* pWindow, AVARDAMAGEPOLICY policy);
+    void create(SAnimationPropertyConfig* pAnimConfig, SLayerSurface* pLayer, AVARDAMAGEPOLICY policy);
+    void create(SAnimationPropertyConfig* pAnimConfig, PHLWORKSPACE pWorkspace, AVARDAMAGEPOLICY policy);
+    void create(SAnimationPropertyConfig* pAnimConfig, AVARDAMAGEPOLICY policy);
 
-    void create(ANIMATEDVARTYPE, SAnimationPropertyConfig*, void* pWindow, AVARDAMAGEPOLICY);
-    void create(ANIMATEDVARTYPE, std::any val, SAnimationPropertyConfig*, void* pWindow, AVARDAMAGEPOLICY);
+    CBaseAnimatedVariable(const CBaseAnimatedVariable&)            = delete;
+    CBaseAnimatedVariable(CBaseAnimatedVariable&&)                 = delete;
+    CBaseAnimatedVariable& operator=(const CBaseAnimatedVariable&) = delete;
+    CBaseAnimatedVariable& operator=(CBaseAnimatedVariable&&)      = delete;
 
-    CAnimatedVariable(const CAnimatedVariable&)            = delete;
-    CAnimatedVariable(CAnimatedVariable&&)                 = delete;
-    CAnimatedVariable& operator=(const CAnimatedVariable&) = delete;
-    CAnimatedVariable& operator=(CAnimatedVariable&&)      = delete;
-
-    ~CAnimatedVariable();
+    virtual ~CBaseAnimatedVariable();
 
     void         unregister();
     void         registerVar();
 
-    // gets the current vector value (real time)
-    const Vector2D& vec() const {
-        return m_vValue;
-    }
-
-    // gets the current float value (real time)
-    const float& fl() const {
-        return m_fValue;
-    }
-
-    // gets the current color value (real time)
-    const CColor& col() const {
-        return m_cValue;
-    }
-
-    // gets the goal vector value
-    const Vector2D& goalv() const {
-        return m_vGoal;
-    }
-
-    // gets the goal float value
-    const float& goalf() const {
-        return m_fGoal;
-    }
-
-    // gets the goal color value
-    const CColor& goalc() const {
-        return m_cGoal;
-    }
-
-    CAnimatedVariable& operator=(const Vector2D& v) {
-        if (v == m_vGoal)
-            return *this;
-
-        m_vGoal        = v;
-        animationBegin = std::chrono::system_clock::now();
-        m_vBegun       = m_vValue;
-
-        onAnimationBegin();
-
-        return *this;
-    }
-
-    CAnimatedVariable& operator=(const float& v) {
-        if (v == m_fGoal)
-            return *this;
-
-        m_fGoal        = v;
-        animationBegin = std::chrono::system_clock::now();
-        m_fBegun       = m_fValue;
-
-        onAnimationBegin();
-
-        return *this;
-    }
-
-    CAnimatedVariable& operator=(const CColor& v) {
-        if (v == m_cGoal)
-            return *this;
-
-        m_cGoal        = v;
-        animationBegin = std::chrono::system_clock::now();
-        m_cBegun       = m_cValue;
-
-        onAnimationBegin();
-
-        return *this;
-    }
-
-    // Sets the actual stored value, without affecting the goal, but resets the timer
-    void setValue(const Vector2D& v) {
-        if (v == m_vValue)
-            return;
-
-        m_vValue       = v;
-        animationBegin = std::chrono::system_clock::now();
-        m_vBegun       = m_vValue;
-
-        onAnimationBegin();
-    }
-
-    // Sets the actual stored value, without affecting the goal, but resets the timer
-    void setValue(const float& v) {
-        if (v == m_fValue)
-            return;
-
-        m_fValue       = v;
-        animationBegin = std::chrono::system_clock::now();
-        m_vBegun       = m_vValue;
-
-        onAnimationBegin();
-    }
-
-    // Sets the actual stored value, without affecting the goal, but resets the timer
-    void setValue(const CColor& v) {
-        if (v == m_cValue)
-            return;
-
-        m_cValue       = v;
-        animationBegin = std::chrono::system_clock::now();
-        m_vBegun       = m_vValue;
-
-        onAnimationBegin();
-    }
-
-    // Sets the actual value and goal
-    void setValueAndWarp(const Vector2D& v) {
-        m_vGoal = v;
-        warp();
-    }
-
-    // Sets the actual value and goal
-    void setValueAndWarp(const float& v) {
-        m_fGoal = v;
-        warp();
-    }
-
-    // Sets the actual value and goal
-    void setValueAndWarp(const CColor& v) {
-        m_cGoal = v;
-        warp();
-    }
-
-    // checks if an animation is in progress
-    inline bool isBeingAnimated() {
-        return m_bIsBeingAnimated;
-    }
-
-    void warp(bool endCallback = true) {
-        switch (m_eVarType) {
-            case AVARTYPE_FLOAT: {
-                m_fValue = m_fGoal;
-                break;
-            }
-            case AVARTYPE_VECTOR: {
-                m_vValue = m_vGoal;
-                break;
-            }
-            case AVARTYPE_COLOR: {
-                m_cValue = m_cGoal;
-                break;
-            }
-            default: UNREACHABLE();
-        }
-
-        m_bIsBeingAnimated = false;
-
-        if (endCallback)
-            onAnimationEnd();
-    }
+    virtual void warp(bool endCallback = true) = 0;
 
+    //
     void setConfig(SAnimationPropertyConfig* pConfig) {
         m_pConfig = pConfig;
     }
@@ -212,6 +102,11 @@ class CAnimatedVariable {
     /* 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. */
@@ -245,22 +140,13 @@ class CAnimatedVariable {
         m_bRemoveEndAfterRan   = false;
     }
 
-  private:
-    Vector2D m_vValue = Vector2D(0, 0);
-    float    m_fValue = 0;
-    CColor   m_cValue;
+    CWindow* getWindow() {
+        return (CWindow*)m_pWindow;
+    }
 
-    Vector2D m_vGoal = Vector2D(0, 0);
-    float    m_fGoal = 0;
-    CColor   m_cGoal;
-
-    Vector2D m_vBegun = Vector2D(0, 0);
-    float    m_fBegun = 0;
-    CColor   m_cBegun;
-
-    // owners
+  protected:
     void*                                 m_pWindow = nullptr;
-    void*                                 m_pWorkspace = nullptr;
+    std::weak_ptr<CWorkspace>             m_pWorkspace;
     void*                                 m_pLayer = nullptr;
 
     SAnimationPropertyConfig*             m_pConfig = nullptr;
@@ -271,8 +157,8 @@ class CAnimatedVariable {
 
     std::chrono::system_clock::time_point animationBegin;
 
-    ANIMATEDVARTYPE                       m_eVarType      = AVARTYPE_INVALID;
     AVARDAMAGEPOLICY                      m_eDamagePolicy = AVARDAMAGE_NONE;
+    ANIMATEDVARTYPE                       m_Type;
 
     bool                                  m_bRemoveEndAfterRan   = true;
     bool                                  m_bRemoveBeginAfterRan = true;
@@ -281,7 +167,9 @@ class CAnimatedVariable {
     std::function<void(void* thisptr)>    m_fUpdateCallback;
 
     bool                                  m_bIsConnectedToActive = false;
+
     void                                  connectToActive();
+
     void                                  disconnectFromActive();
 
     // methods
@@ -314,3 +202,108 @@ class CAnimatedVariable {
     friend struct SLayerSurface;
     friend class CHyprRenderer;
 };
+
+template <Animable VarType>
+class CAnimatedVariable : public CBaseAnimatedVariable {
+  public:
+    CAnimatedVariable() : CBaseAnimatedVariable(typeToANIMATEDVARTYPE<VarType>) {} // dummy var
+
+    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, CWindow* pWindow, AVARDAMAGEPOLICY policy) {
+        create(pAnimConfig, pWindow, policy);
+        m_Value = value;
+        m_Goal  = value;
+    }
+    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, SLayerSurface* 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;
+    }
+
+    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::system_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::system_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 struct SLayerSurface;
+    friend class CHyprRenderer;
+};

src/helpers/Box.cpp

@@ -106,6 +106,11 @@ CBox& CBox::expand(const double& value) {
     w += value * 2.0;
     h += value * 2.0;
 
+    if (w <= 0 || h <= 0) {
+        w = 0;
+        h = 0;
+    }
+
     return *this;
 }
 
@@ -116,6 +121,22 @@ CBox& CBox::noNegativeSize() {
     return *this;
 }
 
+CBox CBox::intersection(const CBox other) const {
+    const float newX      = std::max(x, other.x);
+    const float newY      = std::max(y, other.y);
+    const float newBottom = std::min(y + h, other.y + other.h);
+    const float newRight  = std::min(x + w, other.x + other.w);
+    float       newW      = newRight - newX;
+    float       newH      = newBottom - newY;
+
+    if (newW <= 0 || newH <= 0) {
+        newW = 0;
+        newH = 0;
+    }
+
+    return {newX, newY, newW, newH};
+}
+
 CBox CBox::roundInternal() {
     float newW = x + w - std::floor(x);
     float newH = y + h - std::floor(y);

src/helpers/Box.hpp

@@ -54,6 +54,7 @@ class CBox {
     CBox&                    noNegativeSize();
 
     CBox                     copy() const;
+    CBox                     intersection(const CBox other) const;
 
     SWindowDecorationExtents extentsFrom(const CBox&); // this is the big box
 

src/helpers/Color.cpp

@@ -21,6 +21,6 @@ CColor::CColor(uint64_t hex) {
     this->a = ALPHA(hex);
 }
 
-uint64_t CColor::getAsHex() {
-    return ((int)a) * 0x1000000 + ((int)r) * 0x10000 + ((int)g) * 0x100 + ((int)b) * 0x1;
+uint32_t CColor::getAsHex() {
+    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;
 }

src/helpers/Color.hpp

@@ -10,7 +10,7 @@ class CColor {
 
     float    r = 0, g = 0, b = 0, a = 1.f;
 
-    uint64_t getAsHex();
+    uint32_t getAsHex();
 
     CColor   operator-(const CColor& c2) const {
         return CColor(r - c2.r, g - c2.g, b - c2.b, a - c2.a);

src/helpers/MiscFunctions.cpp

@@ -289,9 +289,9 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         if (!g_pCompositor->m_pLastMonitor)
             return WORKSPACE_INVALID;
 
-        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+        const auto PWORKSPACE = g_pCompositor->m_pLastMonitor->activeWorkspace;
 
-        if (!PWORKSPACE)
+        if (!valid(PWORKSPACE))
             return WORKSPACE_INVALID;
 
         const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PWORKSPACE->m_sPrevWorkspace.iID);
@@ -347,7 +347,8 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             std::sort(namedWSes.begin(), namedWSes.end());
 
             // Just take a blind guess at where we'll probably end up
-            int  predictedWSID = g_pCompositor->m_pLastMonitor->activeWorkspace + remains;
+            int  activeWSID    = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
+            int  predictedWSID = activeWSID + remains;
             int  remainingWSes = 0;
             char walkDir       = in[1];
 
@@ -355,20 +356,20 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             predictedWSID = std::max(predictedWSID, 0);
 
             // Count how many invalidWSes are in between (how bad the prediction was)
-            int  beginID = in[1] == '+' ? g_pCompositor->m_pLastMonitor->activeWorkspace + 1 : predictedWSID;
-            int  endID   = in[1] == '+' ? predictedWSID : g_pCompositor->m_pLastMonitor->activeWorkspace;
+            int  beginID = in[1] == '+' ? activeWSID + 1 : predictedWSID;
+            int  endID   = in[1] == '+' ? predictedWSID : activeWSID;
             auto begin   = invalidWSes.upper_bound(beginID - 1); // upper_bound is >, we want >=
             for (auto it = begin; *it <= endID && it != invalidWSes.end(); it++) {
                 remainingWSes++;
             }
 
             // Handle named workspaces. They are treated like always before other workspaces
-            if (g_pCompositor->m_pLastMonitor->activeWorkspace < 0) {
+            if (activeWSID < 0) {
                 // Behaviour similar to 'm'
                 // Find current
                 int currentItem = -1;
                 for (size_t i = 0; i < namedWSes.size(); i++) {
-                    if (namedWSes[i] == g_pCompositor->m_pLastMonitor->activeWorkspace) {
+                    if (namedWSes[i] == activeWSID) {
                         currentItem = i;
                         break;
                     }
@@ -473,9 +474,10 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
 
             // get the current item
+            int activeWSID  = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
             int currentItem = -1;
             for (size_t i = 0; i < validWSes.size(); i++) {
-                if (validWSes[i] == g_pCompositor->m_pLastMonitor->activeWorkspace) {
+                if (validWSes[i] == activeWSID) {
                     currentItem = i;
                     break;
                 }
@@ -496,7 +498,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         } else {
             if (in[0] == '+' || in[0] == '-') {
                 if (g_pCompositor->m_pLastMonitor) {
-                    const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspace);
+                    const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspaceID());
                     if (!PLUSMINUSRESULT.has_value())
                         return WORKSPACE_INVALID;
 
@@ -722,6 +724,32 @@ int64_t configStringToInt(const std::string& VALUE) {
     return std::stoll(VALUE);
 }
 
+Vector2D configStringToVector2D(const std::string& VALUE) {
+    std::istringstream iss(VALUE);
+    std::string        token;
+
+    if (!std::getline(iss, token, ' ') && !std::getline(iss, token, ','))
+        throw std::invalid_argument("Invalid string format");
+
+    if (!isNumber(token))
+        throw std::invalid_argument("Invalid x value");
+
+    long long x = std::stoll(token);
+
+    if (!std::getline(iss, token))
+        throw std::invalid_argument("Invalid string format");
+
+    if (!isNumber(token))
+        throw std::invalid_argument("Invalid y value");
+
+    long long y = std::stoll(token);
+
+    if (std::getline(iss, token))
+        throw std::invalid_argument("Invalid string format");
+
+    return Vector2D(x, y);
+}
+
 double normalizeAngleRad(double ang) {
     if (ang > M_PI * 2) {
         while (ang > M_PI * 2)

src/helpers/MiscFunctions.hpp

@@ -28,6 +28,7 @@ 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);
 void                             matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
 double                           normalizeAngleRad(double ang);

src/helpers/Monitor.cpp

@@ -1,7 +1,11 @@
 #include "Monitor.hpp"
 
+#include "MiscFunctions.hpp"
+
 #include "../Compositor.hpp"
 
+#include "../config/ConfigValue.hpp"
+
 int ratHandler(void* data) {
     g_pHyprRenderer->renderMonitor((CMonitor*)data);
 
@@ -52,13 +56,18 @@ void CMonitor::onConnect(bool noRule) {
 
     szDescription = output->description ? output->description : "";
     // remove comma character from description. This allow monitor specific rules to work on monitor with comma on their description
-    szDescription.erase(std::remove(szDescription.begin(), szDescription.end(), ','), szDescription.end());
+    std::erase(szDescription, ',');
+
+    // field is backwards-compatible with intended usage of `szDescription` but excludes the parenthesized DRM node name suffix
+    szShortDescription =
+        removeBeginEndSpacesTabs(std::format("{} {} {}", output->make ? output->make : "", output->model ? output->model : "", output->serial ? output->serial : ""));
+    std::erase(szShortDescription, ',');
 
     if (!wlr_backend_is_drm(output->backend))
         createdByUser = true; // should be true. WL, X11 and Headless backends should be addable / removable
 
     // get monitor rule that matches
-    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(output->name, output->description ? output->description : "");
+    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(*this);
 
     // if it's disabled, disable and ignore
     if (monitorRule.disabled) {
@@ -136,20 +145,35 @@ void CMonitor::onConnect(bool noRule) {
     if (!noRule)
         g_pHyprRenderer->applyMonitorRule(this, &monitorRule, true);
 
+    for (const auto& PTOUCHDEV : g_pInputManager->m_lTouchDevices) {
+        if (matchesStaticSelector(PTOUCHDEV.boundOutput)) {
+            Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV.name, szName);
+            wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, PTOUCHDEV.pWlrDevice, output);
+        }
+    }
+
+    for (const auto& PTABLET : g_pInputManager->m_lTablets) {
+        if (matchesStaticSelector(PTABLET.boundOutput)) {
+            Debug::log(LOG, "Binding tablet {} to output {}", PTABLET.name, szName);
+            wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, PTABLET.wlrDevice, output);
+        }
+    }
+
     if (!state.commit())
         Debug::log(WARN, "wlr_output_commit_state failed in CMonitor::onCommit");
 
     wlr_damage_ring_set_bounds(&damage, vecTransformedSize.x, vecTransformedSize.y);
 
-    wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
-
     Debug::log(LOG, "Added new monitor with name {} at {:j0} with size {:j0}, pointer {:x}", output->name, vecPosition, vecPixelSize, (uintptr_t)output);
 
     setupDefaultWS(monitorRule);
 
     for (auto& ws : g_pCompositor->m_vWorkspaces) {
+        if (!valid(ws))
+            continue;
+
         if (ws->m_szLastMonitor == szName || g_pCompositor->m_vMonitors.size() == 1 /* avoid lost workspaces on recover */) {
-            g_pCompositor->moveWorkspaceToMonitor(ws.get(), this);
+            g_pCompositor->moveWorkspaceToMonitor(ws, this);
             ws->startAnim(true, true, true);
             ws->m_szLastMonitor = "";
         }
@@ -163,13 +187,12 @@ void CMonitor::onConnect(bool noRule) {
     //
 
     g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoraddedv2", std::format("{},{},{}", ID, szName, szShortDescription)});
     EMIT_HOOK_EVENT("monitorAdded", this);
 
     if (!g_pCompositor->m_pLastMonitor) // set the last monitor if it isnt set yet
         g_pCompositor->setActiveMonitor(this);
 
-    wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
-
     g_pHyprRenderer->arrangeLayersForMonitor(ID);
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
@@ -261,10 +284,10 @@ void CMonitor::onDisconnect(bool destroy) {
                         BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
 
         // move workspaces
-        std::deque<CWorkspace*> wspToMove;
+        std::deque<PHLWORKSPACE> wspToMove;
         for (auto& w : g_pCompositor->m_vWorkspaces) {
             if (w->m_iMonitorID == ID || !g_pCompositor->getMonitorFromID(w->m_iMonitorID)) {
-                wspToMove.push_back(w.get());
+                wspToMove.push_back(w);
             }
         }
 
@@ -279,7 +302,9 @@ void CMonitor::onDisconnect(bool destroy) {
         g_pCompositor->m_pLastMonitor = nullptr;
     }
 
-    activeWorkspace = -1;
+    if (activeWorkspace)
+        activeWorkspace->m_bVisible = false;
+    activeWorkspace.reset();
 
     if (!destroy)
         wlr_output_layout_remove(g_pCompositor->m_sWLROutputLayout, output);
@@ -290,7 +315,7 @@ void CMonitor::onDisconnect(bool destroy) {
         Debug::log(WARN, "wlr_output_commit_state failed in CMonitor::onDisconnect");
 
     if (g_pCompositor->m_pLastMonitor == this)
-        g_pCompositor->setActiveMonitor(BACKUPMON);
+        g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_pUnsafeOutput);
 
     if (g_pHyprRenderer->m_pMostHzMonitor == this) {
         int       mostHz         = 0;
@@ -309,13 +334,11 @@ void CMonitor::onDisconnect(bool destroy) {
 }
 
 void CMonitor::addDamage(const pixman_region32_t* rg) {
-    static auto* const PZOOMFACTOR = &g_pConfigManager->getConfigValuePtr("misc:cursor_zoom_factor")->floatValue;
+    static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("misc:cursor_zoom_factor");
     if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == this) {
         wlr_damage_ring_add_whole(&damage);
         g_pCompositor->scheduleFrameForMonitor(this);
-    }
-
-    if (wlr_damage_ring_add(&damage, rg))
+    } else if (wlr_damage_ring_add(&damage, rg))
         g_pCompositor->scheduleFrameForMonitor(this);
 }
 
@@ -324,7 +347,7 @@ void CMonitor::addDamage(const CRegion* rg) {
 }
 
 void CMonitor::addDamage(const CBox* box) {
-    static auto* const PZOOMFACTOR = &g_pConfigManager->getConfigValuePtr("misc:cursor_zoom_factor")->floatValue;
+    static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("misc:cursor_zoom_factor");
     if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == this) {
         wlr_damage_ring_add_whole(&damage);
         g_pCompositor->scheduleFrameForMonitor(this);
@@ -338,6 +361,18 @@ bool CMonitor::isMirror() {
     return pMirrorOf != nullptr;
 }
 
+bool CMonitor::matchesStaticSelector(const std::string& selector) const {
+    if (selector.starts_with("desc:")) {
+        // match by description
+        const auto DESCRIPTIONSELECTOR = selector.substr(5);
+
+        return DESCRIPTIONSELECTOR == szShortDescription || DESCRIPTIONSELECTOR == szDescription;
+    } else {
+        // match by selector
+        return szName == selector;
+    }
+}
+
 int CMonitor::findAvailableDefaultWS() {
     for (size_t i = 1; i < INT32_MAX; ++i) {
         if (g_pCompositor->getWorkspaceByID(i))
@@ -373,21 +408,20 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
     if (PNEWWORKSPACE) {
         // workspace exists, move it to the newly connected monitor
         g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, this);
-        activeWorkspace = PNEWWORKSPACE->m_iID;
+        activeWorkspace = PNEWWORKSPACE;
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
         PNEWWORKSPACE->startAnim(true, true, true);
     } else {
         if (newDefaultWorkspaceName == "")
             newDefaultWorkspaceName = std::to_string(WORKSPACEID);
 
-        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(ID, newDefaultWorkspaceName)).get();
-
-        PNEWWORKSPACE->m_iID = WORKSPACEID;
+        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(CWorkspace::create(WORKSPACEID, ID, newDefaultWorkspaceName));
     }
 
-    activeWorkspace = PNEWWORKSPACE->m_iID;
+    activeWorkspace = PNEWWORKSPACE;
 
     PNEWWORKSPACE->setActive(true);
+    PNEWWORKSPACE->m_bVisible      = true;
     PNEWWORKSPACE->m_szLastMonitor = "";
 }
 
@@ -417,7 +451,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         pMirrorOf = nullptr;
 
         // set rule
-        const auto RULE = g_pConfigManager->getMonitorRuleFor(this->szName, this->output->description ? this->output->description : "");
+        const auto RULE = g_pConfigManager->getMonitorRuleFor(*this);
 
         vecPosition = RULE.offset;
 
@@ -453,10 +487,10 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         }
 
         // move all the WS
-        std::deque<CWorkspace*> wspToMove;
+        std::deque<PHLWORKSPACE> wspToMove;
         for (auto& w : g_pCompositor->m_vWorkspaces) {
             if (w->m_iMonitorID == ID) {
-                wspToMove.push_back(w.get());
+                wspToMove.push_back(w);
             }
         }
 
@@ -465,7 +499,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
             w->startAnim(true, true, true);
         }
 
-        activeWorkspace = -1;
+        activeWorkspace.reset();
 
         wlr_output_layout_remove(g_pCompositor->m_sWLROutputLayout, output);
 
@@ -504,24 +538,26 @@ float CMonitor::getDefaultScale() {
     return 1;
 }
 
-void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal, bool noMouseMove, bool noFocus) {
+void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bool noMouseMove, bool noFocus) {
     if (!pWorkspace)
         return;
 
     if (pWorkspace->m_bIsSpecialWorkspace) {
-        if (specialWorkspaceID != pWorkspace->m_iID) {
+        if (activeSpecialWorkspace != pWorkspace) {
             Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id {}", pWorkspace->m_iID);
-            g_pKeybindManager->m_mDispatchers["togglespecialworkspace"](pWorkspace->m_szName == "special" ? "" : pWorkspace->m_szName);
+            setSpecialWorkspace(pWorkspace);
         }
         return;
     }
 
-    if (pWorkspace->m_iID == activeWorkspace)
+    if (pWorkspace == activeWorkspace)
         return;
 
-    const auto POLDWORKSPACE = g_pCompositor->getWorkspaceByID(activeWorkspace);
+    const auto POLDWORKSPACE  = activeWorkspace;
+    POLDWORKSPACE->m_bVisible = false;
+    pWorkspace->m_bVisible    = true;
 
-    activeWorkspace = pWorkspace->m_iID;
+    activeWorkspace = pWorkspace;
 
     if (!internal) {
         const auto ANIMTOLEFT = pWorkspace->m_iID > POLDWORKSPACE->m_iID;
@@ -530,13 +566,13 @@ void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal, bool
 
         // move pinned windows
         for (auto& w : g_pCompositor->m_vWindows) {
-            if (w->m_iWorkspaceID == POLDWORKSPACE->m_iID && w->m_bPinned) {
-                w->m_iWorkspaceID = pWorkspace->m_iID;
-            }
+            if (w->m_pWorkspace == POLDWORKSPACE && w->m_bPinned)
+                w->moveToWorkspace(pWorkspace);
         }
 
-        if (!noFocus && !g_pCompositor->m_pLastMonitor->specialWorkspaceID) {
-            static auto* const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
+        if (!noFocus && !g_pCompositor->m_pLastMonitor->activeSpecialWorkspace &&
+            !(g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+            static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
             CWindow*    pWindow      = pWorkspace->getLastFocusedWindow();
 
             if (!pWindow) {
@@ -559,6 +595,7 @@ void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal, bool
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
         g_pEventManager->postEvent(SHyprIPCEvent{"workspace", pWorkspace->m_szName});
+        g_pEventManager->postEvent(SHyprIPCEvent{"workspacev2", std::format("{},{}", pWorkspace->m_iID, pWorkspace->m_szName)});
         EMIT_HOOK_EVENT("workspace", pWorkspace);
     }
 
@@ -569,71 +606,86 @@ void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal, bool
     g_pConfigManager->ensureVRR(this);
 
     g_pCompositor->updateSuspendedStates();
+
+    if (activeSpecialWorkspace)
+        g_pCompositor->updateFullscreenFadeOnWorkspace(activeSpecialWorkspace);
 }
 
-void CMonitor::changeWorkspace(const int& id, bool internal) {
-    changeWorkspace(g_pCompositor->getWorkspaceByID(id), internal);
+void CMonitor::changeWorkspace(const int& id, bool internal, bool noMouseMove, bool noFocus) {
+    changeWorkspace(g_pCompositor->getWorkspaceByID(id), internal, noMouseMove, noFocus);
 }
 
-void CMonitor::setSpecialWorkspace(CWorkspace* const pWorkspace) {
+void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
     g_pHyprRenderer->damageMonitor(this);
 
     if (!pWorkspace) {
         // remove special if exists
-        if (const auto EXISTINGSPECIAL = g_pCompositor->getWorkspaceByID(specialWorkspaceID); EXISTINGSPECIAL) {
-            EXISTINGSPECIAL->startAnim(false, false);
+        if (activeSpecialWorkspace) {
+            activeSpecialWorkspace->m_bVisible = false;
+            activeSpecialWorkspace->startAnim(false, false);
             g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + szName});
         }
-        specialWorkspaceID = 0;
+        activeSpecialWorkspace.reset();
 
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(activeWorkspace);
-        if (const auto PLAST = PWORKSPACE->getLastFocusedWindow(); PLAST)
+        if (!(g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+            if (const auto PLAST = activeWorkspace->getLastFocusedWindow(); PLAST)
                 g_pCompositor->focusWindow(PLAST);
             else
                 g_pInputManager->refocus();
+        }
+
+        g_pCompositor->updateFullscreenFadeOnWorkspace(activeWorkspace);
+
+        g_pConfigManager->ensureVRR(this);
 
         g_pCompositor->updateSuspendedStates();
 
         return;
     }
 
-    if (specialWorkspaceID) {
-        if (const auto EXISTINGSPECIAL = g_pCompositor->getWorkspaceByID(specialWorkspaceID); EXISTINGSPECIAL)
-            EXISTINGSPECIAL->startAnim(false, false);
+    if (activeSpecialWorkspace) {
+        activeSpecialWorkspace->m_bVisible = false;
+        activeSpecialWorkspace->startAnim(false, false);
     }
 
     bool animate = true;
     //close if open elsewhere
     const auto PMONITORWORKSPACEOWNER = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
-    if (PMONITORWORKSPACEOWNER->specialWorkspaceID == pWorkspace->m_iID) {
-        PMONITORWORKSPACEOWNER->specialWorkspaceID = 0;
+    if (PMONITORWORKSPACEOWNER->activeSpecialWorkspace == pWorkspace) {
+        PMONITORWORKSPACEOWNER->activeSpecialWorkspace.reset();
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITORWORKSPACEOWNER->ID);
         g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMONITORWORKSPACEOWNER->szName});
+
+        const auto PACTIVEWORKSPACE = PMONITORWORKSPACEOWNER->activeWorkspace;
+        g_pCompositor->updateFullscreenFadeOnWorkspace(PACTIVEWORKSPACE);
+
         animate = false;
     }
 
     // open special
     pWorkspace->m_iMonitorID           = ID;
-    specialWorkspaceID       = pWorkspace->m_iID;
+    activeSpecialWorkspace             = pWorkspace;
+    activeSpecialWorkspace->m_bVisible = true;
     if (animate)
         pWorkspace->startAnim(true, true);
 
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_iWorkspaceID == pWorkspace->m_iID) {
+        if (w->m_pWorkspace == pWorkspace) {
             w->m_iMonitorID = ID;
             w->updateSurfaceScaleTransformDetails();
+            w->setAnimationsToMove();
 
             const auto MIDDLE = w->middle();
             if (w->m_bIsFloating && !VECINRECT(MIDDLE, vecPosition.x, vecPosition.y, vecPosition.x + vecSize.x, vecPosition.y + vecSize.y) && w->m_iX11Type != 2) {
                 // 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.goalv();
+                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.goalv() / 2.f;
+                    pos = middle() / 2.f - w->m_vRealSize.goal() / 2.f;
                 } else
                     pos = pos - PMONFROMMIDDLE->vecPosition + vecPosition;
 
@@ -645,15 +697,21 @@ void CMonitor::setSpecialWorkspace(CWorkspace* const pWorkspace) {
 
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
+    if (!(g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
         if (const auto PLAST = pWorkspace->getLastFocusedWindow(); PLAST)
             g_pCompositor->focusWindow(PLAST);
         else
             g_pInputManager->refocus();
+    }
 
     g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_szName + "," + szName});
 
     g_pHyprRenderer->damageMonitor(this);
 
+    g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
+
+    g_pConfigManager->ensureVRR(this);
+
     g_pCompositor->updateSuspendedStates();
 }
 
@@ -681,6 +739,13 @@ void CMonitor::updateMatrix() {
     }
 }
 
+int64_t CMonitor::activeWorkspaceID() {
+    return activeWorkspace ? activeWorkspace->m_iID : 0;
+}
+int64_t CMonitor::activeSpecialWorkspaceID() {
+    return activeSpecialWorkspace ? activeSpecialWorkspace->m_iID : 0;
+}
+
 CMonitorState::CMonitorState(CMonitor* owner) {
     m_pOwner = owner;
     wlr_output_state_init(&m_state);

src/helpers/Monitor.hpp

@@ -58,12 +58,14 @@ class CMonitor {
     bool            primary = false;
 
     uint64_t        ID                     = -1;
-    int             activeWorkspace = -1;
+    PHLWORKSPACE    activeWorkspace        = nullptr;
+    PHLWORKSPACE    activeSpecialWorkspace = nullptr;
     float           setScale               = 1; // scale set by cfg
     float           scale                  = 1; // real scale
 
     std::string     szName             = "";
     std::string     szDescription      = "";
+    std::string     szShortDescription = "";
 
     Vector2D        vecReservedTopLeft     = Vector2D(0, 0);
     Vector2D        vecReservedBottomRight = Vector2D(0, 0);
@@ -84,6 +86,7 @@ class CMonitor {
     bool                    gammaChanged    = false;
     float                   xwaylandScale   = 1.f;
     std::array<float, 9>    projMatrix      = {0};
+    std::optional<Vector2D> forceSize;
 
     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.
@@ -105,8 +108,6 @@ class CMonitor {
     CMonitor*              pMirrorOf = nullptr;
     std::vector<CMonitor*> mirrors;
 
-    CRegion                lastFrameDamage; // stores last frame damage
-
     // for tearing
     CWindow* solitaryClient = nullptr;
 
@@ -119,9 +120,6 @@ class CMonitor {
         bool frameScheduledWhileBusy = false;
     } tearingState;
 
-    // for the special workspace. 0 means not open.
-    int                                                        specialWorkspaceID = 0;
-
     std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4> m_aLayerSurfaceLayers;
 
     DYNLISTENER(monitorFrame);
@@ -140,14 +138,17 @@ class CMonitor {
     void     addDamage(const CBox* box);
     void     setMirror(const std::string&);
     bool     isMirror();
+    bool     matchesStaticSelector(const std::string& selector) const;
     float    getDefaultScale();
-    void     changeWorkspace(CWorkspace* const pWorkspace, bool internal = false, bool noMouseMove = false, bool noFocus = false);
-    void     changeWorkspace(const int& id, bool internal = false);
-    void     setSpecialWorkspace(CWorkspace* const pWorkspace);
+    void     changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal = false, bool noMouseMove = false, bool noFocus = false);
+    void     changeWorkspace(const int& id, bool internal = false, bool noMouseMove = false, bool noFocus = false);
+    void     setSpecialWorkspace(const PHLWORKSPACE& pWorkspace);
     void     setSpecialWorkspace(const int& id);
     void     moveTo(const Vector2D& pos);
     Vector2D middle();
     void     updateMatrix();
+    int64_t  activeWorkspaceID();
+    int64_t  activeSpecialWorkspaceID();
 
     bool     m_bEnabled             = false;
     bool     m_bRenderingInitPassed = false;

src/helpers/Region.cpp

@@ -112,6 +112,11 @@ CRegion& CRegion::scale(float scale) {
     return *this;
 }
 
+CRegion& CRegion::scale(const Vector2D& scale) {
+    wlr_region_scale_xy(&m_rRegion, &m_rRegion, scale.x, scale.y);
+    return *this;
+}
+
 std::vector<pixman_box32_t> CRegion::getRects() const {
     std::vector<pixman_box32_t> result;
 

src/helpers/Region.hpp

@@ -49,6 +49,7 @@ class CRegion {
     CRegion&                    invert(pixman_box32_t* box);
     CRegion&                    invert(const CBox& box);
     CRegion&                    scale(float scale);
+    CRegion&                    scale(const Vector2D& scale);
     CBox                        getExtents();
     bool                        containsPoint(const Vector2D& vec) const;
     bool                        empty() const;
@@ -57,6 +58,7 @@ class CRegion {
 
     std::vector<pixman_box32_t> getRects() const;
 
+    //
     pixman_region32_t* pixman() {
         return &m_rRegion;
     }

src/helpers/Splashes.hpp

@@ -75,6 +75,8 @@ inline const std::vector<std::string> SPLASHES = {
     "Join the discord server!",
     "Thanks ThatOneCalculator!",
     "The AUR packages always work, except for the times they don't.",
-    "Funny animation compositor woo"
+    "Funny animation compositor woo",
+    //
+    "2 years!"
     // clang-format on
 };

src/helpers/SubsurfaceTree.cpp

@@ -1,312 +0,0 @@
-#include "SubsurfaceTree.hpp"
-#include "../events/Events.hpp"
-#include "../Compositor.hpp"
-
-void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
-    if (!node->pSurface || !node->pSurface->exists())
-        return;
-
-    *lx += node->pSurface->wlr()->current.dx;
-    *ly += node->pSurface->wlr()->current.dy;
-
-    if (node->offsetfn) {
-        // This is the root node
-        RASSERT(!node->pSubsurface, "Node had no subsurface!");
-        node->offsetfn(node->globalOffsetData, lx, ly);
-    } else {
-        RASSERT(node->pSubsurface, "Node had no subsurface!");
-
-        *lx += node->pSubsurface->pSubsurface->current.x;
-        *ly += node->pSubsurface->pSubsurface->current.y;
-
-        addSurfaceGlobalOffset(node->pParent, lx, ly);
-    }
-}
-
-SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
-    const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.emplace_back();
-
-    if (pSurface->data)
-        PNODE->pSurface = (CWLSurface*)pSurface->data;
-    else {
-        PNODE->pInternalSurface = pSurface;
-        PNODE->pSurface         = &PNODE->pInternalSurface;
-    }
-
-    PNODE->pWindowOwner = pWindow;
-
-    PNODE->hyprListener_newSubsurface.initCallback(&pSurface->events.new_subsurface, &Events::listener_newSubsurfaceNode, PNODE, "SurfaceTreeNode");
-    PNODE->hyprListener_commit.initCallback(&pSurface->events.commit, &Events::listener_commitSubsurface, PNODE, "SurfaceTreeNode");
-    PNODE->hyprListener_destroy.initCallback(&pSurface->events.destroy, &Events::listener_destroySubsurfaceNode, PNODE, "SurfaceTreeNode");
-
-    wlr_subsurface* wlrSubsurface;
-    wl_list_for_each(wlrSubsurface, &pSurface->current.subsurfaces_below, current.link) {
-        Events::listener_newSubsurfaceNode(PNODE, wlrSubsurface);
-    }
-    wl_list_for_each(wlrSubsurface, &pSurface->current.subsurfaces_above, current.link) {
-        Events::listener_newSubsurfaceNode(PNODE, wlrSubsurface);
-    }
-
-    return PNODE;
-}
-
-SSurfaceTreeNode* createSubsurfaceNode(SSurfaceTreeNode* pParent, SSubsurface* pSubsurface, wlr_surface* surface, CWindow* pWindow) {
-    const auto PNODE   = createTree(surface, pWindow);
-    PNODE->pParent     = pParent;
-    PNODE->pSubsurface = pSubsurface;
-
-    Debug::log(LOG, "Creating a subsurface Node! {}", pWindow);
-
-    return PNODE;
-}
-
-SSurfaceTreeNode* SubsurfaceTree::createTreeRoot(wlr_surface* pSurface, applyGlobalOffsetFn fn, void* data, CWindow* pWindow) {
-    const auto PNODE = createTree(pSurface, pWindow);
-
-    Debug::log(LOG, "Creating a surfaceTree Root! {}", pWindow);
-
-    PNODE->offsetfn         = fn;
-    PNODE->globalOffsetData = data;
-
-    return PNODE;
-}
-
-void destroySubsurface(SSubsurface* pSubsurface);
-
-void SubsurfaceTree::destroySurfaceTree(SSurfaceTreeNode* pNode) {
-    bool exists = false;
-    for (auto& n : surfaceTreeNodes) {
-        if (&n == pNode) {
-            exists = true;
-            break;
-        }
-    }
-
-    if (!exists) {
-        Debug::log(ERR, "Tried to remove a SurfaceTreeNode that doesn't exist?? (Node {:x})", (uintptr_t)pNode);
-        return;
-    }
-
-    for (auto& c : pNode->childSubsurfaces)
-        destroySubsurface(&c);
-
-    pNode->childSubsurfaces.clear();
-
-    pNode->hyprListener_commit.removeCallback();
-    pNode->hyprListener_destroy.removeCallback();
-    pNode->hyprListener_newSubsurface.removeCallback();
-
-    // damage
-    if (pNode->pSurface && pNode->pSurface->exists()) {
-        CBox extents = {};
-        wlr_surface_get_extends(pNode->pSurface->wlr(), extents.pWlr());
-        extents.applyFromWlr();
-
-        int lx = 0, ly = 0;
-        addSurfaceGlobalOffset(pNode, &lx, &ly);
-
-        extents.x += lx;
-        extents.y += ly;
-
-        g_pHyprRenderer->damageBox(&extents);
-    }
-
-    // remove references to this node
-    for (auto& tn : surfaceTreeNodes) {
-        for (auto& cs : tn.childSubsurfaces) {
-            if (cs.pChild == pNode)
-                cs.pChild = nullptr;
-        }
-    }
-
-    surfaceTreeNodes.remove(*pNode);
-
-    Debug::log(LOG, "SurfaceTree Node removed");
-}
-
-void destroySubsurface(SSubsurface* pSubsurface) {
-    if (pSubsurface->pChild) {
-        SubsurfaceTree::destroySurfaceTree(pSubsurface->pChild);
-        pSubsurface->pChild = nullptr;
-    }
-
-    pSubsurface->hyprListener_destroy.removeCallback();
-    pSubsurface->hyprListener_map.removeCallback();
-    pSubsurface->hyprListener_unmap.removeCallback();
-}
-
-//
-// Subsurface listeners
-//
-
-void Events::listener_newSubsurfaceNode(void* owner, void* data) {
-    SSurfaceTreeNode* pNode = (SSurfaceTreeNode*)owner;
-
-    const auto        PSUBSURFACE = (wlr_subsurface*)data;
-
-    const auto        PNEWSUBSURFACE = &pNode->childSubsurfaces.emplace_back();
-
-    Debug::log(LOG, "Added a new subsurface {:x}", (uintptr_t)PSUBSURFACE);
-
-    PNEWSUBSURFACE->pSubsurface = PSUBSURFACE;
-    PNEWSUBSURFACE->pParent     = pNode;
-
-    PNEWSUBSURFACE->hyprListener_map.initCallback(&PSUBSURFACE->surface->events.map, &Events::listener_mapSubsurface, PNEWSUBSURFACE, "Subsurface");
-    PNEWSUBSURFACE->hyprListener_unmap.initCallback(&PSUBSURFACE->surface->events.unmap, &Events::listener_unmapSubsurface, PNEWSUBSURFACE, "Subsurface");
-    PNEWSUBSURFACE->hyprListener_destroy.initCallback(&PSUBSURFACE->events.destroy, &Events::listener_destroySubsurface, PNEWSUBSURFACE, "Subsurface");
-
-    PNEWSUBSURFACE->pWindowOwner = pNode->pWindowOwner;
-
-    if (PSUBSURFACE->surface->mapped)
-        listener_mapSubsurface(PNEWSUBSURFACE, nullptr);
-
-    wlr_subsurface* existingWlrSubsurface;
-    wl_list_for_each(existingWlrSubsurface, &PSUBSURFACE->surface->current.subsurfaces_below, current.link) {
-        listener_newSubsurfaceNode(pNode, existingWlrSubsurface);
-    }
-    wl_list_for_each(existingWlrSubsurface, &PSUBSURFACE->surface->current.subsurfaces_above, current.link) {
-        listener_newSubsurfaceNode(pNode, existingWlrSubsurface);
-    }
-}
-
-void Events::listener_mapSubsurface(void* owner, void* data) {
-    SSubsurface* subsurface = (SSubsurface*)owner;
-
-    if (subsurface->pChild)
-        return;
-
-    Debug::log(LOG, "Subsurface {:x} mapped", (uintptr_t)subsurface->pSubsurface);
-
-    subsurface->pChild = createSubsurfaceNode(subsurface->pParent, subsurface, subsurface->pSubsurface->surface, subsurface->pWindowOwner);
-
-    if (subsurface->pWindowOwner)
-        subsurface->pWindowOwner->updateSurfaceScaleTransformDetails();
-}
-
-void Events::listener_unmapSubsurface(void* owner, void* data) {
-    SSubsurface* subsurface = (SSubsurface*)owner;
-
-    Debug::log(LOG, "Subsurface {:x} unmapped", (uintptr_t)subsurface);
-
-    if (subsurface->pSubsurface->surface == g_pCompositor->m_pLastFocus)
-        g_pInputManager->releaseAllMouseButtons();
-
-    if (subsurface->pChild) {
-        const auto PNODE = subsurface->pChild;
-
-        const auto IT =
-            std::find_if(SubsurfaceTree::surfaceTreeNodes.begin(), SubsurfaceTree::surfaceTreeNodes.end(), [&](const SSurfaceTreeNode& other) { return &other == PNODE; });
-
-        if (IT != SubsurfaceTree::surfaceTreeNodes.end()) {
-            if (PNODE->pSurface && PNODE->pSurface->exists()) {
-                int lx = 0, ly = 0;
-                addSurfaceGlobalOffset(PNODE, &lx, &ly);
-
-                CBox extents = {lx, ly, 0, 0};
-
-                extents.width  = PNODE->pSurface->wlr()->current.width;
-                extents.height = PNODE->pSurface->wlr()->current.height;
-
-                g_pHyprRenderer->damageBox(&extents);
-            }
-
-            // SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
-            // subsurface->pChild = nullptr;
-        }
-    }
-
-    g_pInputManager->simulateMouseMovement(); // to focus and return back to an appropriate surface
-}
-
-void Events::listener_commitSubsurface(void* owner, void* data) {
-    SSurfaceTreeNode* pNode = (SSurfaceTreeNode*)owner;
-
-    // no damaging if it's not visible
-    if (!g_pHyprRenderer->shouldRenderWindow(pNode->pWindowOwner)) {
-        pNode->lastSize = pNode->pSurface->exists() ? Vector2D{pNode->pSurface->wlr()->current.width, pNode->pSurface->wlr()->current.height} : Vector2D{};
-
-        static auto* const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
-        if (*PLOGDAMAGE)
-            Debug::log(LOG, "Refusing to commit damage from {} because it's invisible.", pNode->pWindowOwner);
-        return;
-    }
-
-    int lx = 0, ly = 0;
-
-    addSurfaceGlobalOffset(pNode, &lx, &ly);
-
-    const double SCALE = pNode->pWindowOwner && pNode->pWindowOwner->m_bIsX11 ? 1.0 / pNode->pWindowOwner->m_fX11SurfaceScaledBy : 1.0;
-
-    // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
-    // What this does is that basically, if the pNode is a child of some other node, on commit,
-    // it will also damage (check & damage if needed) all its siblings.
-    if (pNode->pParent)
-        for (auto& cs : pNode->pParent->childSubsurfaces) {
-            const auto NODECOORDS = pNode->pSubsurface ? Vector2D(pNode->pSubsurface->pSubsurface->current.x, pNode->pSubsurface->pSubsurface->current.y) : Vector2D();
-
-            if (&cs != pNode->pSubsurface && cs.pSubsurface) {
-                g_pHyprRenderer->damageSurface(cs.pSubsurface->surface, lx - NODECOORDS.x + cs.pSubsurface->current.x, ly - NODECOORDS.y + cs.pSubsurface->current.y, SCALE);
-            }
-        }
-
-    if (pNode->pSurface && pNode->pSurface->exists()) {
-        g_pHyprRenderer->damageSurface(pNode->pSurface->wlr(), lx, ly, SCALE);
-
-        if (pNode->lastSize != Vector2D{pNode->pSurface->wlr()->current.width, pNode->pSurface->wlr()->current.height} && pNode->pWindowOwner)
-            g_pHyprRenderer->damageWindow(pNode->pWindowOwner);
-    }
-
-    if (pNode->pWindowOwner) {
-        if (pNode->pWindowOwner->m_bIsX11)
-            pNode->pWindowOwner->m_vReportedSize = pNode->pWindowOwner->m_vPendingReportedSize; // apply pending size. We pinged, the window ponged.
-
-        // tearing: if solitary, redraw it. This still might be a single surface window
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(pNode->pWindowOwner->m_iMonitorID);
-        if (PMONITOR && PMONITOR->solitaryClient == pNode->pWindowOwner && pNode->pWindowOwner->canBeTorn() && PMONITOR->tearingState.canTear &&
-            pNode->pSurface->wlr()->current.committed & WLR_SURFACE_STATE_BUFFER) {
-            CRegion damageBox{&pNode->pSurface->wlr()->buffer_damage};
-
-            if (!damageBox.empty()) {
-                if (PMONITOR->tearingState.busy) {
-                    PMONITOR->tearingState.frameScheduledWhileBusy = true;
-                } else {
-                    PMONITOR->tearingState.nextRenderTorn = true;
-                    g_pHyprRenderer->renderMonitor(PMONITOR);
-                }
-            }
-        }
-    }
-
-    pNode->lastSize = pNode->pSurface->exists() ? Vector2D{pNode->pSurface->wlr()->current.width, pNode->pSurface->wlr()->current.height} : Vector2D{};
-}
-
-void Events::listener_destroySubsurface(void* owner, void* data) {
-    SSubsurface* subsurface = (SSubsurface*)owner;
-
-    if (subsurface->pChild) {
-        SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
-    }
-
-    Debug::log(LOG, "Subsurface {:x} destroyed", (uintptr_t)subsurface);
-
-    subsurface->hyprListener_destroy.removeCallback();
-    subsurface->hyprListener_map.removeCallback();
-    subsurface->hyprListener_unmap.removeCallback();
-
-    subsurface->pParent->childSubsurfaces.remove(*subsurface);
-}
-
-void Events::listener_destroySubsurfaceNode(void* owner, void* data) {
-    SSurfaceTreeNode* pNode = (SSurfaceTreeNode*)owner;
-
-    Debug::log(LOG, "Subsurface Node {:x} destroyed", (uintptr_t)pNode);
-
-    for (auto& c : pNode->childSubsurfaces)
-        destroySubsurface(&c);
-
-    pNode->hyprListener_commit.removeCallback();
-    pNode->hyprListener_newSubsurface.removeCallback();
-    pNode->hyprListener_destroy.removeCallback();
-
-    SubsurfaceTree::surfaceTreeNodes.remove(*pNode);
-}

src/helpers/SubsurfaceTree.hpp

@@ -1,60 +0,0 @@
-#pragma once
-
-#include "../defines.hpp"
-#include <list>
-#include "WLSurface.hpp"
-
-struct SSubsurface;
-class CWindow;
-
-typedef void (*applyGlobalOffsetFn)(void*, int*, int*);
-
-struct SSurfaceTreeNode {
-    CWLSurface* pSurface = nullptr; // actual surface
-    CWLSurface  pInternalSurface;   // not present for head nodes to not dupe wlr_surface ownership
-
-    DYNLISTENER(newSubsurface);
-    DYNLISTENER(commit);
-    DYNLISTENER(destroy);
-
-    SSurfaceTreeNode*      pParent     = nullptr;
-    SSubsurface*           pSubsurface = nullptr;
-
-    std::list<SSubsurface> childSubsurfaces;
-
-    applyGlobalOffsetFn    offsetfn;
-    void*                  globalOffsetData;
-    CWindow*               pWindowOwner = nullptr;
-
-    Vector2D               lastSize;
-
-    //
-    bool operator==(const SSurfaceTreeNode& rhs) const {
-        return pSurface == rhs.pSurface;
-    }
-};
-
-struct SSubsurface {
-    wlr_subsurface*   pSubsurface = nullptr;
-
-    SSurfaceTreeNode* pParent = nullptr;
-    SSurfaceTreeNode* pChild  = nullptr;
-
-    DYNLISTENER(map);
-    DYNLISTENER(unmap);
-    DYNLISTENER(destroy);
-
-    CWindow* pWindowOwner = nullptr;
-
-    //
-    bool operator==(const SSubsurface& rhs) const {
-        return pSubsurface == rhs.pSubsurface;
-    }
-};
-
-namespace SubsurfaceTree {
-    SSurfaceTreeNode*                  createTreeRoot(wlr_surface*, applyGlobalOffsetFn, void*, CWindow* pWindow = nullptr);
-    void                               destroySurfaceTree(SSurfaceTreeNode*);
-
-    inline std::list<SSurfaceTreeNode> surfaceTreeNodes;
-};

src/helpers/Vector2D.cpp

@@ -12,6 +12,11 @@ Vector2D::Vector2D() {
     y = 0;
 }
 
+Vector2D::Vector2D(const Hyprlang::VEC2& ref) {
+    x = ref.x;
+    y = ref.y;
+}
+
 Vector2D::~Vector2D() {}
 
 double Vector2D::normalize() {

src/helpers/Vector2D.hpp

@@ -3,12 +3,14 @@
 #include <cmath>
 #include <format>
 #include "../macros.hpp"
+#include <hyprlang.hpp>
 
 class Vector2D {
   public:
     Vector2D(double, double);
     Vector2D();
     ~Vector2D();
+    Vector2D(const Hyprlang::VEC2&);
 
     double x = 0;
     double y = 0;
@@ -88,7 +90,7 @@ class Vector2D {
 
     double   distance(const Vector2D& other) const;
     double   size() const;
-    Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D()) const;
+    Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D{-1, -1}) const;
 
     Vector2D floor() const;
     Vector2D round() const;

src/helpers/WLClasses.cpp

@@ -3,9 +3,19 @@
 #include "../Compositor.hpp"
 
 SLayerSurface::SLayerSurface() {
-    alpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_ENTIRE);
-    alpha.m_pLayer = this;
+    alpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), this, AVARDAMAGE_ENTIRE);
+    realPosition.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), this, AVARDAMAGE_ENTIRE);
+    realSize.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), this, AVARDAMAGE_ENTIRE);
     alpha.registerVar();
+    realPosition.registerVar();
+    realSize.registerVar();
+
+    alpha.setUpdateCallback([this](void*) {
+        if (dimAround)
+            g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(monitorID));
+    });
+
+    alpha.setValueAndWarp(0.f);
 }
 
 SLayerSurface::~SLayerSurface() {
@@ -21,13 +31,17 @@ void SLayerSurface::applyRules() {
     forceBlur        = false;
     ignoreAlpha      = false;
     ignoreAlphaValue = 0.f;
+    dimAround        = false;
     xray             = -1;
+    animationStyle.reset();
 
     for (auto& rule : g_pConfigManager->getMatchingRules(this)) {
         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      = "";
@@ -39,87 +53,237 @@ void SLayerSurface::applyRules() {
                 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];
         }
     }
 }
 
-CRegion SConstraint::getLogicCoordsRegion() {
-    CRegion result;
-
-    if (!constraint)
-        return result;
-
-    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
-
-    if (!PWINDOWOWNER)
-        return result;
-
-    result.add(&constraint->region); // surface-local coords
-
-    if (!PWINDOWOWNER->m_bIsX11) {
-        result.translate(PWINDOWOWNER->m_vRealPosition.goalv());
-        return result;
+void SLayerSurface::startAnimation(bool in, bool instant) {
+    const auto ANIMSTYLE = animationStyle.value_or(realPosition.m_pConfig->pValues->internalStyle);
+    if (in) {
+        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersIn");
+        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersIn");
+        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn");
+    } else {
+        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersOut");
+        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersOut");
+        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut");
     }
 
-    const auto COORDS = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealPosition.goalv() :
-                                                    g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y});
+    if (ANIMSTYLE.starts_with("slide")) {
+        // get closest edge
+        const auto MIDDLE = geometry.middle();
 
-    const auto PMONITOR = PWINDOWOWNER->m_bIsMapped ? g_pCompositor->getMonitorFromID(PWINDOWOWNER->m_iMonitorID) : g_pCompositor->getMonitorFromVector(COORDS);
+        const auto PMONITOR = g_pCompositor->getMonitorFromVector(MIDDLE);
 
-    if (!PMONITOR)
-        return CRegion{};
+        int        force = -1;
 
-    result.scale(PMONITOR->xwaylandScale);
+        CVarList   args(ANIMSTYLE, 0, 's');
+        if (args.size() > 1) {
+            const auto ARG2 = args[1];
+            if (ARG2 == "top")
+                force = 0;
+            else if (ARG2 == "bottom")
+                force = 1;
+            else if (ARG2 == "left")
+                force = 2;
+            else if (ARG2 == "right")
+                force = 3;
+        }
 
-    result.translate(COORDS);
+        const std::array<Vector2D, 4> edgePoints = {
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, 0},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, PMONITOR->vecSize.y},
+            PMONITOR->vecPosition + Vector2D{0, PMONITOR->vecSize.y},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x, PMONITOR->vecSize.y / 2},
+        };
 
-    return result;
+        float closest = std::numeric_limits<float>::max();
+        int   leader  = force;
+        if (leader == -1) {
+            for (size_t i = 0; i < 4; ++i) {
+                float dist = MIDDLE.distance(edgePoints[i]);
+                if (dist < closest) {
+                    leader  = i;
+                    closest = dist;
+                }
+            }
+        }
+
+        realSize.setValueAndWarp(geometry.size());
+        alpha.setValueAndWarp(in ? 0.f : 1.f);
+        alpha = in ? 1.f : 0.f;
+
+        Vector2D prePos;
+
+        switch (leader) {
+            case 0:
+                // TOP
+                prePos = {geometry.x, PMONITOR->vecPosition.y - geometry.h};
+                break;
+            case 1:
+                // BOTTOM
+                prePos = {geometry.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y};
+                break;
+            case 2:
+                // LEFT
+                prePos = {PMONITOR->vecPosition.x - geometry.w, geometry.y};
+                break;
+            case 3:
+                // RIGHT
+                prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, geometry.y};
+                break;
+            default: UNREACHABLE();
+        }
+
+        if (in) {
+            realPosition.setValueAndWarp(prePos);
+            realPosition = geometry.pos();
+        } else {
+            realPosition.setValueAndWarp(geometry.pos());
+            realPosition = prePos;
+        }
+
+    } else if (ANIMSTYLE.starts_with("popin")) {
+        float minPerc = 0.f;
+        if (ANIMSTYLE.find("%") != std::string::npos) {
+            try {
+                auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' '));
+                minPerc      = std::stoi(percstr.substr(0, percstr.length() - 1));
+            } catch (std::exception& e) {
+                ; // oops
+            }
+        }
+
+        minPerc *= 0.01;
+
+        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;
+
+        if (in) {
+            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;
+        }
+    } else {
+        // fade
+        realPosition.setValueAndWarp(geometry.pos());
+        realSize.setValueAndWarp(geometry.size());
+        alpha = in ? 1.f : 0.f;
+    }
+
+    if (!in)
+        fadingOut = true;
 }
 
-Vector2D SConstraint::getLogicConstraintPos() {
-    if (!constraint)
-        return {};
+bool SLayerSurface::isFadedOut() {
+    if (!fadingOut)
+        return false;
 
-    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
-
-    if (!PWINDOWOWNER)
-        return {};
-
-    if (!PWINDOWOWNER->m_bIsX11)
-        return PWINDOWOWNER->m_vRealPosition.goalv();
-
-    const auto COORDS = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealPosition.goalv() :
-                                                    g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y});
-
-    return COORDS;
+    return !realPosition.isBeingAnimated() && !realSize.isBeingAnimated() && !alpha.isBeingAnimated();
 }
 
-Vector2D SConstraint::getLogicConstraintSize() {
-    if (!constraint)
-        return {};
+int SLayerSurface::popupsCount() {
+    if (!layerSurface || !mapped || fadingOut)
+        return 0;
 
-    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
-
-    if (!PWINDOWOWNER)
-        return {};
-
-    if (!PWINDOWOWNER->m_bIsX11)
-        return PWINDOWOWNER->m_vRealSize.goalv();
-
-    const auto PMONITOR = PWINDOWOWNER->m_bIsMapped ?
-        g_pCompositor->getMonitorFromID(PWINDOWOWNER->m_iMonitorID) :
-        g_pCompositor->getMonitorFromVector(g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y}));
-
-    if (!PMONITOR)
-        return {};
-
-    const auto SIZE = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealSize.goalv() :
-                                                  Vector2D{PWINDOWOWNER->m_uSurface.xwayland->width, PWINDOWOWNER->m_uSurface.xwayland->height} * PMONITOR->xwaylandScale;
-
-    return SIZE;
+    int no = 0;
+    wlr_layer_surface_v1_for_each_popup_surface(
+        layerSurface, [](wlr_surface* s, int x, int y, void* data) { *(int*)data += 1; }, &no);
+    return no;
+}
+
+void SKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
+    xkb_state_unref(xkbTranslationState);
+
+    if (keymap) {
+        Debug::log(LOG, "Updating keyboard {:x}'s translation state from a provided keymap", (uintptr_t)this);
+        xkbTranslationState = xkb_state_new(keymap);
+        return;
+    }
+
+    const auto WLRKB      = wlr_keyboard_from_input_device(keyboard);
+    const auto KEYMAP     = WLRKB->keymap;
+    const auto STATE      = WLRKB->xkb_state;
+    const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
+
+    const auto PCONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+
+    for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
+        if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE)) {
+            Debug::log(LOG, "Updating keyboard {:x}'s translation state from an active index {}", (uintptr_t)this, i);
+
+            CVarList       keyboardLayouts(currentRules.layout, 0, ',');
+            CVarList       keyboardModels(currentRules.model, 0, ',');
+            CVarList       keyboardVariants(currentRules.variant, 0, ',');
+
+            xkb_rule_names rules = {.rules = "", .model = "", .layout = "", .variant = "", .options = ""};
+
+            std::string    layout, model, variant;
+            layout  = keyboardLayouts[i % keyboardLayouts.size()];
+            model   = keyboardModels[i % keyboardModels.size()];
+            variant = keyboardVariants[i % keyboardVariants.size()];
+
+            rules.layout  = layout.c_str();
+            rules.model   = model.c_str();
+            rules.variant = variant.c_str();
+
+            auto KEYMAP = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+            if (!KEYMAP) {
+                Debug::log(ERR, "updateXKBTranslationState: keymap failed 1, fallback without model/variant");
+                rules.model   = "";
+                rules.variant = "";
+                KEYMAP        = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            }
+
+            if (!KEYMAP) {
+                Debug::log(ERR, "updateXKBTranslationState: keymap failed 2, fallback to us");
+                rules.layout = "us";
+                KEYMAP       = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            }
+
+            xkbTranslationState = xkb_state_new(KEYMAP);
+
+            xkb_keymap_unref(KEYMAP);
+            xkb_context_unref(PCONTEXT);
+
+            return;
+        }
+    }
+
+    Debug::log(LOG, "Updating keyboard {:x}'s translation state from an unknown index", (uintptr_t)this);
+
+    xkb_rule_names rules = {
+        .rules   = currentRules.rules.c_str(),
+        .model   = currentRules.model.c_str(),
+        .layout  = currentRules.layout.c_str(),
+        .variant = currentRules.variant.c_str(),
+        .options = currentRules.options.c_str(),
+    };
+
+    const auto NEWKEYMAP = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+    xkbTranslationState = xkb_state_new(NEWKEYMAP);
+
+    xkb_keymap_unref(NEWKEYMAP);
+    xkb_context_unref(PCONTEXT);
 }

src/helpers/WLClasses.hpp

@@ -3,10 +3,11 @@
 #include "../events/Events.hpp"
 #include "../defines.hpp"
 #include "wlr-layer-shell-unstable-v1-protocol.h"
-#include "../Window.hpp"
-#include "SubsurfaceTree.hpp"
+#include "../desktop/Window.hpp"
+#include "../desktop/Subsurface.hpp"
+#include "../desktop/Popup.hpp"
 #include "AnimatedVariable.hpp"
-#include "WLSurface.hpp"
+#include "../desktop/WLSurface.hpp"
 #include "Region.hpp"
 
 struct SLayerRule {
@@ -19,6 +20,12 @@ struct SLayerSurface {
     ~SLayerSurface();
 
     void                        applyRules();
+    void                        startAnimation(bool in, bool instant = false);
+    bool                        isFadedOut();
+    int                         popupsCount();
+
+    CAnimatedVariable<Vector2D> realPosition;
+    CAnimatedVariable<Vector2D> realSize;
 
     wlr_layer_surface_v1*       layerSurface;
     wl_list                     link;
@@ -26,13 +33,14 @@ struct SLayerSurface {
     bool                        keyboardExclusive = false;
 
     CWLSurface                  surface;
-    std::list<CWLSurface> popupSurfaces;
+
+    // desktop components
+    std::unique_ptr<CPopup> popupHead;
 
     DYNLISTENER(destroyLayerSurface);
     DYNLISTENER(mapLayerSurface);
     DYNLISTENER(unmapLayerSurface);
     DYNLISTENER(commitLayerSurface);
-    DYNLISTENER(newPopup);
 
     CBox                       geometry = {0, 0, 0, 0};
     Vector2D                   position;
@@ -44,16 +52,20 @@ struct SLayerSurface {
 
     std::string                szNamespace = "";
 
-    CAnimatedVariable         alpha;
+    CAnimatedVariable<float>   alpha;
     bool                       fadingOut     = false;
     bool                       readyToDelete = false;
     bool                       noProcess     = false;
     bool                       noAnimations  = false;
 
     bool                       forceBlur        = false;
+    bool                       forceBlurPopups  = false;
     int                        xray             = -1;
     bool                       ignoreAlpha      = false;
     float                      ignoreAlphaValue = 0.f;
+    bool                       dimAround        = false;
+
+    std::optional<std::string> animationStyle;
 
     // For the list lookup
     bool operator==(const SLayerSurface& rhs) const {
@@ -128,6 +140,7 @@ struct SKeyboard {
     bool               enabled   = true;
 
     xkb_layout_index_t activeLayout        = 0;
+    xkb_state*         xkbTranslationState = nullptr;
 
     std::string        name        = "";
     std::string        xkbFilePath = "";
@@ -136,6 +149,9 @@ struct SKeyboard {
     int                repeatRate        = 0;
     int                repeatDelay       = 0;
     int                numlockOn         = -1;
+    bool               resolveBindsBySym = false;
+
+    void               updateXKBTranslationState(xkb_keymap* const keymap = nullptr);
 
     // For the list lookup
     bool operator==(const SKeyboard& rhs) const {
@@ -146,18 +162,12 @@ struct SKeyboard {
 struct SMouse {
     wlr_input_device* mouse = nullptr;
 
-    wlr_pointer_constraint_v1* currentConstraint = nullptr;
-    bool                       constraintActive  = false;
-
-    CRegion                    confinedTo;
-
     std::string       name = "";
 
     bool              virt = false;
 
     bool              connected = false; // means connected to the cursor
 
-    DYNLISTENER(commitConstraint);
     DYNLISTENER(destroyMouse);
 
     bool operator==(const SMouse& b) const {
@@ -165,59 +175,8 @@ struct SMouse {
     }
 };
 
-struct SConstraint {
-    SMouse*                    pMouse     = nullptr;
-    wlr_pointer_constraint_v1* constraint = nullptr;
-
-    bool                       active = false;
-
-    bool                       hintSet             = false;
-    Vector2D                   positionHint        = {-1, -1}; // the position hint, but will use cursorPosOnActivate if unset
-    Vector2D                   cursorPosOnActivate = {-1, -1};
-
-    DYNLISTENER(setConstraintRegion);
-    DYNLISTENER(destroyConstraint);
-
-    CRegion  getLogicCoordsRegion();
-    Vector2D getLogicConstraintPos();
-    Vector2D getLogicConstraintSize();
-
-    //
-    bool operator==(const SConstraint& b) const {
-        return constraint == b.constraint;
-    }
-};
-
 class CMonitor;
 
-struct SXDGPopup {
-    CWindow*       parentWindow = nullptr;
-    SLayerSurface* parentLS     = nullptr;
-    SXDGPopup*     parentPopup  = nullptr;
-    wlr_xdg_popup* popup        = nullptr;
-    CMonitor*      monitor      = nullptr;
-
-    DYNLISTENER(newPopupFromPopupXDG);
-    DYNLISTENER(destroyPopupXDG);
-    DYNLISTENER(mapPopupXDG);
-    DYNLISTENER(unmapPopupXDG);
-    DYNLISTENER(commitPopupXDG);
-    DYNLISTENER(repositionPopupXDG);
-
-    double            lx;
-    double            ly;
-
-    Vector2D          lastPos             = {};
-    bool              repositionRequested = false;
-
-    SSurfaceTreeNode* pSurfaceTree = nullptr;
-
-    // For the list lookup
-    bool operator==(const SXDGPopup& rhs) const {
-        return popup == rhs.popup;
-    }
-};
-
 struct SSeat {
     wlr_seat*  seat            = nullptr;
     wl_client* exclusiveClient = nullptr;
@@ -259,6 +218,10 @@ struct STablet {
 
     std::string           name = "";
 
+    std::string           boundOutput = "";
+
+    CBox                  activeArea;
+
     //
     bool operator==(const STablet& b) const {
         return wlrDevice == b.wlrDevice;
@@ -309,6 +272,7 @@ struct STabletPad {
 struct SIdleInhibitor {
     wlr_idle_inhibitor_v1* pWlrInhibitor   = nullptr;
     CWindow*               pWindow         = nullptr;
+    HOOK_CALLBACK_FN*      onWindowDestroy = nullptr;
 
     DYNLISTENER(Destroy);
 
@@ -318,33 +282,18 @@ struct SIdleInhibitor {
 };
 
 struct SSwipeGesture {
-    CWorkspace* pWorkspaceBegin = nullptr;
+    PHLWORKSPACE pWorkspaceBegin = nullptr;
 
     double       delta = 0;
 
     int          initialDirection = 0;
     float        avgSpeed         = 0;
     int          speedPoints      = 0;
+    int          touch_id         = 0;
 
     CMonitor*    pMonitor = nullptr;
 };
 
-struct STextInputV1;
-
-struct STextInput {
-    wlr_text_input_v3* pWlrInput = nullptr;
-    STextInputV1*      pV1Input  = nullptr;
-
-    wlr_surface*       pPendingSurface = nullptr;
-
-    DYNLISTENER(textInputEnable);
-    DYNLISTENER(textInputDisable);
-    DYNLISTENER(textInputCommit);
-    DYNLISTENER(textInputDestroy);
-
-    DYNLISTENER(pendingSurfaceDestroy);
-};
-
 struct SIMEKbGrab {
     wlr_input_method_keyboard_grab_v2* pWlrKbGrab = nullptr;
 
@@ -353,26 +302,6 @@ struct SIMEKbGrab {
     DYNLISTENER(grabDestroy);
 };
 
-struct SIMEPopup {
-    wlr_input_popup_surface_v2* pSurface = nullptr;
-
-    int                         x, y;
-    int                         realX, realY;
-    bool                        visible;
-    Vector2D                    lastSize;
-
-    DYNLISTENER(mapPopup);
-    DYNLISTENER(unmapPopup);
-    DYNLISTENER(destroyPopup);
-    DYNLISTENER(commitPopup);
-
-    DYNLISTENER(focusedSurfaceUnmap);
-
-    bool operator==(const SIMEPopup& other) const {
-        return pSurface == other.pSurface;
-    }
-};
-
 struct STouchDevice {
     wlr_input_device* pWlrDevice = nullptr;
 
@@ -406,7 +335,17 @@ struct STearingController {
     DYNLISTENER(set);
     DYNLISTENER(destroy);
 
-    bool operator==(const STearingController& other) {
+    bool operator==(const STearingController& other) const {
         return pWlrHint == other.pWlrHint;
     }
 };
+
+struct SShortcutInhibitor {
+    wlr_keyboard_shortcuts_inhibitor_v1* pWlrInhibitor = nullptr;
+
+    DYNLISTENER(destroy);
+
+    bool operator==(const SShortcutInhibitor& other) const {
+        return pWlrInhibitor == other.pWlrInhibitor;
+    }
+};

src/helpers/WLSurface.cpp

@@ -1,87 +0,0 @@
-#include "WLSurface.hpp"
-#include "../Compositor.hpp"
-
-CWLSurface::CWLSurface(wlr_surface* pSurface) {
-    m_pWLRSurface = pSurface;
-    init();
-}
-
-void CWLSurface::assign(wlr_surface* pSurface) {
-    m_pWLRSurface = pSurface;
-    init();
-}
-
-void CWLSurface::unassign() {
-    destroy();
-}
-
-CWLSurface::~CWLSurface() {
-    destroy();
-}
-
-bool CWLSurface::exists() const {
-    return m_pWLRSurface;
-}
-
-wlr_surface* CWLSurface::wlr() const {
-    return m_pWLRSurface;
-}
-
-bool CWLSurface::small() const {
-    if (!m_pOwner || !exists())
-        return false;
-
-    return m_pOwner->m_vReportedSize.x > m_pWLRSurface->current.buffer_width + 1 || m_pOwner->m_vReportedSize.y > m_pWLRSurface->current.buffer_height + 1;
-}
-
-Vector2D CWLSurface::correctSmallVec() const {
-    if (!m_pOwner || !exists() || !small() || m_bFillIgnoreSmall)
-        return {};
-
-    const auto SIZE = getViewporterCorrectedSize();
-
-    return Vector2D{(m_pOwner->m_vReportedSize.x - SIZE.x) / 2, (m_pOwner->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) *
-        (m_pOwner->m_vRealSize.vec() / m_pOwner->m_vReportedSize);
-}
-
-Vector2D CWLSurface::getViewporterCorrectedSize() const {
-    if (!exists())
-        return {};
-
-    return m_pWLRSurface->current.viewport.has_dst ? Vector2D{m_pWLRSurface->current.viewport.dst_width, m_pWLRSurface->current.viewport.dst_height} :
-                                                     Vector2D{m_pWLRSurface->current.buffer_width, m_pWLRSurface->current.buffer_height};
-}
-
-void CWLSurface::destroy() {
-    if (!m_pWLRSurface)
-        return;
-
-    hyprListener_destroy.removeCallback();
-    m_pWLRSurface->data = nullptr;
-    m_pOwner            = nullptr;
-
-    if (g_pCompositor->m_pLastFocus == m_pWLRSurface)
-        g_pCompositor->m_pLastFocus = nullptr;
-    if (g_pInputManager->m_pLastMouseSurface == m_pWLRSurface)
-        g_pInputManager->m_pLastMouseSurface = nullptr;
-    if (g_pHyprRenderer->m_sLastCursorData.surf == m_pWLRSurface)
-        g_pHyprRenderer->m_sLastCursorData.surf.reset();
-
-    m_pWLRSurface = nullptr;
-
-    Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this);
-}
-
-void CWLSurface::init() {
-    if (!m_pWLRSurface)
-        return;
-
-    RASSERT(!m_pWLRSurface->data, "Attempted to duplicate CWLSurface ownership!");
-
-    m_pWLRSurface->data = this;
-
-    hyprListener_destroy.initCallback(
-        &m_pWLRSurface->events.destroy, [&](void* owner, void* data) { destroy(); }, this, "CWLSurface");
-
-    Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
-}

src/helpers/Watchdog.cpp

@@ -1,6 +1,7 @@
 #include "Watchdog.hpp"
 #include <signal.h>
 #include "config/ConfigManager.hpp"
+#include "../config/ConfigValue.hpp"
 
 CWatchdog::~CWatchdog() {
     m_bExitThread = true;
@@ -13,7 +14,7 @@ CWatchdog::CWatchdog() {
     m_iMainThreadPID = pthread_self();
 
     m_pWatchdog = std::make_unique<std::thread>([this] {
-        static auto* const PTIMEOUT = &g_pConfigManager->getConfigValuePtr("debug:watchdog_timeout")->intValue;
+        static auto PTIMEOUT = CConfigValue<Hyprlang::INT>("debug:watchdog_timeout");
 
         while (1337) {
             std::unique_lock lk(m_mWatchdogMutex);
@@ -37,7 +38,7 @@ CWatchdog::CWatchdog() {
 }
 
 void CWatchdog::startWatching() {
-    static auto* const PTIMEOUT = &g_pConfigManager->getConfigValuePtr("debug:watchdog_timeout")->intValue;
+    static auto PTIMEOUT = CConfigValue<Hyprlang::INT>("debug:watchdog_timeout");
 
     if (*PTIMEOUT == 0)
         return;